@agentunion/fastaun-browser 0.5.18 → 0.5.20

package/dist/org-protocol.js

@@ -0,0 +1,1802 @@
+import { canonicalJson as baseCanonicalJson } from './v2/crypto/canonical.js';
+import { uint8ToBase64 } from './crypto.js';
+import { certFingerprint, parseCertMetadata, publicKeyDerB64, publicKeyFingerprint, verifySignatureWithCert } from './cert-utils.js';
+const AID_RE = /^[^\s/]+\.[^\s/]+$/;
+const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+const BASE64_RE = /^[A-Za-z0-9+/]+={0,2}$/;
+const ERROR_RETRYABLE = { CREDENTIAL_STATUS_UNKNOWN: true };
+const CREDENTIAL_FIELDS = new Set([
+    'ver', 'cid', 'iat', 'iss', 'sub', 'aud', 'nbf', 'exp', 'cap', 'delegate',
+    'delegation_depth', 'parent', 'proof_chain', 'key_version', 'security_level',
+    'revocation_endpoint', 'credential_service', 'ext', 'signature',
+]);
+const CAP_FIELDS = new Set(['ns', 'action', 'resource', 'constraints']);
+const SIGNATURE_FIELDS = new Set(['cert_fingerprint', 'public_key_fingerprint', 'timestamp', 'signature']);
+const BINDING_FIELDS = new Set([
+    'ver', 'membership_id', 'binding_version', 'org_id', 'member_aid', 'member_type',
+    'category', 'role', 'ownership', 'visibility', 'terms_hash', 'request_id', 'nonce',
+    'iat', 'exp', 'member_signature', 'org_signature',
+]);
+const RECEIPT_FIELDS = new Set([
+    'ver', 'receipt_id', 'request_id', 'credential_cid', 'credential_hash',
+    'registrar_aid', 'service_aid', 'status', 'registered_at', 'exp', 'nonce', 'signature', 'registration_authorization',
+]);
+const REPRESENTATION_FIELDS = new Set([
+    'issuer', 'represented', 'from', 'for', 'audience', 'credential_cid', 'method',
+    'resource', 'params_hash', 'iat', 'exp', 'nonce', 'signature',
+]);
+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;
+    constructor(code, message = code) {
+        super(`${code}: ${message}`);
+        this.name = 'ProtocolError';
+        this.code = code;
+        this.retryable = protocolErrorRetryable(code);
+    }
+}
+export async function verifyServiceEvent(eventName, payload, context) {
+    const event = eventName.startsWith('event/') ? eventName.slice(6) : eventName;
+    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)))
+        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 (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 (!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 {
+            service = await context.resolveCredentialService?.(cid);
+        }
+        catch {
+            throw invalid('trusted credential authority is unavailable');
+        }
+        known = service != null;
+        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
+        throw invalid('service event namespace is invalid');
+    try {
+        signature(payload.signature);
+        const signed = payload.signature;
+        if (signed.timestamp !== payload.as_of || typeof context.resolveEventCertificate !== 'function')
+            throw new Error('service event signature context is invalid');
+        const body = { ...payload };
+        delete body.signature;
+        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');
+    }
+    if ((context.now ?? Math.trunc(Date.now() / 1000)) >= payload.expires_at)
+        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;
+}
+function invalid(message) {
+    return new ProtocolError('CREDENTIAL_INVALID', message);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isInt(value) {
+    return typeof value === 'number' && Number.isInteger(value) && Number.isSafeInteger(value);
+}
+function certificatePem(value) {
+    if (typeof value === 'string' && value.includes('-----BEGIN CERTIFICATE-----'))
+        return value;
+    const encoded = typeof value === 'string' ? value : value instanceof Uint8Array ? uint8ToBase64(value) : '';
+    if (!encoded || encoded.length % 4 !== 0 || !BASE64_RE.test(encoded) || btoa(atob(encoded)) !== encoded)
+        throw new Error('certificate encoding is invalid');
+    return '-----BEGIN CERTIFICATE-----\n' + encoded + '\n-----END CERTIFICATE-----';
+}
+function required(obj, fields) {
+    const missing = [...fields].filter((field) => !(field in obj));
+    if (missing.length > 0)
+        throw invalid(`missing fields: ${missing.sort().join(',')}`);
+}
+function onlyKnown(obj, allowed) {
+    const unknown = Object.keys(obj).filter((field) => !allowed.has(field));
+    if (unknown.length > 0)
+        throw invalid(`unknown fields: ${unknown.sort().join(',')}`);
+}
+function aid(value, field) {
+    if (typeof value !== 'string' || value.length === 0 || !AID_RE.test(value)) {
+        throw invalid(`${field} must be an AID`);
+    }
+}
+function signature(value, field = 'signature') {
+    if (!isRecord(value) || !['cert_fingerprint', 'timestamp', 'signature'].every((key) => key in value) || Object.keys(value).some((key) => !SIGNATURE_FIELDS.has(key))) {
+        throw invalid(`${field} is invalid`);
+    }
+    if (typeof value.cert_fingerprint !== 'string' || !FINGERPRINT_RE.test(value.cert_fingerprint)) {
+        throw invalid(`${field} is invalid`);
+    }
+    if (value.public_key_fingerprint !== undefined && (typeof value.public_key_fingerprint !== 'string' || !FINGERPRINT_RE.test(value.public_key_fingerprint)))
+        throw invalid(`${field} is invalid`);
+    if (!isInt(value.timestamp) || value.timestamp < 0)
+        throw invalid(`${field} is invalid`);
+    if (typeof value.signature !== 'string' || !strictDerBase64(value.signature))
+        throw invalid(`${field} is invalid`);
+}
+function strictDerBase64(value) {
+    if (!value || value.length % 4 !== 0 || !BASE64_RE.test(value))
+        return false;
+    let decodedText;
+    try {
+        decodedText = atob(value);
+    }
+    catch {
+        return false;
+    }
+    try {
+        if (btoa(decodedText) !== value)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const decoded = Uint8Array.from(decodedText, (char) => char.charCodeAt(0));
+    if (decoded.length < 8 || decoded[0] !== 0x30)
+        return false;
+    const outer = derLength(decoded, 1);
+    if (!outer || outer.length !== decoded.length - outer.pos)
+        return false;
+    let pos = outer.pos;
+    for (let i = 0; i < 2; i++) {
+        if (pos >= decoded.length || decoded[pos] !== 0x02)
+            return false;
+        const item = derLength(decoded, pos + 1);
+        if (!item || item.length < 1 || item.length > 33 || item.pos + item.length > decoded.length)
+            return false;
+        const first = decoded[item.pos];
+        if (first === 0 && (item.length === 1 || decoded[item.pos + 1] < 0x80))
+            return false;
+        if ((first & 0x80) !== 0)
+            return false;
+        pos = item.pos + item.length;
+    }
+    return pos === decoded.length;
+}
+function derLength(data, pos) {
+    if (pos >= data.length)
+        return null;
+    const first = data[pos];
+    pos += 1;
+    if (first < 0x80)
+        return { length: first, pos };
+    const count = first & 0x7f;
+    if (count === 0 || count > 2 || pos + count > data.length || data[pos] === 0)
+        return null;
+    let length = 0;
+    for (let i = 0; i < count; i++)
+        length = length * 256 + data[pos + i];
+    if (length < 0x80)
+        return null;
+    return { length, pos: pos + count };
+}
+function normalizeNfc(value) {
+    if (typeof value === 'string') {
+        for (const char of value)
+            if (char.codePointAt(0) >= 0xd800 && char.codePointAt(0) <= 0xdfff)
+                throw invalid('isolated surrogate is invalid');
+        return value.normalize('NFC');
+    }
+    if (Array.isArray(value))
+        return value.map(normalizeNfc);
+    if (value !== null && typeof value === 'object') {
+        const out = Object.create(null);
+        for (const [key, item] of Object.entries(value)) {
+            const normalized = normalizeNfc(key);
+            if (Object.hasOwn(out, normalized))
+                throw invalid('duplicate NFC object key');
+            out[normalized] = normalizeNfc(item);
+        }
+        return out;
+    }
+    if (value === null || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER)
+        return value;
+    throw invalid('unsafe or unsupported JSON value');
+}
+export function validateOrgRequestJSON(value) {
+    if (typeof value === 'string') {
+        for (const char of value)
+            if (char.codePointAt(0) >= 0xd800 && char.codePointAt(0) <= 0xdfff)
+                throw invalid('isolated surrogate is invalid');
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value)
+            validateOrgRequestJSON(item);
+    }
+    else if (isRecord(value)) {
+        for (const [key, item] of Object.entries(value)) {
+            validateOrgRequestJSON(key);
+            validateOrgRequestJSON(item);
+        }
+    }
+}
+export function canonicalJson(value) {
+    return baseCanonicalJson(normalizeNfc(value));
+}
+const CONSTRAINT_OPERATORS = { max_value: 'lte', min_value: 'gte', allowed_values: 'in', denied_values: 'not_in', range: 'between', regex: 'match', path_prefix: 'prefix', time_window: 'between', rate_limit: 'lte', ip_whitelist: 'in' };
+function canonicalPath(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    let value;
+    try {
+        value = decodeURIComponent(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!value.startsWith('/') || /[\\\x00%]/u.test(value) || value.includes('//') || value.split('/').some((part) => part === '.' || part === '..'))
+        return undefined;
+    return value.length > 1 ? value.replace(/\/$/u, '') : value;
+}
+function constraintIP(raw) {
+    if (typeof raw !== 'string' || raw.includes('%'))
+        return undefined;
+    const parts = raw.split('/');
+    if (parts.length > 2)
+        return undefined;
+    let value = parts[0];
+    const ipv4 = (text) => {
+        const octets = text.split('.');
+        if (octets.length !== 4 || octets.some((part) => !/^(0|[1-9][0-9]{0,2})$/u.test(part) || Number(part) > 255))
+            return undefined;
+        return octets.map(Number);
+    };
+    let bits;
+    let address = 0n;
+    if (!value.includes(':')) {
+        const octets = ipv4(value);
+        if (!octets)
+            return undefined;
+        bits = 32;
+        for (const octet of octets)
+            address = address * 256n + BigInt(octet);
+    }
+    else {
+        bits = 128;
+        if (value.includes('.')) {
+            const end = value.lastIndexOf(':');
+            const octets = ipv4(value.slice(end + 1));
+            if (!octets)
+                return undefined;
+            value = value.slice(0, end + 1) + ((octets[0] * 256 + octets[1]).toString(16)) + ':' + ((octets[2] * 256 + octets[3]).toString(16));
+        }
+        const halves = value.split('::');
+        if (halves.length > 2)
+            return undefined;
+        const left = halves[0] ? halves[0].split(':') : [];
+        const right = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+        if ([...left, ...right].some((part) => !/^[0-9a-fA-F]{1,4}$/u.test(part)))
+            return undefined;
+        if (halves.length === 1 && left.length !== 8 || halves.length === 2 && left.length + right.length >= 8)
+            return undefined;
+        const groups = halves.length === 1 ? left : [...left, ...Array(8 - left.length - right.length).fill('0'), ...right];
+        for (const group of groups)
+            address = address * 65536n + BigInt(Number.parseInt(group, 16));
+    }
+    const prefix = parts.length === 1 ? bits : /^[0-9]+$/u.test(parts[1]) ? Number(parts[1]) : -1;
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > bits)
+        return undefined;
+    const shift = BigInt(bits - prefix);
+    return { bits, prefix, address: (address >> shift) << shift };
+}
+function validConstraintRegex(value) {
+    if (typeof value !== 'string' || new TextEncoder().encode(value).length > 256 || value.length < 2 || !value.startsWith('^') || !value.endsWith('$'))
+        return false;
+    let inside = false;
+    let repeats = 0;
+    for (let index = 1; index < value.length - 1; index++) {
+        const char = value[index];
+        if (char === '\\') {
+            index++;
+            if (index >= value.length - 1 || !'dDwW\\[]{}*+?^$-.nrtf'.includes(value[index]) || value[index] === '-' && !inside)
+                return false;
+            continue;
+        }
+        if (char === '[') {
+            if (inside)
+                return false;
+            inside = true;
+            continue;
+        }
+        if (char === ']') {
+            if (!inside)
+                return false;
+            inside = false;
+            continue;
+        }
+        if (inside) {
+            if (['&&', '--', '~~'].includes(value.slice(index, index + 2)))
+                return false;
+            continue;
+        }
+        if ('()|.^$'.includes(char))
+            return false;
+        if ('*+?'.includes(char))
+            repeats++;
+        if (char === '{') {
+            const end = value.indexOf('}', index);
+            if (end < 0)
+                return false;
+            const bounds = value.slice(index + 1, end).split(',');
+            if (bounds.length > 2 || bounds.some((bound) => !/^[0-9]+$/u.test(bound) || Number(bound) > 128) || bounds.length === 2 && Number(bounds[0]) > Number(bounds[1]))
+                return false;
+            index = end;
+            repeats++;
+        }
+        if (repeats > 1)
+            return false;
+    }
+    try {
+        new RegExp(value, 'u');
+    }
+    catch {
+        return false;
+    }
+    return !inside;
+}
+function validateCapability(capability) {
+    const constraints = capability.constraints;
+    if (!Array.isArray(constraints) || constraints.length > 64)
+        throw invalid('capability constraints are invalid');
+    const groups = new Map();
+    const number = (value) => typeof value === 'number' && Number.isFinite(value);
+    for (const item of constraints) {
+        if (!isRecord(item) || !['type', 'field', 'value'].every((field) => field in item) || Object.keys(item).some((field) => !['type', 'field', 'value', 'unit', 'operator'].includes(field)))
+            throw invalid('constraint fields are invalid');
+        const kind = item.type;
+        const field = item.field;
+        const unit = item.unit ?? '';
+        if (typeof kind !== 'string' || !Object.hasOwn(CONSTRAINT_OPERATORS, kind) || typeof field !== 'string' || field.length > 128 || !/^[A-Za-z_][A-Za-z0-9_.]*$/u.test(field) || field.includes('..') || field.endsWith('.'))
+            throw invalid('constraint type or field is invalid');
+        if ('operator' in item && item.operator !== CONSTRAINT_OPERATORS[kind])
+            throw invalid('constraint operator is invalid');
+        if ('unit' in item && (typeof unit !== 'string' || unit.length === 0 || new TextEncoder().encode(unit).length > 32))
+            throw invalid('constraint unit is invalid');
+        const key = field + '\x00' + constraintUnit(item);
+        let group = groups.get(key);
+        if (!group) {
+            group = { lower: -Infinity, upper: Infinity, denied: new Set(), timeFrom: '00:00', timeTo: '24:00', field };
+            groups.set(key, group);
+        }
+        const value = item.value;
+        switch (kind) {
+            case 'max_value':
+            case 'min_value':
+            case 'rate_limit':
+                if (!number(value))
+                    throw invalid('constraint value must be numeric');
+                if (kind === 'rate_limit') {
+                    if (!Number.isSafeInteger(value) || value <= 0 || !['', 'second', 'minute', 'hour', 'day'].includes(unit))
+                        throw invalid('rate limit is invalid');
+                }
+                else if (kind === 'max_value')
+                    group.upper = Math.min(group.upper, value);
+                else
+                    group.lower = Math.max(group.lower, value);
+                break;
+            case 'range':
+                if (!Array.isArray(value) || value.length !== 2 || !number(value[0]) || !number(value[1]) || value[0] > value[1])
+                    throw invalid('range is invalid');
+                group.lower = Math.max(group.lower, value[0]);
+                group.upper = Math.min(group.upper, value[1]);
+                break;
+            case 'allowed_values':
+            case 'denied_values': {
+                if (!Array.isArray(value) || value.length < 1 || value.length > 64 || unit || value.some((entry) => entry !== null && typeof entry === 'object'))
+                    throw invalid('enumeration constraint is invalid');
+                const values = new Set(value.map(canonicalText));
+                if (values.size !== value.length)
+                    throw invalid('enumeration contains duplicates');
+                if (kind === 'denied_values')
+                    for (const entry of values)
+                        group.denied.add(entry);
+                else if (!group.allowed)
+                    group.allowed = values;
+                else
+                    for (const entry of group.allowed)
+                        if (!values.has(entry))
+                            group.allowed.delete(entry);
+                break;
+            }
+            case 'regex':
+                if (unit || !validConstraintRegex(value))
+                    throw invalid('regex is outside the supported subset');
+                break;
+            case 'path_prefix': {
+                const path = canonicalPath(value);
+                if (unit || typeof value !== 'string' || new TextEncoder().encode(value).length > 1024 || path === undefined || path !== (value.replace(/\/$/u, '') || '/'))
+                    throw invalid('path prefix is invalid');
+                if (group.path === undefined || group.path === '/' || path === group.path || path.startsWith(group.path + '/'))
+                    group.path = path;
+                else if (path !== '/' && !group.path.startsWith(path + '/'))
+                    throw invalid('capability path prefixes conflict');
+                break;
+            }
+            case 'time_window':
+                if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== 'string' || typeof value[1] !== 'string' || !['', 'UTC'].includes(unit) || !/^([01][0-9]|2[0-3]):[0-5][0-9]$/u.test(value[0]) || !(/^([01][0-9]|2[0-3]):[0-5][0-9]$/u.test(value[1]) || value[1] === '24:00') || value[0] >= value[1])
+                    throw invalid('time window is invalid');
+                if (value[0] > group.timeFrom)
+                    group.timeFrom = value[0];
+                if (value[1] < group.timeTo)
+                    group.timeTo = value[1];
+                break;
+            case 'ip_whitelist': {
+                if (!Array.isArray(value) || value.length < 1 || value.length > 64 || unit || value.some((entry) => !constraintIP(entry)))
+                    throw invalid('IP whitelist is invalid');
+                const networks = value.map((entry) => constraintIP(entry));
+                if (!group.ips)
+                    group.ips = networks;
+                else {
+                    const intersection = new Map();
+                    for (const left of group.ips)
+                        for (const right of networks) {
+                            if (left.bits !== right.bits)
+                                continue;
+                            const prefix = Math.min(left.prefix, right.prefix);
+                            const shift = BigInt(left.bits - prefix);
+                            if (left.address >> shift === right.address >> shift) {
+                                const narrower = left.prefix >= right.prefix ? left : right;
+                                intersection.set(`${narrower.bits}/${narrower.prefix}/${narrower.address}`, narrower);
+                            }
+                        }
+                    group.ips = [...intersection.values()];
+                }
+                break;
+            }
+        }
+    }
+    for (const group of groups.values()) {
+        if (group.lower > group.upper || group.timeFrom >= group.timeTo || group.ips?.length === 0)
+            throw invalid('capability constraints conflict');
+        if (group.allowed) {
+            for (const entry of group.allowed)
+                if (group.denied.has(entry) || constraints.some((item) => isRecord(item) && item.field === group.field && item.type !== 'rate_limit' && !constraintSatisfied(item, parseJsonStrict(entry))))
+                    group.allowed.delete(entry);
+            if (!group.allowed.size)
+                throw invalid('capability constraints conflict');
+        }
+    }
+    const ns = capability.ns;
+    const action = capability.action;
+    const resource = capability.resource;
+    if (/[*?]/u.test(ns) || /[*?]/u.test(action) && action !== '*' || /[*?]/u.test(resource) && resource !== '*' || action === '*' && resource === '*')
+        throw invalid('wildcard scope is invalid');
+    if (action === '*') {
+        const bounded = constraints.some((item) => isRecord(item) && item.type === 'allowed_values' && item.field === 'operation' && item.value.every((entry) => ['get', 'list', 'read', 'usage'].includes(entry)));
+        if (!bounded || ns === 'org')
+            throw invalid('wildcard action requires an explicit read-only set');
+    }
+    if (resource === '*') {
+        const bounded = constraints.some((item) => isRecord(item) && item.field === 'resource' && ['path_prefix', 'allowed_values'].includes(item.type));
+        if (!bounded || !['get', 'list', 'read', 'usage'].includes(action.split('.').at(-1)))
+            throw invalid('wildcard resource requires a bounded read-only scope');
+    }
+}
+export function validateCredential(credential, chainDepth = 0, externalProofChain) {
+    if (!isRecord(credential))
+        throw invalid('credential must be an object');
+    normalizeNfc(credential);
+    onlyKnown(credential, CREDENTIAL_FIELDS);
+    required(credential, new Set(['ver', 'cid', 'iat', 'iss', 'sub', 'aud', 'nbf', 'exp', 'cap', 'key_version', 'signature']));
+    if (credential.ver !== 'aun-cap/1' || typeof credential.cid !== 'string' || credential.cid.length === 0) {
+        throw invalid('credential version or cid is invalid');
+    }
+    aid(credential.iss, 'iss');
+    aid(credential.sub, 'sub');
+    if (!isInt(credential.iat) || !isInt(credential.nbf) || !isInt(credential.exp))
+        throw invalid('credential timestamps must be integers');
+    if (credential.iat > credential.nbf || credential.exp <= credential.nbf)
+        throw invalid('credential time window is invalid');
+    if (!Array.isArray(credential.aud) || credential.aud.length === 0)
+        throw invalid('aud must be a non-empty array');
+    for (const audience of credential.aud)
+        aid(audience, 'aud');
+    if (!Array.isArray(credential.cap) || credential.cap.length === 0)
+        throw invalid('cap must be a non-empty array');
+    for (const capability of credential.cap) {
+        if (!isRecord(capability) || Object.keys(capability).length !== CAP_FIELDS.size || Object.keys(capability).some((key) => !CAP_FIELDS.has(key)))
+            throw invalid('cap item is invalid');
+        for (const field of ['ns', 'action', 'resource'])
+            if (typeof capability[field] !== 'string' || capability[field].length === 0)
+                throw invalid('cap item is invalid');
+        if (!Array.isArray(capability.constraints))
+            throw invalid('cap constraints must be an array');
+        validateCapability(capability);
+    }
+    if ('delegate' in credential && typeof credential.delegate !== 'boolean')
+        throw invalid('delegate must be boolean');
+    const delegationDepth = 'delegation_depth' in credential ? credential.delegation_depth : 0;
+    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) {
+        if (!('delegation_depth' in credential))
+            throw invalid('child delegation_depth is required');
+        if (typeof parent !== 'string' || parent.length === 0)
+            throw invalid('parent is invalid');
+        const chain = credential.proof_chain ?? externalProofChain;
+        if (!Array.isArray(chain) || chain.length === 0)
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'proof_chain is required');
+        if (chain.length > 8 || chainDepth >= 8)
+            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)))
+                throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'embedded proof_chain conflicts with outer chain');
+        }
+    }
+    else if ('proof_chain' in credential && JSON.stringify(credential.proof_chain) !== '[]') {
+        throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'root proof_chain must be empty');
+    }
+    if ('security_level' in credential && !['low', 'medium', 'high'].includes(credential.security_level))
+        throw invalid('security_level is invalid');
+    if (typeof credential.key_version !== 'string' || credential.key_version.length === 0)
+        throw invalid('key_version is invalid');
+    if ('ext' in credential && (!isRecord(credential.ext) || Object.keys(credential.ext).some((key) => typeof key !== 'string')))
+        throw invalid('ext is invalid');
+    const ext = (credential.ext ?? {});
+    if (ext.credential_type === 'archive') {
+        aid(ext.org_id, 'archive org_id');
+        if ('bound_to_membership' in ext && ext.bound_to_membership !== false || !Array.isArray(ext.audit_fields) || !ext.audit_fields.length || ext.audit_fields.some((field) => typeof field !== 'string' || !field))
+            throw invalid('archive credential requires independent, explicit audit fields');
+        const window = ext.audit_window;
+        const start = isRecord(window) ? auditScopeTime(window.from) : undefined;
+        const end = isRecord(window) ? auditScopeTime(window.to) : undefined;
+        if (start === undefined || end === undefined || end < start)
+            throw invalid('archive audit window must have explicit bounds');
+        if (!credential.aud.includes(ext.org_id) || credential.cap.some((cap) => !isRecord(cap) || cap.ns !== 'org' || cap.action !== 'role.auditor' || cap.resource !== ext.org_id))
+            throw invalid('archive credential must grant only organization audit reads');
+    }
+    signature(credential.signature);
+}
+export async function createCredential(options, signer) {
+    if (!isRecord(options) || 'signature' in options)
+        throw invalid('credential creation requires an unsigned object');
+    const value = structuredClone(options);
+    const now = Math.trunc(Date.now() / 1000);
+    const cid = 'cred-' + [...crypto.getRandomValues(new Uint8Array(16))].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+    const defaults = { ver: 'aun-cap/1', cid, iat: now, iss: signer.aid, delegate: false, proof_chain: [] };
+    for (const [key, item] of Object.entries(defaults))
+        if (!(key in value))
+            value[key] = item;
+    if (!('nbf' in value))
+        value.nbf = value.iat;
+    if (value.iss !== signer.aid)
+        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 (!('delegation_depth' in value))
+        value.delegation_depth = value.parent !== undefined && value.parent !== null && isInt(parentDepth) ? parentDepth + 1 : 0;
+    if (Array.isArray(value.cap))
+        for (const item of value.cap)
+            if (isRecord(item) && !('constraints' in item))
+                item.constraints = [];
+    if (!isInt(value.iat) || !isInt(value.exp) || value.iat > now || value.exp <= now)
+        throw invalid('credential signing time is outside its validity window');
+    const result = await signer.sign(canonicalJson(value));
+    if (!result.ok)
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'credential signing failed');
+    value.signature = { cert_fingerprint: signer.certFingerprint, timestamp: now, signature: result.data.signature };
+    credentialChainDocuments(value);
+    await verifyCredentialSignature(value, (fingerprint) => fingerprint === signer.certFingerprint ? signer.certPem : null);
+    return value;
+}
+function organizationIdentifier() { return [...crypto.getRandomValues(new Uint8Array(16))].map((byte) => byte.toString(16).padStart(2, '0')).join(''); }
+function organizationNonce() { return btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(32)))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, ''); }
+export async function signMembershipBinding(binding, signer, party) {
+    validateMembershipBindingPayload(binding, true);
+    if (party !== 'member' && party !== 'org' || party === 'member' && binding.member_aid !== signer.aid)
+        throw invalid('membership signer does not match party');
+    const value = structuredClone(binding);
+    const payload = { ...value };
+    delete payload.member_signature;
+    delete payload.org_signature;
+    value[party + '_signature'] = await signProtocolPayload(payload, signer);
+    return value;
+}
+async function signProtocolPayload(payload, signer) {
+    const now = Math.trunc(Date.now() / 1000);
+    const result = await signer.sign(canonicalJson(payload));
+    if (!result.ok)
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'protocol signing failed');
+    const signature = { cert_fingerprint: signer.certFingerprint, timestamp: now, signature: result.data.signature };
+    try {
+        await verifyAgentSignature(signature, payload, signer.aid, () => signer.certPem, now);
+    }
+    catch {
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'protocol signing identity is invalid');
+    }
+    return signature;
+}
+export async function createMembershipBinding(options, memberSigner, orgSigner) {
+    const value = structuredClone(options);
+    const terms = 'terms' in value ? value.terms : {};
+    delete value.terms;
+    if (!isRecord(terms) || 'member_signature' in value || 'org_signature' in value)
+        throw invalid('membership creation requires unsigned terms');
+    const now = Math.trunc(Date.now() / 1000);
+    const defaults = { ver: 'aun-membership-binding/1', membership_id: 'mem-' + organizationIdentifier(), binding_version: 1, member_type: 'custom', category: 'member', role: 'member', ownership: 'personal', visibility: 'members', request_id: organizationIdentifier(), nonce: organizationNonce(), iat: now, exp: now + 3600, terms_hash: digest(terms) };
+    for (const [key, item] of Object.entries(defaults))
+        if (!(key in value))
+            value[key] = item;
+    if (value.terms_hash !== digest(terms) || !['owner', 'admin', 'member', 'observer'].includes(String(value.role)))
+        throw invalid('membership terms or role is invalid');
+    validateMembershipBindingPayload(value, true);
+    let binding = value;
+    if (memberSigner)
+        binding = await signMembershipBinding(binding, memberSigner, 'member');
+    if (orgSigner)
+        binding = await signMembershipBinding(binding, orgSigner, 'org');
+    return binding;
+}
+export async function createRepresentationProof(credential, params, binding, signer, proofChain) {
+    const now = Math.trunc(Date.now() / 1000);
+    const target = params.for;
+    validateCredentialAt(credential, now, undefined, proofChain);
+    if (typeof target !== 'string' || !AID_RE.test(target) || target === signer.aid)
+        throw invalid('representation requires another target AID');
+    validateRequestBinding(binding, String(binding.method), String(binding.target), params, String(credential.cid), String(params.nonce), String(params.request_id), now);
+    const proof = { issuer: signer.aid, from: signer.aid, represented: credential.sub, for: target, audience: binding.target, resource: target, method: binding.method, params_hash: binding.params_hash, iat: binding.iat, exp: binding.exp, nonce: binding.nonce, credential_cid: credential.cid };
+    proof.signature = await signProtocolPayload(proof, signer);
+    return proof;
+}
+export async function signTransferAcceptance(proposal, signer) {
+    if (!isRecord(proposal) || proposal.ver !== 'aun-org-transfer/1' || proposal.target_member_aid !== signer.aid || !isInt(proposal.exp) || proposal.exp <= Math.trunc(Date.now() / 1000))
+        throw invalid('transfer proposal does not match the accepting identity');
+    const payload = { ...proposal };
+    delete payload.signature;
+    return { transfer_id: proposal.transfer_id, proposal_hash: digest(payload), target_signature: await signProtocolPayload(payload, signer) };
+}
+export async function prepareOrganizationRequest(method, params, target, signer, options = {}) {
+    if (!method.startsWith('org.') || !AID_RE.test(target))
+        throw invalid('organization method and service AID are required');
+    let value = structuredClone(params);
+    const memberSigner = options.memberSigner ?? signer;
+    let binding = isRecord(value.membership_binding) ? value.membership_binding : undefined;
+    if (method === 'org.member.inviteAccept' && value.for !== undefined && value.for !== signer.aid && (!binding || !('org_signature' in binding) || !('credential_template' in value) || !('registration_authorization' in value)))
+        throw invalid('represented invitation acceptance requires original organization materials');
+    if ('membership_binding' in value)
+        validateMembershipBindingPayload(value.membership_binding, true);
+    const anchored = ['org.lifecycle.create', 'org.member.join', 'org.member.approveJoin', 'org.member.inviteAccept', 'org.member.renewCredential'].includes(method);
+    for (const key of ['request_id', 'nonce']) {
+        if (anchored && binding) {
+            if (key in value && value[key] !== binding[key])
+                throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request identity differs from membership binding');
+            value[key] ??= binding[key];
+        }
+        if (!(key in value))
+            value[key] = key === 'nonce' ? organizationNonce() : organizationIdentifier();
+        if (typeof value[key] !== 'string' || !value[key])
+            throw invalid('request binding identity is invalid');
+    }
+    if (method === 'org.lifecycle.create') {
+        if (!('owner_aid' in value))
+            value.owner_aid = signer.aid;
+        if (value.owner_aid !== signer.aid)
+            throw invalid('initial owner must match the authenticated signer');
+        if (!binding) {
+            if (!options.orgSigner || options.orgSigner.aid !== value.org_id)
+                throw invalid('organization signing identity is required');
+            binding = await createMembershipBinding({ org_id: value.org_id, member_aid: signer.aid, role: 'owner', member_type: 'human', terms: { org_id: value.org_id, owner_aid: signer.aid }, request_id: value.request_id, nonce: value.nonce }, signer, options.orgSigner);
+            value.membership_binding = binding;
+        }
+    }
+    else if (method === 'org.member.join') {
+        if (!('member_aid' in value))
+            value.member_aid = 'for' in value ? value.for : memberSigner.aid;
+        for (const [key, fallback] of Object.entries({ member_type: 'custom', category: 'member', requested_role: 'member', ownership: 'personal', visibility: 'members', terms: {} }))
+            if (!(key in value))
+                value[key] = binding?.[key === 'requested_role' ? 'role' : key] ?? fallback;
+        if (!('terms_hash' in value))
+            value.terms_hash = digest(value.terms);
+        if (!binding) {
+            const material = {};
+            for (const key of ['org_id', 'member_aid', 'member_type', 'category', 'ownership', 'visibility', 'terms', 'request_id', 'nonce'])
+                material[key] = value[key];
+            material.role = value.requested_role;
+            if ('exp' in value)
+                material.exp = value.exp;
+            binding = await createMembershipBinding(material, memberSigner);
+        }
+        else if (!('member_signature' in binding))
+            binding = await signMembershipBinding(binding, memberSigner, 'member');
+        value.membership_binding = binding;
+        value.member_signature = binding.member_signature;
+        value.exp = binding.exp;
+    }
+    else if (method === 'org.member.invite') {
+        const targets = value.targets;
+        if (!Array.isArray(targets) || !targets.length || targets.some((aid) => typeof aid !== 'string' || !AID_RE.test(aid)) || new Set(targets).size !== targets.length)
+            throw invalid('invite targets must be distinct concrete AIDs');
+        for (const [key, fallback] of Object.entries({ member_type: 'custom', category: 'member', role: 'member', ownership: 'personal', visibility: 'members', terms: {} }))
+            if (!(key in value))
+                value[key] = binding?.[key] ?? fallback;
+        if (!('terms_hash' in value))
+            value.terms_hash = digest(value.terms);
+        const materials = 'membership_bindings' in value ? value.membership_bindings : (targets.length === 1 && binding ? { [String(targets[0])]: binding } : {});
+        if (!isRecord(materials) || Object.keys(materials).some((aid) => !targets.includes(aid)))
+            throw invalid('invite bindings do not match targets');
+        for (const targetAid of targets) {
+            let material = materials[targetAid];
+            if (!isRecord(material) || !('org_signature' in material)) {
+                if (!options.orgSigner || options.orgSigner.aid !== value.org_id)
+                    throw invalid('organization signing identity is required');
+                if (material === undefined) {
+                    const fields = { member_aid: targetAid };
+                    for (const key of ['org_id', 'member_type', 'category', 'role', 'ownership', 'visibility', 'terms'])
+                        fields[key] = value[key];
+                    if (targets.length === 1)
+                        fields.nonce = value.nonce;
+                    if ('exp' in value)
+                        fields.exp = value.exp;
+                    material = await createMembershipBinding(fields, undefined, options.orgSigner);
+                }
+                else
+                    material = await signMembershipBinding(material, options.orgSigner, 'org');
+            }
+            validateMembershipBindingPayload(material, true);
+            materials[targetAid] = material;
+        }
+        if (targets.length === 1) {
+            const nonce = materials[String(targets[0])].nonce;
+            if ('nonce' in params && params.nonce !== nonce)
+                throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request nonce differs from invite binding');
+            value.nonce = nonce;
+        }
+        value.membership_bindings = materials;
+    }
+    else if (method === 'org.member.approveJoin' && binding) {
+        if (!('org_signature' in binding))
+            binding = await signMembershipBinding(binding, signer, 'org');
+        value.membership_binding = binding;
+        value.org_signature = binding.org_signature;
+        if (!('approved_role' in value))
+            value.approved_role = binding.role;
+        if (!('join_request_id' in value))
+            value.join_request_id = binding.request_id;
+    }
+    else if (method === 'org.member.inviteAccept' && binding) {
+        if (!('member_signature' in binding))
+            binding = await signMembershipBinding(binding, memberSigner, 'member');
+        value.membership_binding = binding;
+        value.member_signature = binding.member_signature;
+        if (!('member_aid' in value))
+            value.member_aid = binding.member_aid;
+        if (!('terms_hash' in value))
+            value.terms_hash = binding.terms_hash;
+    }
+    if (method === 'org.member.renewCredential') {
+        if (!binding)
+            throw invalid('replacement membership binding is required');
+        if (!('member_signature' in binding))
+            binding = await signMembershipBinding(binding, memberSigner, 'member');
+        if (!('org_signature' in binding)) {
+            if (!options.orgSigner || options.orgSigner.aid !== value.org_id)
+                throw invalid('organization signing identity is required');
+            binding = await signMembershipBinding(binding, options.orgSigner, 'org');
+        }
+        value.membership_binding = binding;
+        if (!('member_aid' in value))
+            value.member_aid = binding.member_aid;
+    }
+    const materials = isRecord(value.membership_bindings) ? value.membership_bindings : {};
+    const signedBinding = method === 'org.member.invite' ? (Object.keys(materials).length === 1 ? Object.values(materials)[0] : undefined) : binding;
+    for (const field of ['member_signature', 'org_signature']) {
+        if (field in params && (!isRecord(signedBinding) || !(field in signedBinding) || canonicalText(params[field]) !== canonicalText(signedBinding[field])))
+            throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'outer signature differs from membership binding');
+    }
+    if (['org.lifecycle.create', 'org.member.approveJoin', 'org.member.renewCredential'].includes(method) && !('credential_template' in value)) {
+        if (!options.orgSigner || !binding)
+            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 (!binding)
+            throw invalid('membership binding is required for registration');
+        const issuerSigner = options.orgSigner ?? (signer.aid === value.credential_template.iss ? signer : undefined);
+        value.registration_authorization = await createRegistrationAuthorization(value.credential_template, binding, target, issuerSigner);
+    }
+    if (method === 'org.member.invite' && options.orgSigner) {
+        const templates = isRecord(value.credential_templates) ? value.credential_templates : {};
+        const authorizations = isRecord(value.registration_authorizations) ? value.registration_authorizations : {};
+        for (const [aid, material] of Object.entries(materials)) {
+            if (!(aid in templates))
+                templates[aid] = await createMemberCredential(material, options.orgSigner, { key_version: options.orgSigner.certFingerprint, ...options.credentialOptions });
+            if (!(aid in authorizations))
+                authorizations[aid] = await createRegistrationAuthorization(templates[aid], material, target, options.orgSigner);
+        }
+        value.credential_templates = templates;
+        value.registration_authorizations = authorizations;
+    }
+    if (method === 'org.lifecycle.transferAccept' && value.stage !== 'rekey') {
+        for (const field of ['previous_owner', 'new_owner']) {
+            const material = value[field];
+            if (isRecord(material) && !('registration_authorization' in material)) {
+                if (!isRecord(material.credential_template) || !isRecord(material.membership_binding))
+                    throw invalid('transfer registration materials are required');
+                const issuerSigner = options.orgSigner ?? (signer.aid === material.credential_template.iss ? signer : undefined);
+                material.registration_authorization = await createRegistrationAuthorization(material.credential_template, material.membership_binding, target, issuerSigner);
+            }
+        }
+    }
+    value = orgRequestParams(method, value);
+    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');
+        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) {
+                const material = value[field];
+                if (!isRecord(material) || !isInt(material.exp))
+                    throw invalid('admission material expiry is invalid');
+                maximum = Math.min(maximum, material.exp);
+            }
+        const paramsHash = digest(orgRequestBindingParams(method, value));
+        const expected = { ver: 'aun-membership-admission-request/1', request_id: value.request_id, nonce: value.nonce, target, method, params_hash: paramsHash, membership_id: binding.membership_id, iat: now, exp: maximum };
+        if (!('request_binding' in value))
+            value.request_binding = expected;
+        const request = value.request_binding;
+        if (!isRecord(request) || Object.keys(request).length !== Object.keys(expected).length || Object.keys(request).some((key) => !(key in expected)) || Object.entries(expected).some(([key, item]) => !['iat', 'exp'].includes(key) && request[key] !== item) || !isInt(request.iat) || !isInt(request.exp) || request.iat < 0 || request.iat > now || request.iat < Number(binding.iat) || now >= request.exp || request.exp > request.iat + 300 || request.exp > maximum)
+            throw representationBindingInvalid('admission request binding is invalid');
+        if (value.for === undefined || value.for === signer.aid)
+            return value;
+        const proof = { ver: 'aun-membership-admission-representation/1', issuer: signer.aid, from: signer.aid, represented: binding.member_aid, for: binding.member_aid, audience: target, resource: binding.member_aid, org_id: binding.org_id, membership_id: binding.membership_id, method, params_hash: paramsHash, request_id: value.request_id, nonce: value.nonce, iat: request.iat, exp: request.exp };
+        if (!('representation_proof' in credentials))
+            credentials.representation_proof = { ...proof, signature: await signProtocolPayload(proof, signer) };
+        const supplied = credentials.representation_proof;
+        if (!isRecord(supplied) || Object.keys(supplied).length !== Object.keys(proof).length + 1 || Object.keys(supplied).some((key) => key !== 'signature' && !(key in proof)) || Object.entries(proof).some(([key, item]) => supplied[key] !== item))
+            throw representationBindingInvalid('admission representation proof is invalid');
+        validateRepresentationSignature(supplied.signature);
+        try {
+            await verifyAgentSignature(supplied.signature, proof, signer.aid, () => signer.certPem, now);
+        }
+        catch {
+            throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'admission representation signature is invalid');
+        }
+        return value;
+    }
+    const credential = ['member_credential', 'approval_credential', 'audit_credential'].map((key) => credentials[key]).find(isRecord) ?? value.credential_template;
+    if (isRecord(credential)) {
+        validateCredential(credential, 0, value.proof_chain);
+        const now = Math.trunc(Date.now() / 1000);
+        if (!('request_binding' in value))
+            value.request_binding = buildRequestBinding(method, target, value, credential.cid, value.nonce, value.request_id, now, Math.min(now + 300, credential.exp));
+        validateRequestBinding(value.request_binding, method, target, value, credential.cid, value.nonce, value.request_id, now);
+        if (value.for && value.for !== signer.aid && !('representation_proof' in credentials))
+            value.credentials = { ...credentials, representation_proof: await createRepresentationProof(credential, value, value.request_binding, signer, value.proof_chain) };
+    }
+    else if (value.for && value.for !== signer.aid)
+        throw invalid('representation requires a current holder CAP');
+    return value;
+}
+async function createRegistrationAuthorization(credential, binding, relay, signer) {
+    if (!signer || signer.aid !== credential.iss)
+        throw new ProtocolError('CREDENTIAL_AUTHENTICATION_INVALID', 'issuer signing identity or registration authorization is required');
+    const now = Math.trunc(Date.now() / 1000);
+    const value = { ver: 'aun-credential-registration-authorization/1', issuer_aid: credential.iss, credential_cid: credential.cid, credential_hash: digest(credential), request_id: binding.request_id, nonce: binding.nonce, target: 'credential.' + relay.slice(relay.indexOf('.') + 1), relay_aid: relay, iat: now, exp: binding.exp, revocation_authority: { aid: relay, org_id: binding.org_id, credential_cid: credential.cid, registration_request_id: binding.request_id, reason_codes: ['request_failed', 'membership_ended', 'organization_dissolved', 'org_ownership_transfer', 'credential_renewed'] } };
+    value.signature = await signProtocolPayload(value, signer);
+    return value;
+}
+export async function createMemberCredential(binding, signer, options) {
+    validateMembershipBindingPayload(binding, true);
+    if (!['owner', 'admin', 'member', 'observer'].includes(String(binding.role)))
+        throw invalid('membership role is invalid');
+    const fixed = { iss: binding.org_id, sub: binding.member_aid, aud: [binding.org_id],
+        cap: [{ ns: 'org', action: 'role.' + String(binding.role), resource: binding.org_id, constraints: [] }],
+        delegate: false, delegation_depth: 0, proof_chain: [],
+        ext: { credential_type: 'member', org_id: binding.org_id, membership_id: binding.membership_id, binding_version: binding.binding_version, membership_terms_hash: binding.terms_hash, bound_to_membership: true } };
+    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);
+}
+export async function verifyCredential(credential, context) {
+    if (!context || !context.audience || !context.subject)
+        throw invalid('credential verification requires a target audience and holder');
+    validateCredential(credential, 0, context.proofChain);
+    const value = credential;
+    if (value.sub !== context.subject)
+        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;
+        try {
+            proof = await context.resolveStatusProof?.(cid);
+            if (proof == null)
+                proof = await context.resolveStatus?.(cid);
+        }
+        catch {
+            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))
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is unavailable');
+            try {
+                signature(proof.signature);
+            }
+            catch {
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is unavailable');
+            }
+            if (proof.signature.timestamp !== proof.asOf)
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is unavailable');
+            if (proof.credential_hash !== digest(document))
+                throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'registered credential hash differs from the signed document');
+            return typeof proof.status === 'string' ? proof.status : undefined;
+        }
+        if (document !== value)
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'parent credential status proof is required');
+        return typeof proof === 'string' ? proof : undefined;
+    };
+    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;
+    await validateCredentialCapability(credential, { ns: context.ns, action: context.action, resource: context.resource, params: context.params, units: context.units, now, client_ip: context.clientIp, proof_chain: context.proofChain }, rate);
+    if (!context.method || !context.target)
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'the actual request context is required');
+    validateRequestBinding(context.requestBinding, context.method, context.target, context.params ?? {}, String(value.cid), context.nonce ?? '', context.requestId ?? '', now);
+    const ext = value.ext;
+    if (isRecord(ext) && ext.credential_type === 'member' && (ext.bound_to_membership !== true || value.delegate === true))
+        throw invalid('member credential must be bound and cannot delegate');
+    if (isRecord(ext) && ext.bound_to_membership === true) {
+        const binding = context.membershipBinding;
+        if (!isRecord(binding) || binding.member_aid !== value.sub || binding.org_id !== ext.org_id || binding.membership_id !== ext.membership_id || binding.binding_version !== ext.binding_version || binding.terms_hash !== ext.membership_terms_hash)
+            throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'current membership binding is required');
+        if (ext.credential_type === 'member') {
+            const caps = value.cap;
+            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, 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');
+    }
+    const result = { signature_valid: true, chain_valid: true, status_checked: true, capability_checked: true, request_bound: true };
+    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))
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'authenticated representation context is required');
+    if (target !== undefined && target !== actor || actor !== context.subject) {
+        if (target === undefined || target === actor)
+            throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'credential holder requires representation');
+        const packaged = isRecord(params.credentials) ? params.credentials.representation_proof : undefined;
+        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');
+        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 {
+            for (const subject of subjects)
+                if (!context.resolveOwnership || await context.resolveOwnership(subject, actor) !== true)
+                    allowed = false;
+            if (context.ns === 'org' && !['active', 'nonmember', 'frozen', 'offboarding', 'ended'].includes(await context.resolveActorStatus?.(context.audience, actor) ?? 'unknown'))
+                allowed = false;
+        }
+        catch {
+            allowed = false;
+        }
+        if (!allowed)
+            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 document of documents)
+            validateCredentialAt(document, completedAt, context.audience);
+        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) {
+    validateCredential(credential, 0, proofChain);
+    if (!isInt(now))
+        throw invalid('credential validation time must be an integer');
+    const value = credential;
+    const nbf = value.nbf;
+    const exp = value.exp;
+    if (!isInt(nbf) || !isInt(exp) || now < nbf || now >= exp)
+        throw new ProtocolError('CREDENTIAL_EXPIRED', 'credential is outside its validity window');
+    if (audience !== undefined) {
+        if (!Array.isArray(value.aud) || !value.aud.includes(audience))
+            throw new ProtocolError('CREDENTIAL_AUDIENCE_MISMATCH', 'credential audience does not match target');
+    }
+}
+export async function verifyCredentialSignature(credential, resolveCertificate, now, audience, proofChain) {
+    try {
+        validateCredential(credential, 0, proofChain);
+    }
+    catch (error) {
+        if (error instanceof ProtocolError && error.message.toLowerCase().includes('signature')) {
+            throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'credential signature structure is invalid');
+        }
+        throw error;
+    }
+    const value = credential;
+    const signatureValue = value.signature;
+    const issuer = value.iss;
+    try {
+        const payload = { ...value };
+        delete payload.signature;
+        await verifyAgentSignature(signatureValue, payload, issuer, resolveCertificate, now);
+    }
+    catch {
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'credential signature verification failed');
+    }
+    if (now !== undefined) {
+        validateCredentialAt(credential, now, audience, proofChain);
+    }
+    else if (audience !== undefined && !value.aud.includes(audience)) {
+        throw new ProtocolError('CREDENTIAL_AUDIENCE_MISMATCH', 'credential audience does not match target');
+    }
+}
+function canonicalText(value) {
+    return new TextDecoder().decode(canonicalJson(value));
+}
+function constraintField(context, field) {
+    let value = context;
+    for (const part of field.split('.')) {
+        if (!isRecord(value) || !Object.hasOwn(value, part))
+            return [undefined, false];
+        value = value[part];
+    }
+    return [value, true];
+}
+async function evaluateConstraints(constraints, context, rate) {
+    const pending = [];
+    for (const item of constraints) {
+        if (item.type === 'rate_limit') {
+            pending.push(item);
+            continue;
+        }
+        const field = String(item.field);
+        let [actual, found] = constraintField(context, field);
+        if (!found)
+            [actual, found] = constraintField(context.params, field);
+        if (!found)
+            return false;
+        const units = isRecord(context.units) ? context.units : {};
+        if (item.type !== 'time_window' && (units[field] ?? '') !== constraintUnit(item))
+            return false;
+        try {
+            if (!constraintSatisfied(item, actual))
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    for (const item of pending)
+        if (!rate || await rate(String(item.field), constraintUnit(item), Number(item.value)) !== true)
+            return false;
+    return true;
+}
+export async function validateCredentialCapability(credential, context, rate) {
+    validateCredential(credential, 0, context.proof_chain);
+    if (!isRecord(context) || !['ns', 'action', 'resource'].every((field) => typeof context[field] === 'string' && context[field]))
+        throw new ProtocolError('CREDENTIAL_CAPABILITY_DENIED', 'an explicit capability requirement is required');
+    const value = credential;
+    const actual = { ...context, sub: value.sub, delegation_depth: value.delegation_depth ?? 0, operation: String(context.action).split('.').at(-1), valid_time: context.now };
+    for (const cap of value.cap) {
+        if (cap.ns === context.ns && (cap.action === context.action || cap.action === '*') && (cap.resource === context.resource || cap.resource === '*') && await evaluateConstraints(cap.constraints, actual, rate))
+            return;
+    }
+    throw new ProtocolError('CREDENTIAL_CAPABILITY_DENIED', 'credential does not cover the actual operation or constraints');
+}
+function constraintUnit(item) {
+    return String(item.unit || (item.type === 'rate_limit' ? 'second' : item.type === 'time_window' ? 'UTC' : ''));
+}
+function constraintSatisfied(item, actual) {
+    const value = item.value;
+    switch (item.type) {
+        case 'max_value':
+        case 'min_value':
+            return typeof actual === 'number' && Number.isFinite(actual) && typeof value === 'number' && (item.type === 'max_value' ? actual <= value : actual >= value);
+        case 'range':
+            return typeof actual === 'number' && Number.isFinite(actual) && Array.isArray(value) && actual >= value[0] && actual <= value[1];
+        case 'allowed_values':
+        case 'denied_values': {
+            if (!Array.isArray(value))
+                return false;
+            const found = value.some((entry) => canonicalText(entry) === canonicalText(actual));
+            return item.type === 'allowed_values' ? found : !found;
+        }
+        case 'path_prefix': {
+            const path = canonicalPath(actual), prefix = canonicalPath(value);
+            return path !== undefined && prefix !== undefined && (path === prefix || path.startsWith(prefix.replace(/\/$/u, '') + '/'));
+        }
+        case 'regex': {
+            if (typeof actual !== 'string' || new TextEncoder().encode(actual).length > 4096 || typeof value !== 'string' || !validConstraintRegex(value))
+                return false;
+            const match = new RegExp(value, 'u').exec(actual);
+            return match !== null && match[0] === actual;
+        }
+        case 'ip_whitelist': {
+            if (typeof actual !== 'string' || /[/%]/u.test(actual) || !Array.isArray(value))
+                return false;
+            const address = constraintIP(actual);
+            return address !== undefined && value.some((entry) => {
+                const prefix = constraintIP(entry);
+                return prefix !== undefined && address.bits === prefix.bits && (address.address >> BigInt(address.bits - prefix.prefix)) === (prefix.address >> BigInt(prefix.bits - prefix.prefix));
+            });
+        }
+        case 'time_window': {
+            if (!isInt(actual) || actual < 0 || !Array.isArray(value))
+                return false;
+            const current = new Date(actual * 1000).toISOString().slice(11, 16);
+            return current >= value[0] && current < value[1];
+        }
+    }
+    return false;
+}
+function constraintNarrower(child, parent) {
+    if (!isRecord(child) || !isRecord(parent) || child.type !== parent.type || child.field !== parent.field || constraintUnit(child) !== constraintUnit(parent))
+        return false;
+    const a = child.value, b = parent.value;
+    if (['max_value', 'min_value', 'rate_limit'].includes(child.type))
+        return typeof a === 'number' && Number.isFinite(a) && typeof b === 'number' && Number.isFinite(b) && (child.type === 'min_value' ? a >= b : a <= b);
+    if (child.type === 'allowed_values' || child.type === 'denied_values') {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        const [subset, superset] = child.type === 'denied_values' ? [b, a] : [a, b];
+        return subset.every((entry) => superset.some((candidate) => canonicalText(entry) === canonicalText(candidate)));
+    }
+    if (child.type === 'ip_whitelist') {
+        if (!Array.isArray(a) || !Array.isArray(b))
+            return false;
+        return a.every((entry) => {
+            const subnet = constraintIP(entry);
+            return subnet !== undefined && b.some((candidate) => {
+                const prefix = constraintIP(candidate);
+                return prefix !== undefined && subnet.bits === prefix.bits && subnet.prefix >= prefix.prefix && (subnet.address >> BigInt(subnet.bits - prefix.prefix)) === (prefix.address >> BigInt(prefix.bits - prefix.prefix));
+            });
+        });
+    }
+    if (child.type === 'range' || child.type === 'time_window')
+        return Array.isArray(a) && Array.isArray(b) && a.length === 2 && b.length === 2 && a[0] >= b[0] && a[1] <= b[1];
+    if (child.type === 'path_prefix') {
+        const path = canonicalPath(a), prefix = canonicalPath(b);
+        return path !== undefined && prefix !== undefined && (path === prefix || path.startsWith(prefix.replace(/\/$/u, '') + '/'));
+    }
+    return canonicalText(a) === canonicalText(b);
+}
+function capabilitiesNarrower(child, parent, subject, depth) {
+    if (!Array.isArray(child) || !Array.isArray(parent))
+        return false;
+    return child.every((current) => isRecord(current) && Array.isArray(current.constraints) && parent.some((candidate) => {
+        if (!isRecord(candidate) || current.ns !== candidate.ns || current.action !== candidate.action && candidate.action !== '*' || current.resource !== candidate.resource && candidate.resource !== '*' || !Array.isArray(candidate.constraints))
+            return false;
+        return candidate.constraints.every((raw) => {
+            if (!isRecord(raw))
+                return false;
+            const actual = { sub: subject, delegation_depth: depth };
+            if (candidate.action === '*')
+                actual.operation = String(current.action).split('.').at(-1);
+            if (candidate.resource === '*' && current.resource !== '*')
+                actual.resource = current.resource;
+            if (Object.hasOwn(actual, String(raw.field)) && !constraintSatisfied(raw, actual[String(raw.field)]))
+                return false;
+            return current.constraints.some((item) => constraintNarrower(item, raw));
+        });
+    }));
+}
+async function verifyAgentSignature(signatureValue, payload, expectedAid, resolveCertificate, now, enforceWindow = true) {
+    const certPem = certificatePem(await resolveCertificate(String(signatureValue.cert_fingerprint)));
+    const lower = enforceWindow ? payload.iat ?? payload.registered_at : undefined;
+    if (typeof lower === 'number' && (Number(signatureValue.timestamp) < lower || Number(signatureValue.timestamp) >= Number(payload.exp)))
+        throw new Error('signature timestamp is outside the signed object window');
+    if (!certPem)
+        throw new Error('certificate is missing');
+    if ((await certFingerprint(certPem)).toLowerCase() !== String(signatureValue.cert_fingerprint).toLowerCase())
+        throw new Error('certificate fingerprint mismatch');
+    const metadata = parseCertMetadata(certPem);
+    const current = Math.trunc(now ?? Date.now() / 1000);
+    const timestamp = Number(signatureValue.timestamp);
+    if (metadata.subject.toLowerCase() !== expectedAid.toLowerCase())
+        throw new Error('certificate subject does not match AID');
+    if (current < metadata.notBefore.getTime() / 1000 || current > metadata.notAfter.getTime() / 1000 || timestamp < metadata.notBefore.getTime() / 1000 || timestamp > metadata.notAfter.getTime() / 1000)
+        throw new Error('certificate is not valid');
+    if (timestamp > current + 300)
+        throw new Error('signature timestamp is too far in the future');
+    if (signatureValue.public_key_fingerprint !== undefined && (await publicKeyFingerprint(certPem)).toLowerCase() !== String(signatureValue.public_key_fingerprint).toLowerCase())
+        throw new Error('public key fingerprint mismatch');
+    if (!await verifySignatureWithCert(certPem, String(signatureValue.signature), canonicalJson(payload)))
+        throw new Error('signature verification failed');
+}
+function auditScopeTime(value) {
+    if (isInt(value) && value >= 0)
+        return value;
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u.test(value))
+        return undefined;
+    const parsed = Math.floor(Date.parse(value) / 1000);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function auditScopeNarrower(child, parent) {
+    const current = isRecord(child.ext) ? child.ext : {};
+    const previous = isRecord(parent.ext) ? parent.ext : {};
+    const archive = previous.credential_type === 'archive' || current.credential_type === 'archive';
+    if (archive && (previous.credential_type !== 'archive' || current.credential_type !== 'archive' || previous.org_id !== current.org_id))
+        return false;
+    if (previous.credential_type === 'audit' || 'audit_fields' in previous) {
+        const allowed = new Set(['event_id', 'event_seq', 'event_type', 'org_id', 'occurred_at', 'received_at', 'previous_hash', 'event_hash']);
+        if (archive)
+            allowed.clear();
+        for (const ext of [previous, current])
+            if ('audit_fields' in ext && (!Array.isArray(ext.audit_fields) || !ext.audit_fields.length || ext.audit_fields.some((item) => typeof item !== 'string' || !item)))
+                return false;
+        for (const field of (previous.audit_fields ?? []))
+            allowed.add(field);
+        if (!(current.audit_fields ?? []).every((field) => allowed.has(field)))
+            return false;
+    }
+    if ('audit_window' in previous) {
+        const bounds = [];
+        for (const ext of [previous, current]) {
+            if (!isRecord(ext.audit_window))
+                return false;
+            const start = auditScopeTime(ext.audit_window.from);
+            const end = ext.audit_window.to == null ? Infinity : auditScopeTime(ext.audit_window.to);
+            if (start === undefined || end === undefined || end < start)
+                return false;
+            bounds.push([start, end]);
+        }
+        if (bounds[1][0] < bounds[0][0] || bounds[1][1] > bounds[0][1])
+            return false;
+    }
+    return true;
+}
+function credentialChainDocuments(credential, externalProofChain) {
+    validateCredential(credential, 0, externalProofChain);
+    const value = credential;
+    const chain = value.parent !== undefined && value.parent !== null ? (value.proof_chain ?? externalProofChain) : [];
+    const documents = [value, ...chain];
+    const seen = new Set();
+    for (const document of documents) {
+        if (!isRecord(document) || typeof document.cid !== 'string' || seen.has(document.cid))
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'proof_chain contains a repeated cid');
+        seen.add(document.cid);
+    }
+    let child = value;
+    for (const parent of chain) {
+        if (!isRecord(parent) || child.parent !== parent.cid)
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'parent cid does not match proof_chain');
+        if (child.iss !== parent.sub || parent.delegate !== true)
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'proof_chain issuer or delegation is invalid');
+        if (child.delegation_depth !== (parent.delegation_depth ?? 0) + 1)
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'delegation depth is invalid');
+        if (child.iat < parent.iat || child.nbf < parent.nbf || child.exp > parent.exp)
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential time window is wider than parent');
+        if (!child.aud.every((item) => parent.aud.includes(item)))
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential audience is wider than parent');
+        if (!capabilitiesNarrower(child.cap, parent.cap, child.sub, child.delegation_depth))
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential capability is wider than parent');
+        if (!auditScopeNarrower(child, parent))
+            throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential audit scope is wider than parent');
+        child = parent;
+    }
+    if (chain.length > 0 && child.parent !== undefined && child.parent !== null)
+        throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'proof_chain is incomplete');
+    return documents;
+}
+export async function verifyCredentialChain(credential, resolveCertificate, resolveStatus, now, audience, proofChain) {
+    if (typeof resolveStatus !== 'function')
+        throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential status is unavailable');
+    const documents = credentialChainDocuments(credential, proofChain);
+    for (const document of documents) {
+        const status = await resolveStatus(document.cid);
+        if (status === 'revoked')
+            throw new ProtocolError('CREDENTIAL_REVOKED', 'credential is revoked');
+        if (status === 'expired')
+            throw new ProtocolError('CREDENTIAL_EXPIRED', 'credential is expired');
+        if (status !== 'active')
+            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);
+}
+function validateMembershipBindingPayload(binding, allowPartial = false) {
+    if (!isRecord(binding))
+        throw invalid('membership_binding must be an object');
+    onlyKnown(binding, BINDING_FIELDS);
+    required(binding, allowPartial ? new Set([...BINDING_FIELDS].filter((key) => key !== 'member_signature' && key !== 'org_signature')) : BINDING_FIELDS);
+    if (binding.ver !== 'aun-membership-binding/1' || typeof binding.membership_id !== 'string' || !binding.membership_id)
+        throw invalid('membership_binding identity is invalid');
+    for (const field of ['member_type', 'category', 'role', 'ownership', 'visibility', 'request_id', 'nonce'])
+        if (typeof binding[field] !== 'string' || binding[field].length === 0)
+            throw invalid(`${field} is invalid`);
+    aid(binding.org_id, 'org_id');
+    aid(binding.member_aid, 'member_aid');
+    if (!isInt(binding.binding_version) || binding.binding_version < 1)
+        throw invalid('binding_version is invalid');
+    if (typeof binding.terms_hash !== 'string' || !DIGEST_RE.test(binding.terms_hash))
+        throw invalid('terms_hash is invalid');
+    if (!isInt(binding.iat) || !isInt(binding.exp) || binding.exp <= binding.iat)
+        throw invalid('membership_binding time window is invalid');
+    if ('member_signature' in binding)
+        signature(binding.member_signature, 'member_signature');
+    if ('org_signature' in binding)
+        signature(binding.org_signature, 'org_signature');
+}
+export function validateMembershipBinding(binding) {
+    validateMembershipBindingPayload(binding);
+}
+export function validateMembershipBindingAt(binding, now, expectedRole) {
+    validateMembershipBinding(binding);
+    const value = binding;
+    const iat = value.iat;
+    const exp = value.exp;
+    if (!isInt(now) || !isInt(iat) || !isInt(exp) || now < iat || now >= exp)
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'membership binding is outside its validity window');
+    if (expectedRole !== undefined && value.role !== expectedRole)
+        throw invalid('membership role is invalid');
+}
+export async function verifyMembershipBinding(binding, resolveCertificate, now, expectedOrgSigner, historical = false) {
+    try {
+        validateMembershipBinding(binding);
+    }
+    catch (error) {
+        if (error instanceof ProtocolError && error.message.toLowerCase().includes('signature')) {
+            throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'membership binding signature structure is invalid');
+        }
+        throw error;
+    }
+    if (now !== undefined && !historical)
+        validateMembershipBindingAt(binding, now);
+    const value = binding;
+    const payload = { ...value };
+    const memberSignature = payload.member_signature;
+    const orgSignature = payload.org_signature;
+    delete payload.member_signature;
+    delete payload.org_signature;
+    for (const [signatureValue, signer] of [[memberSignature, value.member_aid], [orgSignature, expectedOrgSigner ?? value.org_id]]) {
+        try {
+            await verifyAgentSignature(signatureValue, payload, String(signer), resolveCertificate, now);
+        }
+        catch {
+            throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'membership binding signature verification failed');
+        }
+    }
+}
+export function validateRegistrationReceipt(receipt, credential, request, expectedServiceAid, now) {
+    if (!isRecord(request))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'request must be an object');
+    validateCredential(credential, 0, request.proof_chain);
+    if (!isRecord(receipt))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'receipt must be an object');
+    onlyKnown(receipt, RECEIPT_FIELDS);
+    required(receipt, new Set([...RECEIPT_FIELDS].filter((field) => field !== 'registration_authorization')));
+    if (receipt.ver !== 'aun-credential-registration-receipt/1' || receipt.status !== 'active')
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'receipt status is invalid');
+    if (receipt.credential_hash !== digest(credential))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_MISMATCH', 'credential hash mismatch');
+    if (isRecord(credential) && (receipt.credential_cid !== credential.cid || receipt.request_id !== request.request_id || receipt.nonce !== request.nonce))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_MISMATCH', 'receipt binding mismatch');
+    if (!isInt(receipt.registered_at) || !isInt(receipt.exp) || receipt.exp <= receipt.registered_at)
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'receipt time window is invalid');
+    if (receipt.registrar_aid !== credential.iss)
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_MISMATCH', 'receipt registrar is not the credential issuer');
+    aid(receipt.registrar_aid, 'registrar_aid');
+    aid(receipt.service_aid, 'service_aid');
+    if (request.registrar_aid !== undefined && receipt.registrar_aid !== request.registrar_aid)
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_MISMATCH', 'receipt registrar does not match request');
+    if (expectedServiceAid !== undefined && receipt.service_aid !== expectedServiceAid)
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'receipt service AID mismatch');
+    if (now !== undefined && (!isInt(now) || now < receipt.registered_at || now >= receipt.exp))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'receipt is outside its validity window');
+    signature(receipt.signature);
+}
+export async function verifyRegistrationReceipt(receipt, credential, request, resolveCertificate, expectedServiceAid, now) {
+    if (!isRecord(request))
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'request must be an object');
+    validateCredential(credential, 0, request.proof_chain);
+    try {
+        validateRegistrationReceipt(receipt, credential, request, expectedServiceAid, now);
+    }
+    catch (error) {
+        if (error instanceof ProtocolError && error.code === 'CREDENTIAL_INVALID') {
+            throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'registration receipt structure is invalid');
+        }
+        throw error;
+    }
+    const value = receipt;
+    const signatureValue = value.signature;
+    try {
+        const payload = { ...value };
+        delete payload.signature;
+        await verifyAgentSignature(signatureValue, payload, String(value.service_aid), resolveCertificate, now);
+    }
+    catch {
+        throw new ProtocolError('CREDENTIAL_REGISTRATION_RECEIPT_INVALID', 'registration receipt signature verification failed');
+    }
+}
+export function digest(value) {
+    return `sha256:${sha256Hex(canonicalJson(value))}`;
+}
+function sha256Hex(input) {
+    const K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
+    const bytes = new Uint8Array(input.length + 1 + ((55 - input.length) % 64 + 64) % 64 + 8);
+    bytes.set(input);
+    bytes[input.length] = 0x80;
+    const view = new DataView(bytes.buffer);
+    const bits = input.length * 8;
+    view.setUint32(bytes.length - 4, bits >>> 0, false);
+    view.setUint32(bytes.length - 8, Math.floor(bits / 0x100000000), false);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    let h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+    for (let offset = 0; offset < bytes.length; offset += 64) {
+        const w = new Uint32Array(64);
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(offset + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const x = w[i - 15], y = w[i - 2];
+            w[i] = (w[i - 16] + (rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3)) + w[i - 7] + (rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10))) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + s1 + ch + K[i] + w[i]) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (s0 + maj) >>> 0;
+            [hh, g, f, e, d, c, b, a] = [g, f, e, (d + t1) >>> 0, c, b, a, (t1 + t2) >>> 0];
+        }
+        h = h.map((v, i) => (v + [a, b, c, d, e, f, g, hh][i]) >>> 0);
+    }
+    return h.map((v) => v.toString(16).padStart(8, '0')).join('');
+}
+export function orgRequestParams(method, params) {
+    if (!method.startsWith('org.'))
+        return params;
+    const orgId = params.org_id ?? null;
+    if (orgId === null) {
+        if (!['org.lifecycle.list', 'org.health', 'org.status'].includes(method))
+            throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'org_id is required');
+    }
+    else if (typeof orgId !== 'string' || !AID_RE.test(orgId))
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'org_id is invalid');
+    const aad = params.aad === undefined ? {} : params.aad;
+    if (!isRecord(aad))
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'organization AAD is invalid');
+    if ('org_id' in aad && aad.org_id !== orgId)
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'AAD org_id does not match request');
+    return { ...params, aad: { ...aad, org_id: orgId } };
+}
+function orgRequestBindingParams(method, params) {
+    const prepared = orgRequestParams(method, params);
+    const result = Object.fromEntries(Object.entries(prepared).filter(([key]) => !['request_binding', 'client_signature'].includes(key) && !key.startsWith('_')));
+    if (method.startsWith('org.') && isRecord(result.credentials))
+        result.credentials = Object.fromEntries(Object.entries(result.credentials).filter(([key]) => key !== 'representation_proof'));
+    return result;
+}
+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 || 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 };
+}
+export function validateRequestBinding(binding, method, target, params, credentialCid, nonce, requestId, now) {
+    const fields = ['request_id', 'nonce', 'target', 'method', 'params_hash', 'iat', 'exp', 'credential_cid'];
+    if (!isRecord(binding) || Object.keys(binding).length !== fields.length || Object.keys(binding).some((key) => !fields.includes(key)))
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request binding is invalid');
+    if (![binding.request_id, binding.nonce, binding.target, binding.method, binding.params_hash].every((value) => typeof value === 'string' && value.length > 0) || typeof binding.credential_cid !== 'string' || (!binding.credential_cid !== (method === 'credential.revocationList')))
+        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 || 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) {
+    return new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', message);
+}
+function validateRepresentationSignature(value) {
+    if (!isRecord(value) || !['cert_fingerprint', 'timestamp', 'signature'].every((field) => field in value) || Object.keys(value).some((key) => !REPRESENTATION_SIGNATURE_FIELDS.has(key)))
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation signature structure is invalid');
+    if (typeof value.cert_fingerprint !== 'string' || !FINGERPRINT_RE.test(value.cert_fingerprint))
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation certificate fingerprint is invalid');
+    if (value.public_key_fingerprint !== undefined && (typeof value.public_key_fingerprint !== 'string' || !FINGERPRINT_RE.test(value.public_key_fingerprint)))
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation public key fingerprint is invalid');
+    if (!isInt(value.timestamp) || value.timestamp < 0)
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation signature timestamp is invalid');
+    if (typeof value.signature !== 'string' || !strictDerBase64(value.signature))
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation signature encoding is invalid');
+}
+function validateRepresentationContext(proof, credential, request, now) {
+    if (!isRecord(request))
+        throw representationBindingInvalid('representation request is invalid');
+    if (Object.keys(request).length !== 6 || Object.keys(request).some((key) => !['from', 'for', 'audience', 'resource', 'params', 'binding'].includes(key)))
+        throw representationBindingInvalid('representation request is invalid');
+    for (const field of ['from', 'for', 'audience', 'resource'])
+        if (typeof request[field] !== 'string' || !request[field])
+            throw representationBindingInvalid('representation request is invalid');
+    for (const field of ['from', 'for', 'audience'])
+        if (!AID_RE.test(request[field]))
+            throw representationBindingInvalid(`representation request ${field} is invalid`);
+    if (!isRecord(request.params) || !isRecord(request.binding))
+        throw representationBindingInvalid('representation request is invalid');
+    const binding = request.binding;
+    if (typeof binding.method !== 'string' || !binding.method || typeof binding.target !== 'string' || !binding.target)
+        throw representationBindingInvalid('representation request binding is invalid');
+    validateRequestBinding(binding, binding.method, binding.target, request.params, String(credential.cid), String(binding.nonce ?? ''), String(binding.request_id ?? ''), now);
+    if (binding.target !== request.audience || proof.issuer !== request.from)
+        throw representationBindingInvalid('representation signer or service target does not match request');
+    if (proof.from !== request.from || proof.for !== request.for || proof.audience !== request.audience || proof.resource !== request.resource)
+        throw representationBindingInvalid('representation identity does not match request');
+    if (proof.represented !== credential.sub || proof.credential_cid !== credential.cid)
+        throw representationBindingInvalid('representation subject does not match credential');
+    if (proof.method !== binding.method || proof.params_hash !== binding.params_hash || proof.nonce !== binding.nonce)
+        throw representationBindingInvalid('representation operation does not match request');
+    if (proof.iat !== binding.iat || proof.exp !== binding.exp)
+        throw representationBindingInvalid('representation time window does not match request');
+}
+export async function verifyRepresentationProof(proof, credential, request, resolveCertificate, now, proofChain) {
+    if (!isRecord(proof) || Object.keys(proof).length !== REPRESENTATION_FIELDS.size || Object.keys(proof).some((key) => !REPRESENTATION_FIELDS.has(key)))
+        throw representationBindingInvalid('representation proof is invalid');
+    for (const field of ['issuer', 'represented', 'from', 'for', 'audience', 'credential_cid', 'method', 'resource', 'params_hash', 'nonce'])
+        if (typeof proof[field] !== 'string' || !proof[field])
+            throw representationBindingInvalid('representation proof is invalid');
+    for (const field of ['issuer', 'represented', 'from', 'for', 'audience'])
+        if (!AID_RE.test(proof[field]))
+            throw representationBindingInvalid('representation proof AID is invalid');
+    if (!DIGEST_RE.test(proof.params_hash))
+        throw representationBindingInvalid('representation params_hash is invalid');
+    if (!isInt(proof.iat) || !isInt(proof.exp) || proof.exp <= proof.iat || !isInt(now) || now < proof.iat || now >= proof.exp)
+        throw representationBindingInvalid('representation time window is invalid');
+    validateRepresentationSignature(proof.signature);
+    if (!isRecord(credential))
+        throw new ProtocolError('CREDENTIAL_INVALID', 'credential must be an object');
+    validateCredential(credential, 0, proofChain);
+    try {
+        const certPem = certificatePem(await resolveCertificate(proof.signature.cert_fingerprint));
+        if (!certPem || !publicKeyDerB64(certPem))
+            throw new Error('certificate is missing');
+        if ((await certFingerprint(certPem)).toLowerCase() !== proof.signature.cert_fingerprint.toLowerCase())
+            throw new Error('certificate fingerprint mismatch');
+        const metadata = parseCertMetadata(certPem);
+        if (metadata.subject.toLowerCase() !== String(proof.issuer).toLowerCase())
+            throw new Error('certificate subject does not match issuer');
+        if (proof.signature.public_key_fingerprint !== undefined && (await publicKeyFingerprint(certPem)).toLowerCase() !== String(proof.signature.public_key_fingerprint).toLowerCase())
+            throw new Error('public key fingerprint mismatch');
+        const timestamp = proof.signature.timestamp;
+        if (timestamp > now + 300 || timestamp < proof.iat || timestamp >= proof.exp)
+            throw new Error('representation signature timestamp is outside its window');
+        if (timestamp < Math.floor(metadata.notBefore.getTime() / 1000) || timestamp > Math.floor(metadata.notAfter.getTime() / 1000) || now < Math.floor(metadata.notBefore.getTime() / 1000) || now > Math.floor(metadata.notAfter.getTime() / 1000))
+            throw new Error('certificate is not valid at signature or verification time');
+        const payload = { ...proof };
+        delete payload.signature;
+        if (!await verifySignatureWithCert(certPem, proof.signature.signature, canonicalJson(payload)))
+            throw new Error('representation proof signature verification failed');
+    }
+    catch {
+        throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'representation proof signature verification failed');
+    }
+    validateRepresentationContext(proof, credential, request, now);
+}
+export function validateRequestNonce(nonce, usedNonces) {
+    if (typeof nonce !== 'string' || nonce.length === 0 || usedNonces.includes(nonce))
+        throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request nonce has already been used');
+}
+export function validateIdempotency(existing, incoming) {
+    if (existing.request_id === incoming.request_id && digest(existing) !== digest(incoming))
+        throw new ProtocolError('CREDENTIAL_IDEMPOTENCY_KEY_REUSE', 'request id was reused with a different payload');
+}
+export function buildRpcRequest(id, method, params) {
+    return { jsonrpc: '2.0', id, method, params };
+}
+export function buildRpcNotification(method, params) {
+    return { jsonrpc: '2.0', method, params };
+}
+export function buildRpcResult(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+export function buildRpcError(id, code, message, errorCode) {
+    return { jsonrpc: '2.0', id, error: { code, message, data: { error_code: errorCode } } };
+}
+export function parseJsonStrict(text, normalizeKeys = true) {
+    try {
+        let index = scanValue(text, 0, normalizeKeys);
+        index = skipWhitespace(text, index);
+        if (index !== text.length)
+            throw new Error('trailing JSON data');
+        const value = JSON.parse(text);
+        if (normalizeKeys)
+            normalizeNfc(value);
+        else {
+            validateOrgRequestJSON(value);
+            baseCanonicalJson(value);
+        }
+        return value;
+    }
+    catch (error) {
+        if (error instanceof ProtocolError)
+            throw error;
+        throw invalid(error instanceof Error ? error.message : String(error));
+    }
+}
+function skipWhitespace(text, index) {
+    while (index < text.length && /\s/.test(text[index]))
+        index++;
+    return index;
+}
+function scanString(text, start) {
+    if (text[start] !== '"')
+        throw new Error('expected string');
+    let escaped = false;
+    for (let index = start + 1; index < text.length; index++) {
+        const char = text[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"')
+            return index + 1;
+    }
+    throw new Error('unterminated string');
+}
+function scanValue(text, start, normalizeKeys = true) {
+    const index = skipWhitespace(text, start);
+    const char = text[index];
+    if (char === '"')
+        return scanString(text, index);
+    if (char === '{')
+        return scanObject(text, index, normalizeKeys);
+    if (char === '[')
+        return scanArray(text, index, normalizeKeys);
+    for (const literal of ['true', 'false', 'null'])
+        if (text.startsWith(literal, index))
+            return index + literal.length;
+    if (char && '-0123456789'.includes(char)) {
+        let end = index + 1;
+        while (end < text.length && !/[\s,\]}]/.test(text[end]))
+            end++;
+        const token = text.slice(index, end);
+        const parts = /^-?(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(token);
+        if (parts && Number.isInteger(Number(token))) {
+            const digits = parts[1] + (parts[2] ?? '');
+            const fraction = (parts[2]?.length ?? 0) - Number(parts[3] ?? 0);
+            if (fraction > 0 && /[1-9]/.test(digits.slice(-Math.min(fraction, digits.length))))
+                throw invalid('JSON fraction rounded to an integer');
+        }
+        return end;
+    }
+    throw new Error('invalid JSON value');
+}
+function scanArray(text, start, normalizeKeys = true) {
+    let index = skipWhitespace(text, start + 1);
+    if (text[index] === ']')
+        return index + 1;
+    while (true) {
+        index = scanValue(text, index, normalizeKeys);
+        index = skipWhitespace(text, index);
+        if (text[index] === ']')
+            return index + 1;
+        if (text[index] !== ',')
+            throw new Error('expected comma');
+        index = skipWhitespace(text, index + 1);
+    }
+}
+function scanObject(text, start, normalizeKeys = true) {
+    let index = skipWhitespace(text, start + 1);
+    const keys = new Set();
+    if (text[index] === '}')
+        return index + 1;
+    while (true) {
+        const keyStart = index;
+        const keyEnd = scanString(text, keyStart);
+        const key = (normalizeKeys ? normalizeNfc(JSON.parse(text.slice(keyStart, keyEnd))) : JSON.parse(text.slice(keyStart, keyEnd)));
+        if (keys.has(key))
+            throw invalid('duplicate object key');
+        keys.add(key);
+        index = skipWhitespace(text, keyEnd);
+        if (text[index] !== ':')
+            throw new Error('expected colon');
+        index = scanValue(text, index + 1, normalizeKeys);
+        index = skipWhitespace(text, index);
+        if (text[index] === '}')
+            return index + 1;
+        if (text[index] !== ',')
+            throw new Error('expected comma');
+        index = skipWhitespace(text, index + 1);
+    }
+}
+//# sourceMappingURL=org-protocol.js.map