@agentunion/fastaun 0.5.26 → 0.5.28

package/dist/semantic-protocol.js

@@ -0,0 +1,894 @@
+import { canonicalJson as messageCanonical } from './v2/crypto/canonical.js';
+import { decryptMessageWithEvidence } from './v2/e2ee/decrypt.js';
+import { createHash, verify as verifySignature, X509Certificate } from 'node:crypto';
+import { canonicalJson as legacyCanonicalJson, parseJsonStrict as legacyParseJsonStrict, validateCapability } from './org-protocol.js';
+import { certCommonName, publicKeyFingerprint } from './cert-utils.js';
+export const CLOCK_SKEW_SECONDS = 300;
+export const SIGNATURE_PROFILE = 'aun-cap-sign/1';
+export const SEMANTIC_VERSION = 'aun-cap/semantic-1';
+export const SIGNATURE_DOMAINS = [
+    'semantic-credential', 'registration-metadata', 'registration-receipt', 'credential-status',
+    'usage-allocation', 'allocation-status', 'semantic-crl', 'usage-transition',
+    'usage-checkpoint', 'usage-acceptance', 'ledger-abort',
+];
+export class SemanticProtocolError extends Error {
+    code;
+    field;
+    retryable;
+    constructor(code, message, field) {
+        super(`${code}: ${message}`);
+        this.code = code;
+        this.field = field;
+        this.name = 'SemanticProtocolError';
+        this.retryable = code === 'SEMANTIC_STATE_UNAVAILABLE';
+    }
+}
+function invalid(message) { throw new SemanticProtocolError('SEMANTIC_FORMAT_INVALID', message); }
+function object(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        invalid('expected JSON object');
+}
+function shape(value, fields) {
+    object(value);
+    const allowed = new Set(Object.keys(fields).map(key => key.replace(/\?$/, '')));
+    for (const key of Object.keys(value))
+        if (!allowed.has(key))
+            invalid(`unknown field: ${key}`);
+    for (const [declared, check] of Object.entries(fields)) {
+        const key = declared.replace(/\?$/, '');
+        if (!Object.hasOwn(value, key)) {
+            if (declared.endsWith('?'))
+                continue;
+            invalid(`missing field: ${key}`);
+        }
+        check(value[key]);
+    }
+}
+const string = value => { if (typeof value !== 'string' || value.length === 0)
+    invalid('expected nonempty string'); };
+const text = value => { string(value); if (!value.trim())
+    invalid('expected nonempty text'); };
+const integer = value => { if (!Number.isSafeInteger(value) || value < 0)
+    invalid('expected nonnegative safe integer'); };
+const positive = value => { integer(value); if (value === 0)
+    invalid('expected positive safe integer'); };
+const aid = value => { string(value); if (!/^[^\s/]+\.[^\s/]+$/.test(value))
+    invalid('invalid AID'); };
+const hash = value => { if (typeof value !== 'string' || !/^sha256:[0-9a-f]{64}$/.test(value))
+    invalid('invalid SHA-256 digest'); };
+const boolean = value => { if (typeof value !== 'boolean')
+    invalid('expected boolean'); };
+const decimal = value => { if (typeof value !== 'string' || !/^(0|[1-9]\d*)(\.\d*[1-9])?$/.test(value))
+    invalid('expected canonical unsigned decimal'); };
+const jsonObject = value => { object(value); canonicalJson(value); };
+const literal = (...values) => value => { if (!values.includes(value))
+    invalid('invalid literal value'); };
+const nullable = (check) => value => { if (value !== null)
+    check(value); };
+const array = (check, minimum = 0) => value => {
+    if (!Array.isArray(value) || value.length < minimum)
+        invalid('invalid array');
+    value.forEach(check);
+};
+function compareCodePoints(a, b) {
+    const aa = Array.from(a), bb = Array.from(b);
+    for (let i = 0; i < Math.min(aa.length, bb.length); i++) {
+        const diff = aa[i].codePointAt(0) - bb[i].codePointAt(0);
+        if (diff)
+            return diff;
+    }
+    return aa.length - bb.length;
+}
+function sorted(values, key = value => value) {
+    for (let i = 1; i < values.length; i++)
+        if (compareCodePoints(key(values[i - 1]), key(values[i])) >= 0)
+            invalid('collection must be sorted and unique');
+}
+const set = (check, minimum = 0) => value => { array(check, minimum)(value); sorted(value); };
+const policy = value => shape(value, { authority: aid, id: string, version: string, hash });
+const usageRef = value => shape(value, { epoch: positive, hash });
+const revisionFields = { cid: string, original_hash: hash, metadata_hash: hash, metadata_version: string };
+const revision = value => shape(value, revisionFields);
+const audienceRevision = value => shape(value, { audience: aid, revision });
+const withdrawn = value => shape(value, { audience: aid, state_seq: positive, last_revision: revision });
+const revokedAudience = value => shape(value, { audience: aid, revision, state_seq: positive });
+const audienceSet = (check, minimum = 0) => value => { array(check, minimum)(value); sorted(value, item => item.audience); };
+const nonce = value => {
+    string(value);
+    if (!/^[A-Za-z0-9_-]+$/.test(value))
+        invalid('nonce must be unpadded base64url');
+    const bytes = Buffer.from(value, 'base64url');
+    if (bytes.length < 16 || bytes.toString('base64url') !== value)
+        invalid('nonce must contain at least 128 bits');
+};
+export function canonicalJson(value) {
+    try {
+        return legacyCanonicalJson(value);
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : String(error));
+    }
+}
+export function parseJsonStrict(value) {
+    try {
+        const source = typeof value === 'string' ? value : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(value);
+        return legacyParseJsonStrict(source);
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : String(error));
+    }
+}
+export function digest(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
+}
+export function bytesDigest(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+export function decodeBase64(value) {
+    if (typeof value !== 'string' || value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+        invalid('invalid padded Base64');
+    const bytes = Buffer.from(value, 'base64');
+    if (bytes.toString('base64') !== value)
+        invalid('noncanonical Base64');
+    return bytes;
+}
+export function decodeSignedJson(value) {
+    shape(value, { bytes_base64: item => { decodeBase64(item); } });
+    return parseJsonStrict(decodeBase64(value.bytes_base64));
+}
+export function encodeSignedJson(value) {
+    return { bytes_base64: Buffer.from(canonicalJson(value)).toString('base64') };
+}
+function signature(value) {
+    shape(value, { profile: literal(SIGNATURE_PROFILE), cert_fingerprint: hash, 'public_key_fingerprint?': hash, timestamp: integer, signature: string });
+    const bytes = decodeBase64(value.signature);
+    if (bytes.length < 8 || bytes.length > 72 || bytes[0] !== 0x30 || bytes[1] !== bytes.length - 2)
+        invalid('signature must be strict P-256 DER');
+    let offset = 2;
+    const order = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n;
+    for (let index = 0; index < 2; index++) {
+        if (bytes[offset++] !== 2)
+            invalid('signature must contain two DER integers');
+        const length = bytes[offset++];
+        if (!length || length > 33 || offset + length > bytes.length)
+            invalid('invalid DER integer length');
+        const part = bytes.slice(offset, offset + length);
+        if (part[0] & 128 || part[0] === 0 && (length === 1 || part[1] < 128))
+            invalid('nonminimal DER integer');
+        const number = BigInt('0x' + Buffer.from(part).toString('hex'));
+        if (number <= 0n || number >= order)
+            invalid('signature scalar outside P-256 range');
+        offset += length;
+    }
+    if (offset !== bytes.length)
+        invalid('trailing DER signature bytes');
+}
+function signatureOf(domain, value) {
+    return domain === 'registration-metadata' ? value.confirmation.signature : value.signature;
+}
+function checkDomain(domain) {
+    if (!SIGNATURE_DOMAINS.includes(domain))
+        invalid('unsupported signature domain');
+}
+export function signingPayload(domain, value) {
+    checkDomain(domain);
+    canonicalJson(value);
+    const unsigned = parseJsonStrict(canonicalJson(value));
+    object(unsigned);
+    if (domain === 'registration-metadata')
+        object(unsigned.confirmation);
+    const block = signatureOf(domain, unsigned);
+    object(block);
+    delete block.signature;
+    return canonicalJson([SIGNATURE_PROFILE, domain, unsigned]);
+}
+export function validateWindow(nbf, exp, now) {
+    integer(nbf);
+    integer(now);
+    if (exp !== null) {
+        integer(exp);
+        if (exp <= nbf)
+            invalid('invalid original validity interval');
+    }
+    if (nbf - now > CLOCK_SKEW_SECONDS || exp !== null && now - exp > CLOCK_SKEW_SECONDS)
+        invalid('outside validity window');
+}
+function proofTime(value, maximum, now) {
+    if (value.valid_until <= value.as_of || value.valid_until - value.as_of > maximum)
+        invalid('invalid proof declaration interval');
+    if (value.signature.timestamp !== value.as_of)
+        invalid('proof signature timestamp must equal as_of');
+    if (now !== undefined)
+        validateWindow(value.as_of, value.valid_until, now);
+}
+function eventTime(value) {
+    if (value.signature.timestamp !== value.as_of)
+        invalid('signature timestamp must equal as_of');
+}
+export function validateAuthorizationRequestTime(value, now) {
+    integer(value.expires_at);
+    integer(now);
+    if (value.expires_at - now > 600 || now - value.expires_at > 300)
+        invalid('outside authorization request validity window');
+}
+export function validateEvidenceRef(value) {
+    shape(value, { profile: string, hash, location: location => {
+            object(location);
+            if (location.kind === 'inline')
+                shape(location, { kind: literal('inline'), data_base64: item => { decodeBase64(item); } });
+            else
+                shape(location, { kind: literal('aun_ref'), ref: string });
+        } });
+}
+function evidenceProfile(profile) {
+    literal('aun-e2ee-v2-envelope-raw/1', 'aun-cap-usage-allocation/1', 'aun-evidence-bytes/1')(profile);
+}
+function evidenceBytes(value) {
+    return ArrayBuffer.isView(value) && Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+function evidenceLocator(value) {
+    if (!value.startsWith('aun-ref:1:'))
+        invalid('unsupported AUN evidence locator');
+    const encoded = value.slice('aun-ref:1:'.length);
+    if (!/^[A-Za-z0-9_-]+$/.test(encoded))
+        invalid('invalid evidence locator Base64url');
+    const bytes = decodeBase64(encoded.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - encoded.length % 4) % 4));
+    if (Buffer.from(bytes).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '') !== encoded)
+        invalid('noncanonical evidence locator Base64url');
+    const locator = parseJsonStrict(bytes);
+    shape(locator, { resolver: literal('aun-evidence-archive/1'), service_aid: aid, object_id: string, object_version: string });
+    const canonical = canonicalJson(locator);
+    if (canonical.length !== bytes.length || canonical.some((byte, index) => byte !== bytes[index]))
+        invalid('noncanonical evidence locator JSON');
+    return locator;
+}
+export async function createEvidenceRef(bytes, profile, locator) {
+    if (!evidenceBytes(bytes))
+        invalid('evidence requires original bytes');
+    evidenceProfile(profile);
+    const ref = { profile, hash: bytesDigest(bytes), location: locator
+            ? { kind: 'aun_ref', ref: 'aun-ref:1:' + Buffer.from(canonicalJson(locator)).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '') }
+            : { kind: 'inline', data_base64: Buffer.from(bytes).toString('base64') } };
+    validateEvidenceRef(ref);
+    if (ref.location.kind === 'aun_ref')
+        evidenceLocator(ref.location.ref);
+    return ref;
+}
+export async function resolveEvidence(ref, resolvers = {}) {
+    validateEvidenceRef(ref);
+    evidenceProfile(ref.profile);
+    let bytes;
+    if (ref.location.kind === 'inline')
+        bytes = decodeBase64(ref.location.data_base64);
+    else {
+        const locator = evidenceLocator(ref.location.ref);
+        const resolver = Object.hasOwn(resolvers, locator.service_aid) ? resolvers[locator.service_aid] : undefined;
+        if (typeof resolver !== 'function')
+            throw new SemanticProtocolError('SEMANTIC_STATE_UNAVAILABLE', 'trusted evidence archive resolver is unavailable');
+        bytes = await resolver(locator);
+    }
+    if (!evidenceBytes(bytes) || bytesDigest(bytes) !== ref.hash)
+        throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'resolved evidence bytes differ from signed hash');
+    return new Uint8Array(bytes);
+}
+export async function archiveMessage(envelope, received) {
+    const bytes = evidenceBytes(envelope) ? new Uint8Array(envelope) : new TextEncoder().encode(typeof envelope === 'string' ? envelope : JSON.stringify(envelope));
+    const parsed = parseJsonStrict(bytes);
+    object(parsed);
+    if (parsed.version !== 'v2' || !['e2ee.p2p_encrypted', 'e2ee.group_encrypted'].includes(parsed.type))
+        invalid('archive requires a V2 encrypted envelope');
+    shape(received, { received_by: aid, received_at: integer, source: string });
+    return { envelope: await createEvidenceRef(bytes, 'aun-e2ee-v2-envelope-raw/1'), envelope_bytes: bytes, ...received };
+}
+async function verifiedMessage(ref, context) {
+    messageBody(ref);
+    if (ref.envelope.profile !== 'aun-e2ee-v2-envelope-raw/1')
+        invalid('unsupported message evidence profile');
+    const envelope = parseJsonStrict(await resolveEvidence(ref.envelope, context.resolvers));
+    object(envelope);
+    object(envelope.aad);
+    const aad = envelope.aad;
+    if (envelope.version !== 'v2' || envelope.suite !== 'P256_HKDF_SHA256_AES_256_GCM' || aad.suite !== envelope.suite)
+        invalid('invalid V2 message suite');
+    integer(aad.timestamp);
+    string(aad.from_device);
+    string(aad.wrap_protocol);
+    if (aad.from !== ref.sender || aad.message_id !== ref.message_id)
+        throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'protected message identity differs from signed reference');
+    if (ref.conversation.kind === 'p2p') {
+        if (envelope.type !== 'e2ee.p2p_encrypted' || aad.to !== ref.conversation.to || context.selfAid !== aad.to)
+            throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'P2P reference or original recipient differs');
+    }
+    else if (envelope.type !== 'e2ee.group_encrypted' || aad.group_id !== ref.conversation.group_id || aad.epoch !== ref.conversation.epoch
+        || digest(aad.state_commitment) !== digest(ref.conversation.state_commitment))
+        throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'group epoch or state commitment differs');
+    if (!Array.isArray(envelope.recipients) && (!envelope.recipient || envelope.merkle_proof !== undefined && !Array.isArray(envelope.merkle_proof)))
+        throw new SemanticProtocolError('SEMANTIC_STATE_UNAVAILABLE', 'original recipient collection or Merkle proof is required');
+    if (typeof envelope.recipients_digest !== 'string' || !/^[0-9a-f]{64}$/.test(envelope.recipients_digest))
+        invalid('invalid original recipient digest');
+    const ciphertext = decodeBase64(envelope.ciphertext), tag = decodeBase64(envelope.tag), nonce = decodeBase64(envelope.nonce), signature = decodeBase64(envelope.sender_signature);
+    decodeBase64(envelope.sender_session_pk);
+    string(envelope.sender_cert_fingerprint);
+    if (tag.length !== 16 || nonce.length !== 12 || signature.length !== 64)
+        invalid('invalid V2 encryption or RAW signature lengths');
+    const aadBytes = messageCanonical(aad), root = new Uint8Array(envelope.recipients_digest.match(/../g).map((value) => parseInt(value, 16)));
+    const core = new Uint8Array(ciphertext.length + tag.length + aadBytes.length + root.length);
+    let offset = 0;
+    for (const part of [ciphertext, tag, aadBytes, root]) {
+        core.set(part, offset);
+        offset += part.length;
+    }
+    if (bytesDigest(core) !== ref.signed_core_hash)
+        throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'message signed core differs from reference');
+    if (typeof context.resolveSenderKey !== 'function' || typeof context.verifySenderIdentity !== 'function')
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'trusted historical sender identity adapter is required');
+    const signedAt = Math.trunc(aad.timestamp / 1000), fingerprint = envelope.sender_cert_fingerprint;
+    const senderKey = await context.resolveSenderKey(ref.sender, aad.from_device, fingerprint, signedAt);
+    await context.verifySenderIdentity(ref.sender, aad.from_device, fingerprint, signedAt, senderKey);
+    const keys = context.resolveDecryptionKeys ? await context.resolveDecryptionKeys(envelope) : { ikPriv: context.selfIkPrivate, spkPriv: context.selfSpkPrivate };
+    if (!evidenceBytes(keys.ikPriv))
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'original receiver decryption keys are required');
+    const decrypted = decryptMessageWithEvidence(envelope, context.selfAid, context.selfDeviceId, keys.ikPriv, keys.spkPriv, senderKey);
+    if (!decrypted)
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'receiver has no valid original recipient row');
+    const payload = parseJsonStrict(decrypted.payloadBytes);
+    object(payload);
+    if (!['text', 'quote'].includes(payload.type))
+        invalid('semantic message requires original text or quote payload');
+    text(payload.text);
+    return { text: payload.text, payload_hash: bytesDigest(decrypted.payloadBytes) };
+}
+async function verifyEvidenceProfile(ref, context) {
+    const bytes = await resolveEvidence(ref, context.resolvers);
+    if (ref.profile === 'aun-e2ee-v2-envelope-raw/1') {
+        const envelope = parseJsonStrict(bytes);
+        object(envelope);
+        object(envelope.aad);
+        const aad = envelope.aad;
+        const ciphertext = decodeBase64(envelope.ciphertext), tag = decodeBase64(envelope.tag), aadBytes = messageCanonical(aad);
+        if (typeof envelope.recipients_digest !== 'string' || !/^[0-9a-f]{64}$/.test(envelope.recipients_digest))
+            invalid('invalid original recipient digest');
+        const root = new Uint8Array(envelope.recipients_digest.match(/../g).map((value) => parseInt(value, 16)));
+        const core = new Uint8Array(ciphertext.length + tag.length + aadBytes.length + root.length);
+        let offset = 0;
+        for (const part of [ciphertext, tag, aadBytes, root]) {
+            core.set(part, offset);
+            offset += part.length;
+        }
+        await verifiedMessage({ sender: aad.from, message_id: aad.message_id, signed_core_hash: bytesDigest(core),
+            conversation: envelope.type === 'e2ee.p2p_encrypted' ? { kind: 'p2p', to: aad.to }
+                : { kind: 'group', group_id: aad.group_id, epoch: aad.epoch, state_commitment: aad.state_commitment }, envelope: ref }, context);
+    }
+    else if (ref.profile === 'aun-cap-usage-allocation/1') {
+        const allocation = parseJsonStrict(bytes), canonical = canonicalJson(allocation);
+        if (canonical.length !== bytes.length || canonical.some((byte, index) => byte !== bytes[index]))
+            invalid('allocation evidence must retain canonical signed bytes');
+        await verifyRecord('usage-allocation', allocation, { ...context, expectedAid: undefined });
+    }
+}
+export async function verifyMessageBody(value, context) {
+    object(value);
+    const credential = (Object.hasOwn(value, 'bytes_base64') ? decodeSignedJson(value) : value);
+    if (typeof context.resolveCertificate !== 'function' || typeof context.verifyCertificateTrust !== 'function')
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'explicit certificate resolver and trust verifier are required');
+    await verifyRecord('semantic-credential', credential, context);
+    const evidence = new Set();
+    for (const ref of credential.authorization.evidence ?? []) {
+        await verifyEvidenceProfile(ref, context);
+        evidence.add(ref.hash);
+    }
+    if (credential.authorization.kind === 'text')
+        return { credential_hash: digest(credential), body_hash: bytesDigest(new TextEncoder().encode(credential.authorization.text)), text: credential.authorization.text, evidence_hashes: [...evidence].sort() };
+    const ref = credential.authorization.message, verified = await verifiedMessage(ref, context);
+    evidence.add(ref.envelope.hash);
+    for (const item of ref.context ?? []) {
+        if (item.profile !== 'aun-e2ee-v2-envelope-raw/1')
+            invalid('necessary context requires message evidence profile');
+        await verifyEvidenceProfile(item, context);
+        evidence.add(item.hash);
+    }
+    for (const item of ref.attachments ?? []) {
+        if (item.profile !== 'aun-evidence-bytes/1')
+            invalid('attachment requires original bytes profile');
+        await resolveEvidence(item, context.resolvers);
+        evidence.add(item.hash);
+    }
+    return { credential_hash: digest(credential), body_hash: bytesDigest(new TextEncoder().encode(verified.text)), payload_hash: verified.payload_hash, text: verified.text, evidence_hashes: [...evidence].sort() };
+}
+function messageBody(value) {
+    shape(value, {
+        message_id: string, sender: aid, signed_core_hash: hash,
+        conversation: conversation => {
+            object(conversation);
+            if (conversation.kind === 'p2p')
+                shape(conversation, { kind: literal('p2p'), to: aid });
+            else
+                shape(conversation, { kind: literal('group'), group_id: string, epoch: integer, state_commitment: jsonObject });
+        }, envelope: validateEvidenceRef, 'context?': array(validateEvidenceRef), 'attachments?': array(validateEvidenceRef),
+    });
+}
+function capability(value) {
+    shape(value, { ns: string, action: string, resource: string, constraints: array(item => shape(item, {
+            type: string, field: string, value: item => { canonicalJson(item); }, 'operator?': string, 'unit?': string,
+        })) });
+    try {
+        validateCapability(value);
+    }
+    catch (error) {
+        invalid(error instanceof Error ? error.message : String(error));
+    }
+}
+export function validateSemanticCredential(value, now) {
+    canonicalJson(value);
+    shape(value, {
+        ver: literal(SEMANTIC_VERSION), cid: string, cap: array(capability), authorization: basis => {
+            object(basis);
+            if (basis.kind === 'text')
+                shape(basis, { kind: literal('text'), text, 'evidence?': array(validateEvidenceRef) });
+            else
+                shape(basis, { kind: literal('message_ref'), message: messageBody, 'evidence?': array(validateEvidenceRef) });
+        }, signature, 'iss?': aid, 'sub?': aid, 'aud?': set(aid, 1), 'iat?': integer, 'nbf?': integer,
+        'exp?': integer, 'key_version?': string, 'delegate?': boolean, 'parent?': string,
+        'delegation_depth?': item => { integer(item); if (item > 8)
+            invalid('delegation depth exceeds 8'); },
+        'proof_chain?': array(jsonObject), 'security_level?': literal('low', 'medium', 'high'),
+        'revocation_endpoint?': item => { canonicalJson(item); }, 'credential_service?': jsonObject, 'ext?': jsonObject,
+    });
+    const item = value;
+    if (item.nbf !== undefined && item.exp !== undefined && item.nbf >= item.exp)
+        invalid('invalid credential interval');
+    if (item.iat !== undefined && item.exp !== undefined && item.iat >= item.exp)
+        invalid('invalid credential issuance interval');
+    if (now !== undefined) {
+        if (item.iat !== undefined && item.iat - now > 300)
+            invalid('credential iat is in the future');
+        validateWindow(item.nbf ?? 0, item.exp ?? null, now);
+    }
+}
+export function validateUsageContract(value) {
+    shape(value, {
+        grant_key: hash, epoch: positive, audiences: set(aid, 1), ledger: ledger => {
+            object(ledger);
+            if (ledger.scope === 'global')
+                shape(ledger, { scope: literal('global'), authority: aid });
+            else
+                shape(ledger, { scope: literal('per_aud'), authorities: authorities => { object(authorities); for (const [key, value] of Object.entries(authorities)) {
+                        aid(key);
+                        aid(value);
+                    } } });
+        }, limits: array(limit => shape(limit, { id: string, metric: string, unit: string, limit: decimal }), 1), 'allocations?': array(validateEvidenceRef),
+    });
+    const item = value;
+    if (new Set(item.limits.map(limit => limit.id)).size !== item.limits.length)
+        invalid('duplicate usage limit id');
+    if (item.ledger.scope === 'per_aud' && digest(Object.keys(item.ledger.authorities).sort(compareCodePoints)) !== digest(item.audiences))
+        invalid('ledger authorities must cover exactly audiences');
+}
+export function validateRegistrationMetadata(value, now) {
+    canonicalJson(value);
+    shape(value, {
+        original_hash: hash, version: string, confirmed_at: integer, iss: aid, sub: aid, aud: set(aid, 1),
+        nbf: integer, exp: nullable(integer), use_limit: nullable(integer), 'usage?': validateUsageContract,
+        delegate: boolean, 'parent?': string, 'delegation_depth?': item => { integer(item); if (item > 8)
+            invalid('delegation depth exceeds 8'); },
+        'proof_chain?': array(jsonObject), policy,
+        confirmation: confirmation => shape(confirmation, { authority: aid, authorization: policy, audiences: set(aid, 1), signature }),
+    });
+    const item = value;
+    if (item.exp !== null && item.nbf >= item.exp)
+        invalid('invalid metadata interval');
+    if (item.confirmation.signature.timestamp !== item.confirmed_at)
+        invalid('metadata signature timestamp must equal confirmed_at');
+    if (item.aud.some(audience => !item.confirmation.audiences.includes(audience)))
+        invalid('confirmation does not cover metadata audiences');
+    if (item.use_limit !== null && !item.usage)
+        invalid('finite usage requires usage contract');
+    if (item.usage) {
+        if (item.aud.some(audience => !item.usage.audiences.includes(audience)))
+            invalid('usage does not cover metadata audiences');
+        if (item.use_limit !== null && !item.usage.limits.some(limit => limit.metric === 'count' && limit.limit === String(item.use_limit)))
+            invalid('count limit differs from use_limit');
+    }
+    if (now !== undefined) {
+        validateWindow(item.nbf, item.exp, now);
+        if (item.confirmed_at - now > 300)
+            invalid('confirmation is in the future');
+    }
+}
+const transitionFields = {
+    service_aid: aid, cid: string, original_hash: hash, transition_id: string, fence: positive,
+    candidate_hash: hash, from_usage: usageRef, to_usage: usageRef,
+};
+function transitionEpoch(value) {
+    if (value.to_usage.epoch - value.from_usage.epoch !== 1)
+        invalid('transition epoch must increment by one');
+}
+const account = value => shape(value, { grant_key: hash, original_hash: hash, limit_id: string, scope_key: string, metric: string, unit: string, used: decimal });
+function accounts(value) {
+    array(account, 1)(value);
+    const keys = ['grant_key', 'original_hash', 'limit_id', 'scope_key'];
+    for (let i = 1; i < value.length; i++) {
+        let comparison = 0;
+        for (const key of keys) {
+            comparison = compareCodePoints(value[i - 1][key], value[i][key]);
+            if (comparison)
+                break;
+        }
+        if (comparison >= 0)
+            invalid('accounts must be sorted by complete account key and unique');
+    }
+}
+function validateTransition(value) {
+    object(value);
+    const common = { ...transitionFields, expected: audienceSet(audienceRevision, 1), expected_absent: set(aid), expected_withdrawn: audienceSet(withdrawn), withdraw: set(aid), candidate: audienceSet(audienceRevision, 1), prepared_at: integer, as_of: integer, signature };
+    if (value.state === 'prepared')
+        shape(value, { ...common, state: literal('prepared') });
+    else if (value.state === 'committed') {
+        shape(value, { ...common, state: literal('committed'), terminal_at: integer, published: audienceSet(audienceRevision, 1), checkpoint_hashes: set(hash, 1), acceptance_hashes: set(hash, 1) });
+        if (digest(value.published) !== digest(value.candidate))
+            invalid('published revisions must equal candidates');
+    }
+    else {
+        shape(value, { ...common, state: literal('aborted'), terminal_at: integer, recovery: recovery => {
+                shape(recovery, { eligible: boolean, reason: literal('cancelled', 'credential_revoked') });
+                if (recovery.eligible !== (recovery.reason === 'cancelled'))
+                    invalid('inconsistent recovery eligibility');
+            } });
+    }
+    transitionEpoch(value);
+    eventTime(value);
+    if (value.prepared_at > value.as_of || value.state !== 'prepared' && value.terminal_at !== value.as_of)
+        invalid('inconsistent transition event time');
+    for (const item of [...value.expected, ...value.candidate, ...value.expected_withdrawn.map((entry) => ({ revision: entry.last_revision }))]) {
+        if (item.revision.cid !== value.cid || item.revision.original_hash !== value.original_hash)
+            invalid('transition revision differs from original');
+    }
+    const previous = new Set(value.expected.map((entry) => entry.audience));
+    const absent = value.expected_absent, restored = value.expected_withdrawn.map((entry) => entry.audience);
+    if (new Set([...previous, ...absent, ...restored]).size !== previous.size + absent.length + restored.length)
+        invalid('transition audience preconditions overlap');
+    if (value.withdraw.some((audience) => !previous.has(audience)))
+        invalid('withdraw must refer to current audience');
+    const expectedCandidate = [...previous, ...absent, ...restored].filter(audience => !value.withdraw.includes(audience)).sort(compareCodePoints);
+    if (digest(value.candidate.map((item) => item.audience)) !== digest(expectedCandidate))
+        invalid('candidate audiences do not match transition change');
+}
+function validateCrl(value, now) {
+    shape(value, {
+        service_aid: aid, scope: scope => shape(scope, { audiences: set(aid, 1) }),
+        query: query => shape(query, { params_hash: hash, nonce }), after_event_seq: integer, upper_event_seq: integer,
+        cursor: nullable(string), events: array(event => shape(event, {
+            event_seq: positive, cid: string, original_hash: hash, affected: audienceSet(revokedAudience, 1), revoked_at: integer,
+            actor: aid, authorization: policy, authority_evidence_hashes: set(hash), reason_code: string, 'reason?': string,
+        })), next_cursor: nullable(string), as_of: integer, valid_until: integer, signature,
+    });
+    proofTime(value, 300, now);
+    if (value.upper_event_seq < value.after_event_seq)
+        invalid('invalid CRL snapshot range');
+    let last = value.after_event_seq;
+    for (const event of value.events) {
+        if (event.event_seq <= last || event.event_seq > value.upper_event_seq)
+            invalid('event outside CRL snapshot sequence');
+        last = event.event_seq;
+        for (const affected of event.affected)
+            if (!value.scope.audiences.includes(affected.audience) || affected.revision.cid !== event.cid || affected.revision.original_hash !== event.original_hash)
+                invalid('CRL affected binding differs from event or scope');
+    }
+}
+export function validateSignedRecord(domain, value, now) {
+    checkDomain(domain);
+    canonicalJson(value);
+    object(value);
+    if (now !== undefined) {
+        integer(now);
+        const block = domain === 'registration-metadata' ? value.confirmation?.signature : value.signature;
+        if (typeof block?.timestamp === 'number' && block.timestamp - now > CLOCK_SKEW_SECONDS)
+            invalid('signature timestamp is in the future');
+    }
+    switch (domain) {
+        case 'semantic-credential':
+            validateSemanticCredential(value, now);
+            return;
+        case 'registration-metadata':
+            validateRegistrationMetadata(value, now);
+            return;
+        case 'registration-receipt':
+            shape(value, { ...revisionFields, audiences: set(aid, 1), service_aid: aid, registered_at: integer, 'usage?': usageRef, signature });
+            if (value.signature.timestamp !== value.registered_at)
+                invalid('receipt signature timestamp must equal registered_at');
+            if (now !== undefined && value.registered_at - now > 300)
+                invalid('receipt is in the future');
+            return;
+        case 'credential-status':
+            shape(value, { ...revisionFields, audience: aid, status: literal('active', 'revoked', 'expired'), state_seq: positive, 'usage?': usageRef, 'query?': query => shape(query, { request_hash: hash, nonce }), as_of: integer, valid_until: integer, signature });
+            proofTime(value, value.query ? 30 : 300, now);
+            return;
+        case 'usage-allocation':
+            shape(value, { allocation_id: string, grant_key: hash, parent_original_hash: hash, child_original_hash: hash, parent_epoch: positive, child_epoch: positive, parent_authority: aid, child_authority: aid, audiences: set(aid, 1), budgets: array(budget => shape(budget, { parent_limit_id: string, child_limit_id: string, metric: string, unit: string, amount: decimal }), 1), nbf: integer, exp: integer, signature });
+            if (value.exp <= value.nbf)
+                invalid('invalid allocation interval');
+            if (new Set(value.budgets.map((item) => `${item.parent_limit_id}\0${item.child_limit_id}`)).size !== value.budgets.length)
+                invalid('duplicate allocation budget');
+            if (now !== undefined)
+                validateWindow(value.nbf, value.exp, now);
+            return;
+        case 'allocation-status':
+            shape(value, { allocation_id: string, allocation_hash: hash, authority: aid, state: literal('active', 'draining', 'closed'), state_seq: positive, query: query => shape(query, { request_hash: hash, nonce }), as_of: integer, valid_until: integer, signature });
+            proofTime(value, 30, now);
+            return;
+        case 'semantic-crl':
+            validateCrl(value, now);
+            return;
+        case 'usage-transition':
+            validateTransition(value);
+            return;
+        case 'usage-checkpoint':
+            shape(value, { ...transitionFields, authority: aid, audiences: set(aid, 1), accounts, in_flight: literal(0), unknown: literal(0), reserved: literal('0'), closed_allocations: set(hash), as_of: integer, signature });
+            transitionEpoch(value);
+            eventTime(value);
+            return;
+        case 'usage-acceptance':
+            shape(value, { ...transitionFields, authority: aid, audiences: set(aid, 1), checkpoint_hashes: set(hash, 1), accounts, usage: validateUsageContract, as_of: integer, signature });
+            transitionEpoch(value);
+            eventTime(value);
+            if (value.usage.epoch !== value.to_usage.epoch || digest(value.usage) !== value.to_usage.hash)
+                invalid('accepted usage does not match target UsageRef');
+            if (value.audiences.some((audience) => !value.usage.audiences.includes(audience)))
+                invalid('acceptance audience outside new usage contract');
+            for (const audience of value.audiences)
+                if ((value.usage.ledger.scope === 'global' ? value.usage.ledger.authority : value.usage.ledger.authorities[audience]) !== value.authority)
+                    invalid('acceptance authority differs from new ledger authority');
+            if (value.usage.audiences.some((audience) => (value.usage.ledger.scope === 'global' ? value.usage.ledger.authority : value.usage.ledger.authorities[audience]) === value.authority && !value.audiences.includes(audience)))
+                invalid('acceptance must cover all audiences assigned to authority');
+            return;
+        case 'ledger-abort':
+            shape(value, { ...transitionFields, authority: aid, audiences: set(aid, 1), aborted_receipt_hash: hash, usage: usageRef, result: literal('resumed', 'frozen'), as_of: integer, signature });
+            transitionEpoch(value);
+            eventTime(value);
+            if (digest(value.usage) !== digest(value.from_usage))
+                invalid('abort ack must bind original UsageRef');
+    }
+}
+export function validateUsageRecord(domain, value, now) {
+    if (!['usage-allocation', 'allocation-status', 'usage-transition', 'usage-checkpoint', 'usage-acceptance', 'ledger-abort'].includes(domain))
+        invalid('expected usage signature domain');
+    validateSignedRecord(domain, value, now);
+}
+export function validateStatusProof(value, policy, context) {
+    validateSignedRecord('credential-status', value, context.now);
+    const proof = value;
+    object(policy);
+    if (!Number.isFinite(context.elapsedSeconds) || context.elapsedSeconds < 0)
+        invalid('invalid monotonic elapsed time');
+    let maximum;
+    if (policy.mode === 'online') {
+        shape(policy, { mode: literal('online') });
+        maximum = 30;
+        if (!context.query || !proof.query || digest(context.query) !== digest(proof.query))
+            throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'status query does not match request');
+    }
+    else {
+        shape(policy, { mode: literal('bounded'), max_staleness_seconds: positive });
+        maximum = policy.max_staleness_seconds;
+        if (maximum > 300 || proof.query !== undefined)
+            invalid('invalid bounded status policy or query');
+    }
+    if (proof.valid_until - proof.as_of > maximum || context.elapsedSeconds >= maximum)
+        invalid('status declaration or monotonic lifetime exceeded');
+}
+export const MANAGEMENT_CONTEXT_FIELDS = ['_auth', '_caller_id'];
+export function projectManagementParams(params) {
+    object(params);
+    canonicalJson(params);
+    return Object.fromEntries(Object.entries(params).filter(([key]) => key !== 'request_binding' && !MANAGEMENT_CONTEXT_FIELDS.includes(key)));
+}
+export function validateManagementBinding(value, now, context) {
+    shape(value, {
+        request_id: string, nonce, target: aid,
+        method: literal('credential.semantic.register', 'credential.semantic.revise', 'credential.semantic.get', 'credential.semantic.status', 'credential.semantic.revoke', 'credential.semantic.revocationList'),
+        params_hash: hash, iat: integer, exp: integer, credential_cid: item => { if (typeof item !== 'string')
+            invalid('invalid credential CID'); },
+    });
+    const item = value;
+    if ((item.credential_cid === '') !== (item.method === 'credential.semantic.revocationList'))
+        invalid('management CID does not match method');
+    if (item.exp <= item.iat || item.exp - item.iat > 300)
+        invalid('invalid management declaration interval');
+    if (now !== undefined) {
+        integer(now);
+        if (item.iat - now > 300 || now - item.exp > 300)
+            throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'management request is outside its validity window');
+    }
+    if (context) {
+        const params = context.params;
+        if (item.method !== context.method || item.target !== context.target || item.credential_cid !== params.credential_cid || item.request_id !== params.request_id || item.nonce !== params.nonce || item.params_hash !== digest(projectManagementParams(params)))
+            throw new SemanticProtocolError('SEMANTIC_BINDING_INVALID', 'management request binding does not match actual request');
+    }
+}
+export function buildManagementBinding(method, target, params, now = Math.trunc(Date.now() / 1000)) {
+    const binding = { request_id: params.request_id, nonce: params.nonce, credential_cid: params.credential_cid, target, method, params_hash: digest(projectManagementParams(params)), iat: now, exp: now + 300 };
+    validateManagementBinding(binding, now, { method, target, params });
+    return binding;
+}
+export function validateMetadataChange(value) {
+    shape(value, { expected: audienceSet(audienceRevision), metadata: array(item => { validateRegistrationMetadata(decodeSignedJson(item)); }),
+        'expected_absent?': set(aid), 'withdraw?': set(aid), 'expected_withdrawn?': audienceSet(withdrawn) });
+    const change = value;
+    const parsed = change.metadata.map(item => decodeSignedJson(item));
+    sorted(parsed, item => item.version);
+    const replaced = parsed.flatMap(item => item.aud);
+    if (new Set(replaced).size !== replaced.length || replaced.some(audience => change.withdraw?.includes(audience)))
+        invalid('metadata audience changes overlap');
+    if (change.metadata.length === 0 && !change.withdraw?.length)
+        invalid('metadata change must publish or withdraw audiences');
+    const existing = change.expected.map(item => item.audience), absent = change.expected_absent ?? [], restored = (change.expected_withdrawn ?? []).map(item => item.audience);
+    if (new Set([...existing, ...absent, ...restored]).size !== existing.length + absent.length + restored.length)
+        invalid('metadata change preconditions overlap');
+    const affected = [...replaced, ...change.withdraw ?? []].sort(compareCodePoints);
+    if (digest(affected) !== digest([...existing, ...absent, ...restored].sort(compareCodePoints)))
+        invalid('metadata change preconditions do not cover changes');
+    if (change.withdraw?.some(audience => !existing.includes(audience)))
+        invalid('withdraw must refer to an expected current audience');
+}
+export function validateLineageEntry(value) {
+    object(value);
+    object(value.credential);
+    if (value.credential.ver === SEMANTIC_VERSION)
+        shape(value, {
+            credential: validateSemanticCredential, metadata: validateRegistrationMetadata,
+            registration_receipt: item => validateSignedRecord('registration-receipt', item),
+            status: item => validateSignedRecord('credential-status', item),
+        });
+    else
+        shape(value, { credential: item => { jsonObject(item); if (item.ver !== 'aun-cap/1')
+                invalid('unsupported lineage credential version'); },
+            legacy: item => shape(item, { 'registration_receipt?': jsonObject, status_proof: jsonObject }) });
+}
+export function validateManagementParams(method, value, context = {}) {
+    canonicalJson(value);
+    object(value);
+    const base = {
+        request_id: string, nonce, credential_cid: (item) => { if (typeof item !== 'string')
+            invalid('invalid CID'); },
+        request_binding: (binding) => validateManagementBinding(binding, context.now),
+        authority: (authority) => shape(authority, { policy, evidence: array(validateEvidenceRef) }),
+    };
+    switch (method) {
+        case 'credential.semantic.register':
+            shape(value, { ...base, original: item => { validateSemanticCredential(decodeSignedJson(item)); }, metadata: array(item => { validateRegistrationMetadata(decodeSignedJson(item)); }, 1), lineage_evidence: array(validateLineageEntry) });
+            if (decodeSignedJson(value.original).cid !== value.credential_cid)
+                invalid('original CID differs from management CID');
+            sorted(value.metadata.map((item) => decodeSignedJson(item)), item => item.version);
+            break;
+        case 'credential.semantic.revise':
+            if (value.kind === 'metadata')
+                shape(value, { ...base, kind: literal('metadata'), change: validateMetadataChange });
+            else if (value.kind === 'usage_prepare') {
+                shape(value, { ...base, kind: literal('usage_prepare'), transition_id: string, from_usage: usageRef, to_usage: usageRef,
+                    change: validateMetadataChange, previous_abort_acks: array(item => validateSignedRecord('ledger-abort', decodeSignedJson(item))) });
+                transitionEpoch(value);
+            }
+            else if (value.kind === 'usage_commit') {
+                shape(value, { ...base, kind: literal('usage_commit'), transition_id: string, fence: positive,
+                    checkpoints: array(item => validateSignedRecord('usage-checkpoint', decodeSignedJson(item)), 1),
+                    allocation_closures: array(item => {
+                        const closure = decodeSignedJson(item);
+                        validateSignedRecord('allocation-status', closure);
+                        if (closure.state !== 'closed')
+                            invalid('allocation closure must be closed');
+                    }), acceptances: array(item => validateSignedRecord('usage-acceptance', decodeSignedJson(item)), 1) });
+                sorted(value.allocation_closures.map((item) => digest(decodeSignedJson(item))));
+            }
+            else
+                shape(value, { ...base, kind: literal('usage_abort'), transition_id: string, fence: positive, from_usage: usageRef });
+            break;
+        case 'credential.semantic.get':
+            shape(value, { ...base, audience: aid, 'metadata_version?': string, 'transition_id?': string });
+            if (value.metadata_version !== undefined && value.transition_id !== undefined)
+                invalid('get selectors are mutually exclusive');
+            break;
+        case 'credential.semantic.status':
+            if (value.policy?.mode === 'online')
+                shape(value, { ...base, audience: aid, expected_revision: revision, policy: item => shape(item, { mode: literal('online') }), query: item => shape(item, { request_hash: hash, nonce }) });
+            else
+                shape(value, { ...base, audience: aid, expected_revision: revision, policy: item => shape(item, { mode: literal('bounded'), max_staleness_seconds: item => { positive(item); if (item > 300)
+                            invalid('bounded staleness exceeds 300'); } }) });
+            if (value.expected_revision.cid !== value.credential_cid)
+                invalid('status revision CID differs from management CID');
+            break;
+        case 'credential.semantic.revoke':
+            shape(value, { ...base, reason_code: string, 'reason?': string });
+            break;
+        case 'credential.semantic.revocationList':
+            shape(value, { ...base, scope: item => shape(item, { audiences: set(aid, 1) }), after_event_seq: integer, cursor: nullable(string), limit: item => { positive(item); if (item > 1000)
+                    invalid('CRL page limit exceeds 1000'); } });
+            break;
+        default: invalid('unsupported semantic management method');
+    }
+    validateManagementBinding(value.request_binding, context.now, { method, target: context.target ?? value.request_binding.target, params: value });
+}
+function certificate(material) {
+    if (typeof material === 'string' && !material.startsWith('-----BEGIN CERTIFICATE-----'))
+        return new X509Certificate(decodeBase64(material));
+    return new X509Certificate(material);
+}
+function expectedSigner(domain, value, expected) {
+    const bound = domain === 'registration-metadata' ? value.confirmation.authority
+        : domain === 'usage-allocation' ? value.parent_authority
+            : ['registration-receipt', 'semantic-crl', 'usage-transition'].includes(domain) ? value.service_aid
+                : ['allocation-status', 'usage-checkpoint', 'usage-acceptance', 'ledger-abort'].includes(domain) ? value.authority : undefined;
+    if (bound && expected && bound !== expected)
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'expected signer differs from signed authority');
+    const signer = bound ?? expected;
+    if (!signer)
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'trusted signer identity is required');
+    aid(signer);
+    return signer;
+}
+export async function verifyRecord(domain, value, context) {
+    const now = context.now ?? Math.trunc(Date.now() / 1000);
+    integer(now);
+    validateSignedRecord(domain, value, now);
+    const item = value, block = signatureOf(domain, item);
+    const expected = expectedSigner(domain, item, context.expectedAid);
+    const resolved = await context.resolveCertificate(block.cert_fingerprint, expected, block.timestamp);
+    if (resolved === undefined || resolved === null)
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'signing certificate is unavailable');
+    try {
+        const wrapper = typeof resolved === 'object' && !(resolved instanceof Uint8Array) ? resolved : { certificatePem: resolved };
+        const cert = certificate(wrapper.certificatePem);
+        if (bytesDigest(cert.raw) !== block.cert_fingerprint || block.public_key_fingerprint && publicKeyFingerprint(cert.toString()) !== block.public_key_fingerprint)
+            throw new Error('certificate fingerprint differs from signature');
+        if (certCommonName(cert.toString()) !== expected || cert.publicKey.asymmetricKeyType !== 'ec' || cert.publicKey.asymmetricKeyDetails?.namedCurve !== 'prime256v1')
+            throw new Error('certificate identity or curve mismatch');
+        const start = Date.parse(cert.validFrom) / 1000, end = Date.parse(cert.validTo) / 1000;
+        if (block.timestamp < start || block.timestamp > end)
+            throw new Error('signature timestamp is outside original certificate validity');
+        if (context.requireCurrentValidity ?? true)
+            validateWindow(start, end, now);
+        if (typeof context.verifyCertificateTrust !== 'function')
+            throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'explicit certificate trust verifier is required');
+        await context.verifyCertificateTrust(wrapper.certificatePem, { expectedAID: expected, signedAt: block.timestamp, now });
+        if (!verifySignature('sha256', signingPayload(domain, item), cert.publicKey, decodeBase64(block.signature)))
+            throw new Error('signature verification failed');
+    }
+    catch (error) {
+        if (error instanceof SemanticProtocolError)
+            throw error;
+        throw new SemanticProtocolError('SEMANTIC_SIGNATURE_INVALID', error instanceof Error ? error.message : String(error));
+    }
+    const required = ['authorization_policy', 'historical_revocation', 'revision_bindings', 'business_acceptance'];
+    if (domain === 'semantic-credential') {
+        required.push('issuer_authority');
+        if (item.iss && item.iss !== expected)
+            required.push('representation');
+    }
+    return { original_hash: digest(item), signatures_verified: true, identities_bound: true, revisions_bound: false,
+        checked: ['format', 'signature_domain', 'signature', 'certificate_fingerprint', 'signer_identity', 'certificate_time', 'trust_chain'],
+        required };
+}
+export async function signRecord(domain, value, signer, options = {}) {
+    checkDomain(domain);
+    const item = parseJsonStrict(canonicalJson(value));
+    object(item);
+    const timestamp = options.timestamp ?? (domain === 'registration-metadata' ? item.confirmed_at : domain === 'registration-receipt' ? item.registered_at : item.as_of ?? Math.trunc(Date.now() / 1000));
+    integer(timestamp);
+    const owner = domain === 'registration-metadata' ? item.confirmation : item;
+    object(owner);
+    if (Object.hasOwn(owner, 'signature'))
+        invalid('signing requires an unsigned object');
+    owner.signature = { profile: SIGNATURE_PROFILE, cert_fingerprint: signer.certFingerprint, timestamp };
+    expectedSigner(domain, item, signer.aid);
+    const result = await signer.sign(Buffer.from(signingPayload(domain, item)));
+    if (!result.ok)
+        throw new SemanticProtocolError('SEMANTIC_SIGNATURE_INVALID', 'signing failed');
+    owner.signature.signature = result.data.signature;
+    validateSignedRecord(domain, item);
+    const cert = certificate(signer.certPem);
+    if (bytesDigest(cert.raw) !== signer.certFingerprint || certCommonName(cert.toString()) !== signer.aid || cert.publicKey.asymmetricKeyDetails?.namedCurve !== 'prime256v1' || timestamp < Date.parse(cert.validFrom) / 1000 || timestamp > Date.parse(cert.validTo) / 1000)
+        throw new SemanticProtocolError('SEMANTIC_IDENTITY_INVALID', 'signing certificate does not match identity or original validity');
+    if (!verifySignature('sha256', signingPayload(domain, item), cert.publicKey, decodeBase64(owner.signature.signature)))
+        throw new SemanticProtocolError('SEMANTIC_SIGNATURE_INVALID', 'generated signature does not verify');
+    return encodeSignedJson(item);
+}
+//# sourceMappingURL=semantic-protocol.js.map