@bcts/envelope 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/index.cjs

@@ -25,60 +25,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let _bcts_crypto = require("@bcts/crypto");
+let _bcts_components = require("@bcts/components");
 let _bcts_dcbor = require("@bcts/dcbor");
 let _bcts_known_values = require("@bcts/known-values");
-let _bcts_components = require("@bcts/components");
 let pako = require("pako");
 pako = __toESM(pako);
+let _bcts_crypto = require("@bcts/crypto");
 let _bcts_rand = require("@bcts/rand");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let _bcts_tags = require("@bcts/tags");
 
 //#region src/base/digest.ts
-var Digest = class Digest {
-	#data;
-	constructor(data) {
-		if (data.length !== 32) throw new Error(`Digest must be exactly 32 bytes, got ${data.length} bytes`);
-		this.#data = data;
-	}
-	data() {
-		return this.#data;
-	}
-	static fromImage(image) {
-		return new Digest((0, _bcts_crypto.sha256)(image));
-	}
-	static fromDigests(digests) {
-		const totalLength = digests.length * 32;
-		const combined = new Uint8Array(totalLength);
-		let offset = 0;
-		for (const digest of digests) {
-			combined.set(digest.data(), offset);
-			offset += 32;
-		}
-		return Digest.fromImage(combined);
-	}
-	hex() {
-		return Array.from(this.#data).map((b) => b.toString(16).padStart(2, "0")).join("");
-	}
-	short() {
-		return this.hex().substring(0, 7);
-	}
-	static fromHex(hex) {
-		if (hex.length !== 64) throw new Error(`Hex string must be exactly 64 characters, got ${hex.length}`);
-		const data = new Uint8Array(32);
-		for (let i = 0; i < 32; i++) data[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-		return new Digest(data);
-	}
-	equals(other) {
-		if (this.#data.length !== other.#data.length) return false;
-		for (let i = 0; i < this.#data.length; i++) if (this.#data[i] !== other.#data[i]) return false;
-		return true;
-	}
-	toString() {
-		return this.short();
-	}
-	clone() {
-		return new Digest(new Uint8Array(this.#data));
-	}
+_bcts_components.Digest.prototype.short = function() {
+	return this.hex().slice(0, 7);
 };
 
 //#endregion
@@ -113,6 +72,7 @@ let ErrorCode = /* @__PURE__ */ function(ErrorCode$1) {
 	ErrorCode$1["SSKR"] = "SSKR";
 	ErrorCode$1["INVALID_TYPE"] = "INVALID_TYPE";
 	ErrorCode$1["AMBIGUOUS_TYPE"] = "AMBIGUOUS_TYPE";
+	ErrorCode$1["SUBJECT_NOT_UNIT"] = "SUBJECT_NOT_UNIT";
 	ErrorCode$1["UNEXPECTED_RESPONSE_ID"] = "UNEXPECTED_RESPONSE_ID";
 	ErrorCode$1["INVALID_RESPONSE"] = "INVALID_RESPONSE";
 	ErrorCode$1["CBOR"] = "CBOR";
@@ -159,8 +119,8 @@ var EnvelopeError = class EnvelopeError extends Error {
 	static invalidAssertion() {
 		return new EnvelopeError(ErrorCode.INVALID_ASSERTION, "assertion must be a map with exactly one element");
 	}
-	static invalidAttachment() {
-		return new EnvelopeError(ErrorCode.INVALID_ATTACHMENT, "invalid attachment");
+	static invalidAttachment(message) {
+		return new EnvelopeError(ErrorCode.INVALID_ATTACHMENT, message !== void 0 ? `invalid attachment: ${message}` : "invalid attachment");
 	}
 	static nonexistentAttachment() {
 		return new EnvelopeError(ErrorCode.NONEXISTENT_ATTACHMENT, "nonexistent attachment");
@@ -216,6 +176,9 @@ var EnvelopeError = class EnvelopeError extends Error {
 	static ambiguousType() {
 		return new EnvelopeError(ErrorCode.AMBIGUOUS_TYPE, "ambiguous type");
 	}
+	static subjectNotUnit() {
+		return new EnvelopeError(ErrorCode.SUBJECT_NOT_UNIT, "subject is not the unit value");
+	}
 	static unexpectedResponseId() {
 		return new EnvelopeError(ErrorCode.UNEXPECTED_RESPONSE_ID, "unexpected response ID");
 	}
@@ -245,7 +208,7 @@ var Assertion = class Assertion {
 	constructor(predicate, object) {
 		this.#predicate = predicate instanceof Envelope ? predicate : Envelope.new(predicate);
 		this.#object = object instanceof Envelope ? object : Envelope.new(object);
-		this.#digest = Digest.fromDigests([this.#predicate.digest(), this.#object.digest()]);
+		this.#digest = _bcts_components.Digest.fromDigests([this.#predicate.digest(), this.#object.digest()]);
 	}
 	predicate() {
 		return this.#predicate;
@@ -348,45 +311,33 @@ function registerCompressExtension() {
 		return this.case().type === "compressed";
 	};
 }
-registerCompressExtension();
 
 //#endregion
 //#region src/extension/encrypt.ts
-function createSecureRng$1() {
-	return new _bcts_rand.SecureRandomNumberGenerator();
+/**
+* Encrypts plaintext with a symmetric key using the given digest as AAD.
+* This is an envelope-specific helper function that returns an envelope EncryptedMessage.
+*/
+function encryptWithDigest(key, plaintext, digest) {
+	const nonce = (0, _bcts_rand.rngRandomData)(new _bcts_rand.SecureRandomNumberGenerator(), _bcts_crypto.SYMMETRIC_NONCE_SIZE);
+	const aad = digest.data();
+	const [ciphertext, authTag] = (0, _bcts_crypto.aeadChaCha20Poly1305EncryptWithAad)(plaintext, key.data(), nonce, aad);
+	return new EncryptedMessage(ciphertext, nonce, authTag, digest);
 }
-var SymmetricKey = class SymmetricKey {
-	#key;
-	constructor(key) {
-		if (key.length !== _bcts_crypto.SYMMETRIC_KEY_SIZE) throw new Error(`Symmetric key must be ${_bcts_crypto.SYMMETRIC_KEY_SIZE} bytes`);
-		this.#key = key;
-	}
-	static generate() {
-		return new SymmetricKey((0, _bcts_rand.rngRandomData)(createSecureRng$1(), _bcts_crypto.SYMMETRIC_KEY_SIZE));
-	}
-	static from(key) {
-		return new SymmetricKey(key);
-	}
-	data() {
-		return this.#key;
-	}
-	encrypt(plaintext, digest) {
-		const nonce = (0, _bcts_rand.rngRandomData)(createSecureRng$1(), _bcts_crypto.SYMMETRIC_NONCE_SIZE);
-		const aad = digest.data();
-		const [ciphertext, authTag] = (0, _bcts_crypto.aeadChaCha20Poly1305EncryptWithAad)(plaintext, this.#key, nonce, aad);
-		return new EncryptedMessage(ciphertext, nonce, authTag, digest);
-	}
-	decrypt(message) {
-		const digest = message.aadDigest();
-		if (digest === void 0) throw EnvelopeError.general("Missing digest in encrypted message");
-		const aad = digest.data();
-		try {
-			return (0, _bcts_crypto.aeadChaCha20Poly1305DecryptWithAad)(message.ciphertext(), this.#key, message.nonce(), aad, message.authTag());
-		} catch (_error) {
-			throw EnvelopeError.general("Decryption failed: invalid key or corrupted data");
-		}
+/**
+* Decrypts an envelope EncryptedMessage with a symmetric key.
+* This is an envelope-specific helper function.
+*/
+function decryptWithDigest(key, message) {
+	const digest = message.aadDigest();
+	if (digest === void 0) throw EnvelopeError.general("Missing digest in encrypted message");
+	const aad = digest.data();
+	try {
+		return (0, _bcts_crypto.aeadChaCha20Poly1305DecryptWithAad)(message.ciphertext(), key.data(), message.nonce(), aad, message.authTag());
+	} catch (_error) {
+		throw EnvelopeError.general("Decryption failed: invalid key or corrupted data");
 	}
-};
+}
 var EncryptedMessage = class {
 	#ciphertext;
 	#nonce;
@@ -424,18 +375,14 @@ function registerEncryptExtension() {
 		if (c.type === "elided") throw EnvelopeError.general("Cannot encrypt elided envelope");
 		if (c.type === "node") {
 			if (c.subject.isEncrypted()) throw EnvelopeError.general("Subject is already encrypted");
-			const encodedCbor$1 = (0, _bcts_dcbor.cborData)(c.subject.taggedCbor());
-			const subjectDigest = c.subject.digest();
-			const encryptedMessage$1 = key.encrypt(encodedCbor$1, subjectDigest);
+			const encryptedMessage$1 = encryptWithDigest(key, (0, _bcts_dcbor.cborData)(c.subject.taggedCbor()), c.subject.digest());
 			const encryptedSubject = Envelope.fromCase({
 				type: "encrypted",
 				message: encryptedMessage$1
 			});
 			return Envelope.newWithAssertions(encryptedSubject, c.assertions);
 		}
-		const encodedCbor = (0, _bcts_dcbor.cborData)(this.taggedCbor());
-		const digest = this.digest();
-		const encryptedMessage = key.encrypt(encodedCbor, digest);
+		const encryptedMessage = encryptWithDigest(key, (0, _bcts_dcbor.cborData)(this.taggedCbor()), this.digest());
 		return Envelope.fromCase({
 			type: "encrypted",
 			message: encryptedMessage
@@ -447,7 +394,7 @@ function registerEncryptExtension() {
 		const message = subjectCase.message;
 		const subjectDigest = message.aadDigest();
 		if (subjectDigest === void 0) throw EnvelopeError.general("Missing digest in encrypted message");
-		const cbor$1 = (0, _bcts_dcbor.decodeCbor)(key.decrypt(message));
+		const cbor$1 = (0, _bcts_dcbor.decodeCbor)(decryptWithDigest(key, message));
 		const resultSubject = Envelope.fromTaggedCbor(cbor$1);
 		if (!resultSubject.digest().equals(subjectDigest)) throw EnvelopeError.general("Invalid digest after decryption");
 		const c = this.case();
@@ -468,7 +415,6 @@ function registerEncryptExtension() {
 		return this.case().type === "encrypted";
 	};
 }
-registerEncryptExtension();
 
 //#endregion
 //#region src/base/envelope.ts
@@ -486,6 +432,7 @@ var Envelope = class Envelope {
 	}
 	static new(subject) {
 		if (subject instanceof Envelope) return subject;
+		if (subject instanceof _bcts_known_values.KnownValue) return Envelope.newWithKnownValue(subject);
 		return Envelope.newLeaf(subject);
 	}
 	static newOrNull(subject) {
@@ -519,7 +466,7 @@ var Envelope = class Envelope {
 			type: "node",
 			subject,
 			assertions: sortedAssertions,
-			digest: Digest.fromDigests(digests)
+			digest: _bcts_components.Digest.fromDigests(digests)
 		});
 	}
 	static newWithAssertions(subject, assertions) {
@@ -537,7 +484,7 @@ var Envelope = class Envelope {
 		return new Envelope({
 			type: "knownValue",
 			value: knownValue,
-			digest: Digest.fromImage(knownValue.toCborData())
+			digest: _bcts_components.Digest.fromImage(knownValue.toCborData())
 		});
 	}
 	static newWithEncrypted(encryptedMessage) {
@@ -564,14 +511,14 @@ var Envelope = class Envelope {
 		return new Envelope({
 			type: "leaf",
 			cbor: cbor$1,
-			digest: Digest.fromImage(cborBytes)
+			digest: _bcts_components.Digest.fromImage(cborBytes)
 		});
 	}
 	static newWrapped(envelope) {
 		return new Envelope({
 			type: "wrapped",
 			envelope,
-			digest: Digest.fromDigests([envelope.digest()])
+			digest: _bcts_components.Digest.fromDigests([envelope.digest()])
 		});
 	}
 	digest() {
@@ -633,7 +580,7 @@ var Envelope = class Envelope {
 			case "wrapped": return c.envelope.taggedCbor();
 			case "assertion": return c.assertion.toCbor();
 			case "elided": return Envelope.valueToCbor(c.digest.data());
-			case "knownValue": throw new Error("Known value encoding not yet implemented");
+			case "knownValue": return c.value.untaggedCbor();
 			case "encrypted": {
 				const message = c.message;
 				const digest = message.aadDigest();
@@ -678,7 +625,7 @@ var Envelope = class Envelope {
 					if (compressedData === void 0) throw EnvelopeError.cbor("compressed data must be byte string");
 					const digestBytes = arr.length === 2 ? (0, _bcts_dcbor.asByteString)(arr.get(1)) : void 0;
 					if (arr.length === 2 && digestBytes === void 0) throw EnvelopeError.cbor("digest must be byte string");
-					const compressed = new Compressed(compressedData, digestBytes !== void 0 ? new Digest(digestBytes) : void 0);
+					const compressed = new Compressed(compressedData, digestBytes !== void 0 ? _bcts_components.Digest.fromData(digestBytes) : void 0);
 					return Envelope.fromCase({
 						type: "compressed",
 						value: compressed
@@ -693,7 +640,7 @@ var Envelope = class Envelope {
 					if (ciphertext === void 0 || nonce === void 0 || authTag === void 0) throw EnvelopeError.cbor("ciphertext, nonce, and auth must be byte strings");
 					const digestBytes = arr.length === 4 ? (0, _bcts_dcbor.asByteString)(arr.get(3)) : void 0;
 					if (arr.length === 4 && digestBytes === void 0) throw EnvelopeError.cbor("aad digest must be byte string");
-					const message = new EncryptedMessage(ciphertext, nonce, authTag, digestBytes !== void 0 ? new Digest(digestBytes) : void 0);
+					const message = new EncryptedMessage(ciphertext, nonce, authTag, digestBytes !== void 0 ? _bcts_components.Digest.fromData(digestBytes) : void 0);
 					return Envelope.fromCase({
 						type: "encrypted",
 						message
@@ -705,7 +652,7 @@ var Envelope = class Envelope {
 		const bytes = (0, _bcts_dcbor.asByteString)(cbor$1);
 		if (bytes !== void 0) {
 			if (bytes.length !== 32) throw EnvelopeError.cbor("elided digest must be 32 bytes");
-			return Envelope.newElided(new Digest(bytes));
+			return Envelope.newElided(_bcts_components.Digest.fromData(bytes));
 		}
 		const array = (0, _bcts_dcbor.asCborArray)(cbor$1);
 		if (array !== void 0) {
@@ -902,6 +849,54 @@ Envelope.prototype.extractBytes = function() {
 Envelope.prototype.extractNull = function() {
 	return extractNull(this);
 };
+function extractSubject(envelope, decoder) {
+	const cbor$1 = envelope.subject().tryLeaf();
+	try {
+		return decoder(cbor$1);
+	} catch (error) {
+		throw EnvelopeError.cbor("failed to decode subject", error instanceof Error ? error : void 0);
+	}
+}
+Envelope.prototype.extractSubject = function(decoder) {
+	return extractSubject(this, decoder);
+};
+function tryObjectForPredicate(envelope, predicate, decoder) {
+	return extractSubject(envelope.objectForPredicate(predicate), decoder);
+}
+Envelope.prototype.tryObjectForPredicate = function(predicate, decoder) {
+	return tryObjectForPredicate(this, predicate, decoder);
+};
+function tryOptionalObjectForPredicate(envelope, predicate, decoder) {
+	const obj = envelope.optionalObjectForPredicate(predicate);
+	if (obj === void 0) return;
+	return extractSubject(obj, decoder);
+}
+Envelope.prototype.tryOptionalObjectForPredicate = function(predicate, decoder) {
+	return tryOptionalObjectForPredicate(this, predicate, decoder);
+};
+function extractObjectForPredicateWithDefault(envelope, predicate, decoder, defaultValue) {
+	return tryOptionalObjectForPredicate(envelope, predicate, decoder) ?? defaultValue;
+}
+Envelope.prototype.extractObjectForPredicateWithDefault = function(predicate, decoder, defaultValue) {
+	return extractObjectForPredicateWithDefault(this, predicate, decoder, defaultValue);
+};
+function extractObjectsForPredicate(envelope, predicate, decoder) {
+	return envelope.objectsForPredicate(predicate).map((obj) => extractSubject(obj, decoder));
+}
+Envelope.prototype.extractObjectsForPredicate = function(predicate, decoder) {
+	return extractObjectsForPredicate(this, predicate, decoder);
+};
+function tryObjectsForPredicate(envelope, predicate, decoder) {
+	try {
+		return extractObjectsForPredicate(envelope, predicate, decoder);
+	} catch (error) {
+		if (error instanceof EnvelopeError && error.code === ErrorCode.NONEXISTENT_PREDICATE) return [];
+		throw error;
+	}
+}
+Envelope.prototype.tryObjectsForPredicate = function(predicate, decoder) {
+	return tryObjectsForPredicate(this, predicate, decoder);
+};
 
 //#endregion
 //#region src/base/elide.ts
@@ -942,6 +937,9 @@ function elideSetWithAction(envelope, target, isRevealing, action) {
 Envelope.prototype.elideRemovingSetWithAction = function(target, action) {
 	return elideSetWithAction(this, target, false, action);
 };
+Envelope.prototype.elideSetWithAction = function(target, action) {
+	return elideSetWithAction(this, target, true, action);
+};
 Envelope.prototype.elideRemovingSet = function(target) {
 	return elideSetWithAction(this, target, false, elideAction());
 };
@@ -1148,6 +1146,39 @@ function walkTree(envelope, level, incomingEdge, state, visit) {
 	}
 	return currentState;
 }
+Envelope.prototype.digests = function(levelLimit) {
+	const result = /* @__PURE__ */ new Set();
+	const visitor = (envelope, level, _incomingEdge, _state) => {
+		if (level < levelLimit) {
+			result.add(envelope.digest());
+			result.add(envelope.subject().digest());
+		}
+		return [void 0, false];
+	};
+	this.walk(false, void 0, visitor);
+	return result;
+};
+Envelope.prototype.deepDigests = function() {
+	return this.digests(Number.MAX_SAFE_INTEGER);
+};
+Envelope.prototype.shallowDigests = function() {
+	return this.digests(2);
+};
+Envelope.prototype.object = function() {
+	return this.tryObject();
+};
+Envelope.prototype.predicate = function() {
+	return this.tryPredicate();
+};
+Envelope.prototype.toCbor = function() {
+	return this.taggedCbor();
+};
+Envelope.prototype.expectLeaf = function() {
+	return this.tryLeaf();
+};
+Envelope.prototype.checkTypeValue = function(type) {
+	this.checkType(type);
+};
 
 //#endregion
 //#region src/base/assertions.ts
@@ -1287,6 +1318,30 @@ Envelope.prototype.asLeaf = function() {
 	const c = this.case();
 	if (c.type === "leaf") return c.cbor;
 };
+Envelope.unit = function() {
+	return Envelope.new(_bcts_known_values.UNIT);
+};
+Envelope.prototype.asKnownValue = function() {
+	const c = this.case();
+	if (c.type === "knownValue") return c.value;
+};
+Envelope.prototype.tryKnownValue = function() {
+	const kv = this.asKnownValue();
+	if (kv === void 0) throw EnvelopeError.notKnownValue();
+	return kv;
+};
+Envelope.prototype.isKnownValue = function() {
+	return this.case().type === "knownValue";
+};
+Envelope.prototype.isSubjectUnit = function() {
+	const kv = this.subject().asKnownValue();
+	if (kv === void 0) return false;
+	return kv.equals(_bcts_known_values.UNIT);
+};
+Envelope.prototype.checkSubjectUnit = function() {
+	if (this.isSubjectUnit()) return this;
+	throw EnvelopeError.subjectNotUnit();
+};
 
 //#endregion
 //#region src/base/queries.ts
@@ -1402,6 +1457,38 @@ Envelope.prototype.elementsCount = function() {
 	}
 	return count;
 };
+Envelope.prototype.isSubjectEncrypted = function() {
+	const c = this.case();
+	if (c.type === "encrypted") return true;
+	if (c.type === "node") return c.subject.isSubjectEncrypted();
+	return false;
+};
+Envelope.prototype.isSubjectCompressed = function() {
+	const c = this.case();
+	if (c.type === "compressed") return true;
+	if (c.type === "node") return c.subject.isSubjectCompressed();
+	return false;
+};
+Envelope.prototype.isSubjectElided = function() {
+	const c = this.case();
+	if (c.type === "elided") return true;
+	if (c.type === "node") return c.subject.isSubjectElided();
+	return false;
+};
+Envelope.prototype.setPosition = function(position) {
+	const positionAssertions = this.assertionsWithPredicate(_bcts_known_values.POSITION);
+	if (positionAssertions.length > 1) throw EnvelopeError.invalidFormat();
+	return (positionAssertions.length === 1 ? this.removeAssertion(positionAssertions[0]) : this).addAssertion(_bcts_known_values.POSITION, position);
+};
+Envelope.prototype.position = function() {
+	return this.objectForPredicate(_bcts_known_values.POSITION).extractNumber();
+};
+Envelope.prototype.removePosition = function() {
+	const positionAssertions = this.assertionsWithPredicate(_bcts_known_values.POSITION);
+	if (positionAssertions.length > 1) throw EnvelopeError.invalidFormat();
+	if (positionAssertions.length === 1) return this.removeAssertion(positionAssertions[0]);
+	return this;
+};
 
 //#endregion
 //#region src/base/wrap.ts
@@ -1417,15 +1504,35 @@ Envelope.prototype.unwrap = function() {
 	return this.tryUnwrap();
 };
 
+//#endregion
+//#region src/base/ur.ts
+Envelope.prototype.urString = function() {
+	return _bcts_uniform_resources.UR.new("envelope", this.untaggedCbor()).string();
+};
+Envelope.prototype.ur = function() {
+	return _bcts_uniform_resources.UR.new("envelope", this.untaggedCbor());
+};
+Envelope.prototype.taggedCborData = function() {
+	return this.cborBytes();
+};
+Envelope.fromUrString = function(urString) {
+	const ur = _bcts_uniform_resources.UR.fromURString(urString);
+	return Envelope.fromUR(ur);
+};
+Envelope.fromURString = Envelope.fromUrString;
+Envelope.fromUR = function(ur) {
+	ur.checkType("envelope");
+	return Envelope.fromUntaggedCbor(ur.cbor());
+};
+
 //#endregion
 //#region src/extension/types.ts
-const IS_A = "isA";
 if (Envelope?.prototype) {
 	Envelope.prototype.addType = function(object) {
-		return this.addAssertion(IS_A, object);
+		return this.addAssertion(_bcts_known_values.IS_A, object);
 	};
 	Envelope.prototype.types = function() {
-		return this.objectsForPredicate(IS_A);
+		return this.objectsForPredicate(_bcts_known_values.IS_A);
 	};
 	Envelope.prototype.getType = function() {
 		const t = this.types();
@@ -1470,6 +1577,7 @@ if (Envelope?.prototype) {
 		const saltBytes = generateRandomBytes(count);
 		return this.addAssertion(SALT, saltBytes);
 	};
+	Envelope.prototype.addSaltWithLen = Envelope.prototype.addSaltWithLength;
 	Envelope.prototype.addSaltBytes = function(saltBytes) {
 		if (saltBytes.length < MIN_SALT_SIZE) throw EnvelopeError.general(`Salt must be at least ${MIN_SALT_SIZE} bytes, got ${saltBytes.length}`);
 		return this.addAssertion(SALT, saltBytes);
@@ -1481,6 +1589,32 @@ if (Envelope?.prototype) {
 		const saltBytes = generateRandomBytes((0, _bcts_rand.rngNextInClosedRangeI32)(rng, min, max), rng);
 		return this.addAssertion(SALT, saltBytes);
 	};
+	Envelope.prototype.addAssertionSalted = function(predicate, object, salted) {
+		const assertion = Envelope.newAssertion(predicate, object);
+		if (!salted) return this.addAssertionEnvelope(assertion);
+		const saltedAssertion = assertion.addSalt();
+		const c = this.case();
+		if (c.type === "node") return Envelope.newWithUncheckedAssertions(c.subject, [...c.assertions, saltedAssertion]);
+		return Envelope.newWithUncheckedAssertions(this, [saltedAssertion]);
+	};
+	Envelope.prototype.addAssertionEnvelopeSalted = function(assertionEnvelope, salted) {
+		if (!salted) return this.addAssertionEnvelope(assertionEnvelope);
+		const saltedAssertion = assertionEnvelope.addSalt();
+		const c = this.case();
+		if (c.type === "node") return Envelope.newWithUncheckedAssertions(c.subject, [...c.assertions, saltedAssertion]);
+		return Envelope.newWithUncheckedAssertions(this, [saltedAssertion]);
+	};
+	Envelope.prototype.addOptionalAssertionEnvelopeSalted = function(assertionEnvelope, salted) {
+		if (assertionEnvelope === void 0) return this;
+		if (!salted) return this.addOptionalAssertionEnvelope(assertionEnvelope);
+		const saltedAssertion = assertionEnvelope.addSalt();
+		const c = this.case();
+		if (c.type === "node") {
+			if (c.assertions.some((a) => a.digest().equals(saltedAssertion.digest()))) return this;
+			return Envelope.newWithUncheckedAssertions(c.subject, [...c.assertions, saltedAssertion]);
+		}
+		return Envelope.newWithUncheckedAssertions(this.subject(), [saltedAssertion]);
+	};
 }
 
 //#endregion
@@ -1513,123 +1647,21 @@ const VERIFIED_BY = "verifiedBy";
 */
 const NOTE = "note";
 /**
-* Represents a cryptographic signature.
-*/
-var Signature = class Signature {
-	#data;
-	constructor(data) {
-		this.#data = data;
-	}
-	/**
-	* Returns the raw signature bytes.
-	*/
-	data() {
-		return this.#data;
-	}
-	/**
-	* Returns the hex-encoded signature.
-	*/
-	hex() {
-		return Array.from(this.#data).map((b) => b.toString(16).padStart(2, "0")).join("");
-	}
-	/**
-	* Creates a Signature from hex string.
-	*/
-	static fromHex(hex) {
-		const bytes = new Uint8Array(hex.length / 2);
-		for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-		return new Signature(bytes);
-	}
-};
-/**
-* ECDSA signing key using secp256k1 curve.
-* Uses @bcts/crypto functions.
-*/
-var SigningPrivateKey = class SigningPrivateKey {
-	#privateKey;
-	constructor(privateKey) {
-		if (privateKey.length !== _bcts_crypto.ECDSA_PRIVATE_KEY_SIZE) throw new Error(`Private key must be ${_bcts_crypto.ECDSA_PRIVATE_KEY_SIZE} bytes`);
-		this.#privateKey = privateKey;
-	}
-	/**
-	* Generates a new random private key.
-	*/
-	static generate() {
-		return new SigningPrivateKey((0, _bcts_rand.rngRandomData)(new _bcts_rand.SecureRandomNumberGenerator(), _bcts_crypto.ECDSA_PRIVATE_KEY_SIZE));
-	}
-	/**
-	* Creates a private key from hex string.
-	*/
-	static fromHex(hex) {
-		const bytes = new Uint8Array(hex.length / 2);
-		for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-		return new SigningPrivateKey(bytes);
-	}
-	/**
-	* Returns the corresponding public key.
-	*/
-	publicKey() {
-		return new SigningPublicKey((0, _bcts_crypto.ecdsaPublicKeyFromPrivateKey)(this.#privateKey));
-	}
-	/**
-	* Signs data and returns a Signature.
-	*/
-	sign(data) {
-		return new Signature((0, _bcts_crypto.ecdsaSign)(this.#privateKey, data));
-	}
-	/**
-	* Returns the raw private key bytes.
-	*/
-	data() {
-		return this.#privateKey;
-	}
-};
-/**
-* ECDSA public key for signature verification using secp256k1 curve.
-* Uses @bcts/crypto functions.
+* Metadata that can be attached to a signature.
 */
-var SigningPublicKey = class SigningPublicKey {
-	#publicKey;
-	constructor(publicKey) {
-		if (publicKey.length !== _bcts_crypto.ECDSA_PUBLIC_KEY_SIZE && publicKey.length !== _bcts_crypto.ECDSA_UNCOMPRESSED_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${_bcts_crypto.ECDSA_PUBLIC_KEY_SIZE} bytes (compressed) or ${_bcts_crypto.ECDSA_UNCOMPRESSED_PUBLIC_KEY_SIZE} bytes (uncompressed)`);
-		this.#publicKey = publicKey;
-	}
-	/**
-	* Creates a public key from hex string.
-	*/
-	static fromHex(hex) {
-		const bytes = new Uint8Array(hex.length / 2);
-		for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-		return new SigningPublicKey(bytes);
-	}
-	/**
-	* Verifies a signature against the provided data.
-	*/
-	verify(data, signature) {
-		try {
-			return (0, _bcts_crypto.ecdsaVerify)(this.#publicKey, signature.data(), data);
-		} catch {
-			return false;
-		}
-	}
+var SignatureMetadata = class SignatureMetadata {
+	#assertions = [];
 	/**
-	* Returns the raw public key bytes.
+	* Creates a new SignatureMetadata instance.
+	* Use the static `new()` method for fluent API style.
 	*/
-	data() {
-		return this.#publicKey;
-	}
+	constructor() {}
 	/**
-	* Returns the hex-encoded public key.
+	* Creates a new empty SignatureMetadata.
 	*/
-	hex() {
-		return Array.from(this.#publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+	static new() {
+		return new SignatureMetadata();
 	}
-};
-/**
-* Metadata that can be attached to a signature.
-*/
-var SignatureMetadata = class SignatureMetadata {
-	#assertions = [];
 	/**
 	* Adds an assertion to the metadata.
 	*/
@@ -1640,114 +1672,110 @@ var SignatureMetadata = class SignatureMetadata {
 		return metadata;
 	}
 	/**
-	* Returns all assertions in the metadata.
+	* Returns all assertions in this metadata.
 	*/
 	assertions() {
 		return this.#assertions;
 	}
-	/**
-	* Returns true if this metadata has any assertions.
-	*/
-	hasAssertions() {
-		return this.#assertions.length > 0;
+};
+Envelope.prototype.addSignatureWithMetadata = function(signer, metadata) {
+	const digest = this.subject().digest();
+	const signature = signer.sign(digest.data());
+	let signatureEnvelope = Envelope.new(signature);
+	if ("publicKey" in signer && typeof signer.publicKey === "function") {
+		const verifier = signer.publicKey();
+		signatureEnvelope = signatureEnvelope.addAssertion(VERIFIED_BY, verifier);
+	}
+	if (metadata !== void 0) for (const [predicate, object] of metadata.assertions()) signatureEnvelope = signatureEnvelope.addAssertion(predicate, object);
+	return this.addAssertion(SIGNED, signatureEnvelope);
+};
+Envelope.prototype.addSignature = function(signer) {
+	return this.addSignatureWithMetadata(signer, void 0);
+};
+Envelope.prototype.addSignatureOpt = function(signer, _options, metadata) {
+	return this.addSignatureWithMetadata(signer, metadata);
+};
+Envelope.prototype.addSignatures = function(signers) {
+	return signers.reduce((envelope, signer) => envelope.addSignature(signer), this);
+};
+Envelope.prototype.addSignaturesWithMetadata = function(signersWithMetadata) {
+	return signersWithMetadata.reduce((envelope, { signer, metadata }) => envelope.addSignatureWithMetadata(signer, metadata), this);
+};
+Envelope.prototype.hasSignatureFrom = function(verifier) {
+	const signedAssertions = this.assertionsWithPredicate(SIGNED);
+	for (const assertion of signedAssertions) try {
+		const signatureCbor = assertion.tryObject().subject().tryLeaf();
+		const signature = _bcts_components.Signature.fromTaggedCbor(signatureCbor);
+		const digest = this.subject().digest();
+		if (verifier.verify(signature, digest.data())) return true;
+	} catch {
+		continue;
 	}
+	return false;
 };
-if (Envelope?.prototype) {
-	Envelope.prototype.addSignature = function(signer) {
-		return this.addSignatureWithMetadata(signer, void 0);
-	};
-	Envelope.prototype.addSignatureWithMetadata = function(signer, metadata) {
+Envelope.prototype.hasSignaturesFrom = function(verifiers) {
+	return verifiers.every((verifier) => this.hasSignatureFrom(verifier));
+};
+Envelope.prototype.hasSignaturesFromThreshold = function(verifiers, threshold) {
+	let count = 0;
+	for (const verifier of verifiers) if (this.hasSignatureFrom(verifier)) {
+		count++;
+		if (count >= threshold) return true;
+	}
+	return false;
+};
+Envelope.prototype.sign = function(signer) {
+	return this.wrap().addSignature(signer);
+};
+Envelope.prototype.signWithMetadata = function(signer, metadata) {
+	return this.wrap().addSignatureWithMetadata(signer, metadata);
+};
+Envelope.prototype.verify = function(verifier) {
+	if (!this.hasSignatureFrom(verifier)) throw EnvelopeError.general("Signature verification failed");
+	return this.unwrap();
+};
+Envelope.prototype.verifyReturningMetadata = function(verifier) {
+	const signedAssertions = this.assertionsWithPredicate(SIGNED);
+	for (const assertion of signedAssertions) try {
+		const signatureEnvelope = assertion.tryObject();
+		const signatureCbor = signatureEnvelope.subject().tryLeaf();
+		const signature = _bcts_components.Signature.fromTaggedCbor(signatureCbor);
 		const digest = this.subject().digest();
-		const signature = signer.sign(digest.data());
-		let signatureEnvelope = Envelope.new(signature.data());
-		if (metadata?.hasAssertions() === true) {
-			for (const [predicate, object] of metadata.assertions()) signatureEnvelope = signatureEnvelope.addAssertion(predicate, object);
-			signatureEnvelope = signatureEnvelope.wrap();
-			const outerSignature = signer.sign(signatureEnvelope.digest().data());
-			signatureEnvelope = signatureEnvelope.addAssertion(SIGNED, outerSignature.data());
-		}
-		return this.addAssertion(SIGNED, signatureEnvelope);
-	};
-	Envelope.prototype.addSignatures = function(signers) {
-		return signers.reduce((envelope, signer) => envelope.addSignature(signer), this);
-	};
-	Envelope.prototype.hasSignatureFrom = function(verifier) {
-		const subjectDigest = this.subject().digest();
-		const signatures = this.signatures();
-		for (const sigEnvelope of signatures) {
-			const c = sigEnvelope.case();
-			if (c.type === "leaf") try {
-				const sigData = sigEnvelope.asByteString();
-				if (sigData !== void 0) {
-					const signature = new Signature(sigData);
-					if (verifier.verify(subjectDigest.data(), signature)) return true;
-				}
-			} catch {
-				continue;
-			}
-			else if (c.type === "node") {
-				const outerSigs = sigEnvelope.assertions().filter((a) => {
-					const aC = a.case();
-					if (aC.type === "assertion") {
-						const pred = aC.assertion.predicate();
-						try {
-							return pred.asText() === SIGNED;
-						} catch {
-							return false;
-						}
-					}
-					return false;
-				});
-				for (const outerSig of outerSigs) {
-					const outerSigCase = outerSig.case();
-					if (outerSigCase.type === "assertion") {
-						const outerSigObj = outerSigCase.assertion.object();
-						try {
-							const outerSigData = outerSigObj.asByteString();
-							if (outerSigData !== void 0) {
-								const outerSignature = new Signature(outerSigData);
-								const nodeSubject = c.subject;
-								const nodeSubjectCase = nodeSubject.case();
-								if (nodeSubjectCase.type === "wrapped" && verifier.verify(nodeSubject.digest().data(), outerSignature)) {
-									const innerSigData = nodeSubjectCase.envelope.subject().asByteString();
-									if (innerSigData !== void 0) {
-										const innerSignature = new Signature(innerSigData);
-										if (verifier.verify(subjectDigest.data(), innerSignature)) return true;
-									}
-								}
-							}
-						} catch {
-							continue;
-						}
-					}
-				}
-			}
+		if (verifier.verify(signature, digest.data())) {
+			const metadata = new SignatureMetadata();
+			for (const metaAssertion of signatureEnvelope.assertions()) try {
+				const pred = metaAssertion.tryPredicate();
+				const obj = metaAssertion.tryObject();
+				const predValue = pred.tryLeaf();
+				const objValue = obj.tryLeaf();
+				if (predValue !== VERIFIED_BY) metadata.withAssertion(predValue, objValue);
+			} catch {}
+			return {
+				envelope: this.unwrap(),
+				metadata
+			};
 		}
-		return false;
-	};
-	Envelope.prototype.verifySignatureFrom = function(verifier) {
-		if (this.hasSignatureFrom(verifier)) return this;
-		throw EnvelopeError.general("No valid signature found from the given verifier");
-	};
-	Envelope.prototype.signatures = function() {
-		return this.assertions().filter((a) => {
-			const c = a.case();
-			if (c.type === "assertion") {
-				const pred = c.assertion.predicate();
-				try {
-					return pred.asText() === SIGNED;
-				} catch {
-					return false;
-				}
-			}
-			return false;
-		}).map((a) => {
-			const c = a.case();
-			if (c.type === "assertion") return c.assertion.object();
-			throw EnvelopeError.general("Invalid signature assertion");
-		});
-	};
-}
+	} catch {
+		continue;
+	}
+	throw EnvelopeError.general("Signature verification failed");
+};
+Envelope.prototype.signatures = function() {
+	return this.assertionsWithPredicate(SIGNED).map((assertion) => assertion.tryObject());
+};
+Envelope.prototype.verifySignatureFrom = function(verifier) {
+	if (!this.hasSignatureFrom(verifier)) throw EnvelopeError.general("Signature verification failed");
+	return this;
+};
+Envelope.prototype.verifySignaturesFrom = function(verifiers) {
+	if (!this.hasSignaturesFrom(verifiers)) throw EnvelopeError.general("Signature verification failed");
+	return this;
+};
+Envelope.prototype.verifySignaturesFromThreshold = function(verifiers, threshold) {
+	const t = threshold ?? verifiers.length;
+	if (!this.hasSignaturesFromThreshold(verifiers, t)) throw EnvelopeError.general("Signature verification failed - threshold not met");
+	return this;
+};
 
 //#endregion
 //#region src/extension/attachment.ts
@@ -1931,188 +1959,268 @@ if (Envelope?.prototype) {
 			}
 		});
 	};
+	/**
+	* Validates that this envelope is a valid attachment.
+	*
+	* An attachment is valid if:
+	* 1. The envelope is an assertion with 'attachment' as predicate
+	* 2. The object contains a wrapped payload with vendor assertion
+	* 3. Reconstructing the attachment yields an equivalent envelope
+	*
+	* @throws EnvelopeError if the envelope is not a valid attachment
+	*/
+	Envelope.prototype.validateAttachment = function() {
+		const c = this.case();
+		if (c.type !== "assertion") throw EnvelopeError.invalidAttachment("Envelope is not an assertion");
+		if (c.assertion.predicate().asText() !== ATTACHMENT) throw EnvelopeError.invalidAttachment("Assertion predicate is not 'attachment'");
+		const payload = this.attachmentPayload();
+		const vendor = this.attachmentVendor();
+		const conformsTo = this.attachmentConformsTo();
+		const reconstructed = Envelope.newAttachment(payload, vendor, conformsTo);
+		if (!this.digest().equals(reconstructed.digest())) throw EnvelopeError.invalidAttachment("Attachment structure is invalid");
+	};
+	/**
+	* Finds a single attachment matching the given vendor and conformsTo.
+	*
+	* Unlike `attachmentsWithVendorAndConformsTo` which returns an array,
+	* this method requires exactly one attachment to match.
+	*
+	* @param vendor - Optional vendor identifier to match
+	* @param conformsTo - Optional conformsTo URI to match
+	* @returns The matching attachment envelope
+	* @throws EnvelopeError if not exactly one attachment matches
+	*/
+	Envelope.prototype.attachmentWithVendorAndConformsTo = function(vendor, conformsTo) {
+		const matches = this.attachmentsWithVendorAndConformsTo(vendor, conformsTo);
+		if (matches.length === 0) throw EnvelopeError.general("No matching attachment found");
+		if (matches.length > 1) throw EnvelopeError.general(`Expected exactly one attachment, found ${matches.length}`);
+		return matches[0];
+	};
 }
 
 //#endregion
 //#region src/extension/recipient.ts
-const HAS_RECIPIENT = "hasRecipient";
-var PublicKeyBase = class PublicKeyBase {
-	#publicKey;
-	constructor(publicKey) {
-		if (publicKey.length !== _bcts_crypto.X25519_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${_bcts_crypto.X25519_PUBLIC_KEY_SIZE} bytes`);
-		this.#publicKey = publicKey;
+/**
+* Public key encryption extension for Gordian Envelope.
+*
+* This module implements public key encryption for Gordian Envelope, allowing
+* encrypted content to be selectively shared with one or more recipients. Each
+* recipient needs their own public/private key pair, and only recipients with
+* the corresponding private key can decrypt the envelope's content.
+*
+* The recipient extension builds on the basic envelope encryption capabilities
+* by adding:
+*
+* - **Multiple Recipients** - A single envelope can be encrypted to multiple
+*   recipients
+* - **Content Key Distribution** - Uses public key cryptography to securely
+*   distribute the symmetric key that encrypts the actual content
+* - **Privacy** - Recipients can decrypt the envelope independently without
+*   revealing their identity or access to other recipients
+*
+* ## How It Works
+*
+* The envelope's subject is encrypted using a random symmetric key (the
+* "content key"), and then this content key is encrypted to each recipient's
+* public key using a `SealedMessage`. Each encrypted content key is attached
+* to the envelope with a `hasRecipient` assertion.
+*
+* When recipients want to decrypt the envelope, they use their private key to
+* decrypt the content key from the appropriate `SealedMessage`, and then use
+* that content key to decrypt the envelope's subject.
+*
+* Ported from bc-envelope-rust/src/extension/recipient.rs
+*/
+/**
+* Predicate constant for recipient assertions.
+* This is the known value 'hasRecipient' used to identify recipient assertions.
+*/
+const HAS_RECIPIENT = _bcts_known_values.HAS_RECIPIENT;
+/**
+* SealedMessage wrapping the sealed content key for a recipient.
+* This is the proper implementation from @bcts/components that supports
+* both X25519 and MLKEM encryption schemes.
+*/
+var SealedMessage = class SealedMessage {
+	#inner;
+	constructor(sealedMessage) {
+		this.#inner = sealedMessage;
 	}
-	data() {
-		return this.#publicKey;
-	}
-	hex() {
-		return Array.from(this.#publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
-	}
-	static fromHex(hex) {
-		if (hex.length !== 64) throw new Error("Hex string must be 64 characters (32 bytes)");
-		const bytes = new Uint8Array(32);
-		for (let i = 0; i < 32; i++) bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
-		return new PublicKeyBase(bytes);
-	}
-};
-var PrivateKeyBase = class PrivateKeyBase {
-	#privateKey;
-	#publicKey;
-	constructor(privateKey, publicKey) {
-		this.#privateKey = privateKey;
-		this.#publicKey = new PublicKeyBase(publicKey);
-	}
-	static generate() {
-		const privateKey = (0, _bcts_crypto.x25519NewPrivateKeyUsing)(new _bcts_rand.SecureRandomNumberGenerator());
-		return new PrivateKeyBase(privateKey, (0, _bcts_crypto.x25519PublicKeyFromPrivateKey)(privateKey));
-	}
-	static fromBytes(privateKey, publicKey) {
-		if (privateKey.length !== _bcts_crypto.X25519_PRIVATE_KEY_SIZE) throw new Error(`Private key must be ${_bcts_crypto.X25519_PRIVATE_KEY_SIZE} bytes`);
-		if (publicKey.length !== _bcts_crypto.X25519_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${_bcts_crypto.X25519_PUBLIC_KEY_SIZE} bytes`);
-		return new PrivateKeyBase(privateKey, publicKey);
-	}
-	static fromHex(privateHex, publicHex) {
-		const privateBytes = new Uint8Array(32);
-		const publicBytes = new Uint8Array(32);
-		for (let i = 0; i < 32; i++) {
-			privateBytes[i] = parseInt(privateHex.substr(i * 2, 2), 16);
-			publicBytes[i] = parseInt(publicHex.substr(i * 2, 2), 16);
-		}
-		return new PrivateKeyBase(privateBytes, publicBytes);
+	/**
+	* Creates a sealed message by encrypting a symmetric key to a recipient.
+	* Uses the Encrypter interface which supports both X25519 and MLKEM.
+	*
+	* @param contentKey - The symmetric key to encrypt
+	* @param recipient - The recipient's public key (implements Encrypter)
+	* @param testNonce - Optional nonce for deterministic testing
+	* @returns A sealed message containing the encrypted content key
+	*/
+	static seal(contentKey, recipient, testNonce) {
+		const encapsulationPublicKey = recipient.encapsulationPublicKey();
+		return new SealedMessage(_bcts_components.SealedMessage.newOpt(contentKey.data(), encapsulationPublicKey, new Uint8Array(0), testNonce));
+	}
+	/**
+	* Decrypts this sealed message using recipient's private key.
+	*
+	* @param recipient - The recipient's private key (implements Decrypter)
+	* @returns The decrypted content key data
+	*/
+	decrypt(recipient) {
+		const encapsulationPrivateKey = recipient.encapsulationPrivateKey();
+		return this.#inner.decrypt(encapsulationPrivateKey);
 	}
-	publicKeys() {
-		return this.#publicKey;
+	/**
+	* Returns the underlying SealedMessage from components.
+	*/
+	inner() {
+		return this.#inner;
 	}
+	/**
+	* Returns the CBOR-encoded data of this sealed message.
+	*/
 	data() {
-		return this.#privateKey;
-	}
-	hex() {
-		return Array.from(this.#privateKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+		return this.#inner.taggedCborData();
 	}
-	unseal(sealedMessage) {
-		try {
-			const decrypted = sealedMessage.decrypt(this.#privateKey, this.#publicKey.data());
-			return SymmetricKey.from(decrypted);
-		} catch (_error) {
-			throw EnvelopeError.general("Failed to unseal message: not a recipient");
-		}
-	}
-};
-var SealedMessage = class SealedMessage {
-	#data;
-	constructor(data) {
-		this.#data = data;
-	}
-	static seal(contentKey, recipientPublicKey) {
-		const rng = new _bcts_rand.SecureRandomNumberGenerator();
-		const ephemeralPrivate = (0, _bcts_crypto.x25519NewPrivateKeyUsing)(rng);
-		const ephemeralPublic = (0, _bcts_crypto.x25519PublicKeyFromPrivateKey)(ephemeralPrivate);
-		const encryptionKey = (0, _bcts_crypto.hkdfHmacSha256)((0, _bcts_crypto.x25519SharedKey)(ephemeralPrivate, recipientPublicKey.data()), new TextEncoder().encode("sealed_message"), 32);
-		const nonce = (0, _bcts_rand.rngRandomData)(rng, _bcts_crypto.SYMMETRIC_NONCE_SIZE);
-		const [ciphertext, authTag] = (0, _bcts_crypto.aeadChaCha20Poly1305EncryptWithAad)(contentKey.data(), encryptionKey, nonce, new Uint8Array(0));
-		const totalLength = ephemeralPublic.length + nonce.length + ciphertext.length + authTag.length;
-		const sealed = new Uint8Array(totalLength);
-		let offset = 0;
-		sealed.set(ephemeralPublic, offset);
-		offset += ephemeralPublic.length;
-		sealed.set(nonce, offset);
-		offset += nonce.length;
-		sealed.set(ciphertext, offset);
-		offset += ciphertext.length;
-		sealed.set(authTag, offset);
-		return new SealedMessage(sealed);
-	}
-	decrypt(recipientPrivate, _recipientPublic) {
-		const minLength = _bcts_crypto.X25519_PUBLIC_KEY_SIZE + _bcts_crypto.SYMMETRIC_NONCE_SIZE + _bcts_crypto.SYMMETRIC_AUTH_SIZE;
-		if (this.#data.length < minLength) throw new Error("Sealed message too short");
-		let offset = 0;
-		const ephemeralPublic = this.#data.slice(offset, offset + _bcts_crypto.X25519_PUBLIC_KEY_SIZE);
-		offset += _bcts_crypto.X25519_PUBLIC_KEY_SIZE;
-		const nonce = this.#data.slice(offset, offset + _bcts_crypto.SYMMETRIC_NONCE_SIZE);
-		offset += _bcts_crypto.SYMMETRIC_NONCE_SIZE;
-		const ciphertextAndTag = this.#data.slice(offset);
-		const ciphertext = ciphertextAndTag.slice(0, -_bcts_crypto.SYMMETRIC_AUTH_SIZE);
-		const authTag = ciphertextAndTag.slice(-_bcts_crypto.SYMMETRIC_AUTH_SIZE);
-		return (0, _bcts_crypto.aeadChaCha20Poly1305DecryptWithAad)(ciphertext, (0, _bcts_crypto.hkdfHmacSha256)((0, _bcts_crypto.x25519SharedKey)(recipientPrivate, ephemeralPublic), new TextEncoder().encode("sealed_message"), 32), nonce, new Uint8Array(0), authTag);
-	}
-	data() {
-		return this.#data;
-	}
-	hex() {
-		return Array.from(this.#data).map((b) => b.toString(16).padStart(2, "0")).join("");
-	}
-	static fromHex(hex) {
-		const bytes = new Uint8Array(hex.length / 2);
-		for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
-		return new SealedMessage(bytes);
+	/**
+	* Creates a SealedMessage from CBOR-encoded data.
+	*/
+	static fromData(data) {
+		return new SealedMessage(_bcts_components.SealedMessage.fromTaggedCborData(data));
 	}
 };
 if (Envelope?.prototype) {
-	Envelope.prototype.encryptSubjectToRecipient = function(recipientPublicKey) {
-		const contentKey = SymmetricKey.generate();
-		return this.encryptSubject(contentKey).addRecipient(recipientPublicKey, contentKey);
+	/**
+	* Adds a recipient assertion to this envelope.
+	*
+	* This method adds a `hasRecipient` assertion containing a `SealedMessage`
+	* that holds the content key encrypted to the recipient's public key.
+	*
+	* @param recipient - The recipient's public key (implements Encrypter)
+	* @param contentKey - The symmetric key used to encrypt the envelope's subject
+	* @param testNonce - Optional nonce for deterministic testing
+	* @returns A new envelope with the recipient assertion added
+	*/
+	Envelope.prototype.addRecipient = function(recipient, contentKey, testNonce) {
+		const sealedMessage = SealedMessage.seal(contentKey, recipient, testNonce);
+		return this.addAssertion(HAS_RECIPIENT, sealedMessage.inner());
+	};
+	/**
+	* Encrypts the envelope's subject and adds a recipient assertion.
+	*
+	* This is a convenience method that:
+	* 1. Generates a random content key
+	* 2. Encrypts the subject with the content key
+	* 3. Adds a recipient assertion with the sealed content key
+	*
+	* @param recipient - The recipient's public key (implements Encrypter)
+	* @returns A new envelope with encrypted subject and recipient assertion
+	*/
+	Envelope.prototype.encryptSubjectToRecipient = function(recipient) {
+		if (!(0, _bcts_components.isEncrypter)(recipient)) throw EnvelopeError.general("Recipient must implement Encrypter interface. Use PublicKeys or EncapsulationPublicKey from @bcts/components.");
+		const contentKey = _bcts_components.SymmetricKey.new();
+		return this.encryptSubject(contentKey).addRecipient(recipient, contentKey);
 	};
+	/**
+	* Encrypts the envelope's subject and adds recipient assertions for multiple recipients.
+	*
+	* @param recipients - Array of recipient public keys (each implements Encrypter)
+	* @returns A new envelope with encrypted subject and recipient assertions
+	*/
 	Envelope.prototype.encryptSubjectToRecipients = function(recipients) {
 		if (recipients.length === 0) throw EnvelopeError.general("Must provide at least one recipient");
-		const contentKey = SymmetricKey.generate();
+		const contentKey = _bcts_components.SymmetricKey.new();
 		let result = this.encryptSubject(contentKey);
-		for (const recipient of recipients) result = result.addRecipient(recipient, contentKey);
+		for (const recipient of recipients) {
+			if (!(0, _bcts_components.isEncrypter)(recipient)) throw EnvelopeError.general("All recipients must implement Encrypter interface. Use PublicKeys or EncapsulationPublicKey from @bcts/components.");
+			result = result.addRecipient(recipient, contentKey);
+		}
 		return result;
 	};
-	Envelope.prototype.addRecipient = function(recipientPublicKey, contentKey) {
-		const sealedMessage = SealedMessage.seal(contentKey, recipientPublicKey);
-		return this.addAssertion(HAS_RECIPIENT, sealedMessage.data());
-	};
-	Envelope.prototype.decryptSubjectToRecipient = function(recipientPrivateKey) {
-		if (this.subject().case().type !== "encrypted") throw EnvelopeError.general("Subject is not encrypted");
-		const recipientAssertions = this.assertions().filter((assertion) => {
+	/**
+	* Returns all SealedMessages from the envelope's `hasRecipient` assertions.
+	*
+	* @returns Array of SealedMessage objects
+	*/
+	Envelope.prototype.recipients = function() {
+		return this.assertions().filter((assertion) => {
 			try {
 				const predicate = assertion.subject().asPredicate();
 				if (predicate === void 0) return false;
-				return predicate.asText() === HAS_RECIPIENT;
+				const knownValue = predicate.asKnownValue();
+				if (knownValue !== void 0) return knownValue.equals(HAS_RECIPIENT);
+				return predicate.asText() === "hasRecipient";
 			} catch {
 				return false;
 			}
+		}).map((assertion) => {
+			const assertionCase = assertion.case();
+			if (assertionCase.type !== "assertion") throw EnvelopeError.general("Invalid recipient assertion structure");
+			const obj = assertionCase.assertion.object();
+			try {
+				const leafCbor = obj.asLeaf();
+				if (leafCbor !== void 0) {
+					const cborData$6 = leafCbor.toData();
+					return new SealedMessage(_bcts_components.SealedMessage.fromTaggedCborData(cborData$6));
+				}
+				const cborData$5 = obj.taggedCborData();
+				return new SealedMessage(_bcts_components.SealedMessage.fromTaggedCborData(cborData$5));
+			} catch {
+				try {
+					const sealedData = obj.asByteString();
+					if (sealedData !== void 0) return SealedMessage.fromData(sealedData);
+				} catch {}
+				throw EnvelopeError.general("Invalid recipient sealed message format");
+			}
 		});
-		if (recipientAssertions.length === 0) throw EnvelopeError.general("No recipients found");
-		let contentKey = null;
-		for (const assertion of recipientAssertions) try {
-			const obj = assertion.subject().asObject();
-			if (obj === void 0) continue;
-			const sealedData = obj.asByteString();
-			if (sealedData === void 0) continue;
-			const sealedMessage = new SealedMessage(sealedData);
-			contentKey = recipientPrivateKey.unseal(sealedMessage);
+	};
+	/**
+	* Decrypts the envelope's subject using the recipient's private key.
+	*
+	* This method:
+	* 1. Finds all `hasRecipient` assertions
+	* 2. Tries to decrypt each sealed message until one succeeds
+	* 3. Uses the recovered content key to decrypt the subject
+	*
+	* @param recipient - The recipient's private key (implements Decrypter)
+	* @returns A new envelope with decrypted subject
+	*/
+	Envelope.prototype.decryptSubjectToRecipient = function(recipient) {
+		if (this.subject().case().type !== "encrypted") throw EnvelopeError.general("Subject is not encrypted");
+		const sealedMessages = this.recipients();
+		if (sealedMessages.length === 0) throw EnvelopeError.general("No recipients found");
+		let contentKeyData = null;
+		for (const sealedMessage of sealedMessages) try {
+			contentKeyData = sealedMessage.decrypt(recipient);
 			break;
 		} catch {
 			continue;
 		}
-		if (contentKey === null) throw EnvelopeError.general("Not a valid recipient");
+		if (contentKeyData === null) throw EnvelopeError.general("Not a valid recipient");
+		const contentKey = _bcts_components.SymmetricKey.from(contentKeyData);
 		return this.decryptSubject(contentKey);
 	};
-	Envelope.prototype.decryptToRecipient = function(recipientPrivateKey) {
-		return this.decryptSubjectToRecipient(recipientPrivateKey).unwrap();
+	/**
+	* Decrypts an envelope that was encrypted to a recipient and unwraps it.
+	*
+	* This is a convenience method that:
+	* 1. Decrypts the subject using the recipient's private key
+	* 2. Unwraps the resulting envelope
+	*
+	* @param recipient - The recipient's private key (implements Decrypter)
+	* @returns The unwrapped, decrypted envelope
+	*/
+	Envelope.prototype.decryptToRecipient = function(recipient) {
+		return this.decryptSubjectToRecipient(recipient).unwrap();
 	};
+	/**
+	* Wraps and encrypts an envelope to multiple recipients.
+	*
+	* @param recipients - Array of recipient public keys (each implements Encrypter)
+	* @returns A wrapped and encrypted envelope
+	*/
 	Envelope.prototype.encryptToRecipients = function(recipients) {
 		return this.wrap().encryptSubjectToRecipients(recipients);
 	};
-	Envelope.prototype.recipients = function() {
-		return this.assertions().filter((assertion) => {
-			try {
-				const predicate = assertion.subject().asPredicate();
-				if (predicate === void 0) return false;
-				return predicate.asText() === HAS_RECIPIENT;
-			} catch {
-				return false;
-			}
-		}).map((assertion) => {
-			const obj = assertion.subject().asObject();
-			if (obj === void 0) throw EnvelopeError.general("Invalid recipient assertion");
-			const sealedData = obj.asByteString();
-			if (sealedData === void 0) throw EnvelopeError.general("Invalid recipient data");
-			return new SealedMessage(sealedData);
-		});
-	};
 }
 
 //#endregion
@@ -2144,72 +2252,306 @@ const PARAMETER_IDS = {
 	RHS: 3
 };
 var Function = class Function {
-	#id;
-	constructor(id) {
-		this.#id = id;
+	#variant;
+	#value;
+	#name;
+	constructor(variant, value, name) {
+		this.#variant = variant;
+		this.#value = value;
+		this.#name = name;
+	}
+	static newKnown(value, name) {
+		return new Function("known", value, name);
+	}
+	static newNamed(name) {
+		return new Function("named", 0, name);
+	}
+	static fromNumeric(id) {
+		return Function.newKnown(id);
+	}
+	static fromString(name) {
+		return Function.newNamed(name);
+	}
+	isKnown() {
+		return this.#variant === "known";
+	}
+	isNamed() {
+		return this.#variant === "named";
+	}
+	value() {
+		return this.#variant === "known" ? this.#value : void 0;
 	}
 	id() {
-		return this.#id;
+		if (this.#variant === "known") return this.#value;
+		if (this.#name === void 0) throw new Error("Invalid named function: missing name");
+		return this.#name;
+	}
+	name() {
+		if (this.#variant === "known") return this.#name ?? this.#value.toString();
+		else return `"${this.#name}"`;
+	}
+	namedName() {
+		return this.#variant === "named" ? this.#name : void 0;
+	}
+	assignedName() {
+		return this.#variant === "known" ? this.#name : void 0;
 	}
 	isNumeric() {
-		return typeof this.#id === "number";
+		return this.#variant === "known";
 	}
 	isString() {
-		return typeof this.#id === "string";
+		return this.#variant === "named";
 	}
 	envelope() {
-		const functionStr = typeof this.#id === "number" ? `«${this.#id}»` : `«"${this.#id}"»`;
+		const functionStr = this.#variant === "known" ? `«${this.#value}»` : `«"${this.#name}"»`;
 		return Envelope.new(functionStr);
 	}
+	intoEnvelope() {
+		return this.envelope();
+	}
 	withParameter(param, value) {
 		return new Expression(this).withParameter(param, value);
 	}
-	static fromNumeric(id) {
-		return new Function(id);
-	}
-	static fromString(name) {
-		return new Function(name);
+	equals(other) {
+		if (this.#variant !== other.#variant) return false;
+		if (this.#variant === "known") return this.#value === other.#value;
+		else return this.#name === other.#name;
+	}
+	hashCode() {
+		if (this.#variant === "known") return this.#value;
+		else {
+			let hash = 0;
+			for (let i = 0; i < (this.#name?.length ?? 0); i++) hash = hash * 31 + (this.#name?.charCodeAt(i) ?? 0) | 0;
+			return hash;
+		}
 	}
 	toString() {
-		return typeof this.#id === "number" ? `«${this.#id}»` : `«"${this.#id}"»`;
+		return this.#variant === "known" ? `«${this.#value}»` : `«"${this.#name}"»`;
+	}
+};
+var FunctionsStore = class {
+	#dict = /* @__PURE__ */ new Map();
+	constructor(functions = []) {
+		for (const func of functions) this.insert(func);
+	}
+	insert(func) {
+		if (func.isKnown()) {
+			const value = func.value();
+			if (value !== void 0) this.#dict.set(value, func);
+		} else {
+			const name = func.namedName();
+			if (name !== void 0) this.#dict.set(name, func);
+		}
+	}
+	assignedName(func) {
+		let key;
+		if (func.isKnown()) key = func.value();
+		else key = func.namedName();
+		if (key === void 0) return void 0;
+		return this.#dict.get(key)?.assignedName();
+	}
+	name(func) {
+		return this.assignedName(func) ?? func.name();
+	}
+	static nameForFunction(func, store) {
+		if (store !== void 0) {
+			const assigned = store.assignedName(func);
+			if (assigned !== void 0 && assigned !== "") return assigned;
+		}
+		return func.name();
 	}
 };
 var Parameter = class Parameter {
-	#id;
+	#variant;
 	#value;
-	constructor(id, value) {
-		this.#id = id;
+	#name;
+	#paramValue;
+	constructor(variant, value, name, paramValue) {
+		this.#variant = variant;
 		this.#value = value;
+		this.#name = name;
+		this.#paramValue = paramValue;
 	}
-	id() {
-		return this.#id;
+	static newKnown(value, name) {
+		return new Parameter("known", value, name);
+	}
+	static newNamed(name) {
+		return new Parameter("named", 0, name);
+	}
+	static withValue(id, value) {
+		if (typeof id === "number") return new Parameter("known", id, void 0, value);
+		else return new Parameter("named", 0, id, value);
+	}
+	isKnown() {
+		return this.#variant === "known";
+	}
+	isNamed() {
+		return this.#variant === "named";
 	}
 	value() {
-		return this.#value;
+		return this.#variant === "known" ? this.#value : void 0;
+	}
+	id() {
+		if (this.#variant === "known") return this.#value;
+		if (this.#name === void 0) throw new Error("Invalid named parameter: missing name");
+		return this.#name;
+	}
+	name() {
+		if (this.#variant === "known") return this.#name ?? this.#value.toString();
+		else return `"${this.#name}"`;
+	}
+	namedName() {
+		return this.#variant === "named" ? this.#name : void 0;
+	}
+	assignedName() {
+		return this.#variant === "known" ? this.#name : void 0;
+	}
+	paramValue() {
+		return this.#paramValue;
 	}
 	isNumeric() {
-		return typeof this.#id === "number";
+		return this.#variant === "known";
 	}
 	isString() {
-		return typeof this.#id === "string";
+		return this.#variant === "named";
 	}
 	envelope() {
-		const paramStr = typeof this.#id === "number" ? `❰${this.#id}❱` : `❰"${this.#id}"❱`;
-		return Envelope.newAssertion(paramStr, this.#value);
+		const paramStr = this.#variant === "known" ? `❰${this.#value}❱` : `❰"${this.#name}"❱`;
+		if (this.#paramValue !== void 0) return Envelope.newAssertion(paramStr, this.#paramValue);
+		return Envelope.new(paramStr);
+	}
+	intoEnvelope() {
+		return this.envelope();
+	}
+	equals(other) {
+		if (this.#variant !== other.#variant) return false;
+		if (this.#variant === "known") return this.#value === other.#value;
+		else return this.#name === other.#name;
+	}
+	hashCode() {
+		if (this.#variant === "known") return this.#value;
+		else {
+			let hash = 0;
+			for (let i = 0; i < (this.#name?.length ?? 0); i++) hash = hash * 31 + (this.#name?.charCodeAt(i) ?? 0) | 0;
+			return hash;
+		}
+	}
+	toString() {
+		const idStr = this.#variant === "known" ? `❰${this.#value}❱` : `❰"${this.#name}"❱`;
+		if (this.#paramValue !== void 0) return `${idStr}: ${this.#paramValue.asText()}`;
+		return idStr;
 	}
 	static blank(value) {
-		return new Parameter(PARAMETER_IDS.BLANK, Envelope.new(value));
+		return Parameter.withValue(PARAMETER_IDS.BLANK, Envelope.new(value));
 	}
 	static lhs(value) {
-		return new Parameter(PARAMETER_IDS.LHS, Envelope.new(value));
+		return Parameter.withValue(PARAMETER_IDS.LHS, Envelope.new(value));
 	}
 	static rhs(value) {
-		return new Parameter(PARAMETER_IDS.RHS, Envelope.new(value));
+		return Parameter.withValue(PARAMETER_IDS.RHS, Envelope.new(value));
 	}
-	toString() {
-		return `${typeof this.#id === "number" ? `❰${this.#id}❱` : `❰"${this.#id}"❱`}: ${this.#value.asText()}`;
+};
+var ParametersStore = class {
+	#dict = /* @__PURE__ */ new Map();
+	constructor(parameters = []) {
+		for (const param of parameters) this.insert(param);
+	}
+	insert(param) {
+		if (param.isKnown()) {
+			const value = param.value();
+			if (value !== void 0) this.#dict.set(value, param);
+		} else {
+			const name = param.namedName();
+			if (name !== void 0) this.#dict.set(name, param);
+		}
+	}
+	assignedName(param) {
+		let key;
+		if (param.isKnown()) key = param.value();
+		else key = param.namedName();
+		if (key === void 0) return void 0;
+		return this.#dict.get(key)?.assignedName();
+	}
+	name(param) {
+		return this.assignedName(param) ?? param.name();
+	}
+	static nameForParameter(param, store) {
+		if (store !== void 0) {
+			const assigned = store.assignedName(param);
+			if (assigned !== void 0 && assigned !== "") return assigned;
+		}
+		return param.name();
 	}
 };
+const ADD = Function.newKnown(FUNCTION_IDS.ADD, "add");
+const SUB = Function.newKnown(FUNCTION_IDS.SUB, "sub");
+const MUL = Function.newKnown(FUNCTION_IDS.MUL, "mul");
+const DIV = Function.newKnown(FUNCTION_IDS.DIV, "div");
+const NEG = Function.newKnown(FUNCTION_IDS.NEG, "neg");
+const LT = Function.newKnown(FUNCTION_IDS.LT, "lt");
+const LE = Function.newKnown(FUNCTION_IDS.LE, "le");
+const GT = Function.newKnown(FUNCTION_IDS.GT, "gt");
+const GE = Function.newKnown(FUNCTION_IDS.GE, "ge");
+const EQ = Function.newKnown(FUNCTION_IDS.EQ, "eq");
+const NE = Function.newKnown(FUNCTION_IDS.NE, "ne");
+const AND = Function.newKnown(FUNCTION_IDS.AND, "and");
+const OR = Function.newKnown(FUNCTION_IDS.OR, "or");
+const XOR = Function.newKnown(FUNCTION_IDS.XOR, "xor");
+const NOT = Function.newKnown(FUNCTION_IDS.NOT, "not");
+const ADD_VALUE = FUNCTION_IDS.ADD;
+const SUB_VALUE = FUNCTION_IDS.SUB;
+const MUL_VALUE = FUNCTION_IDS.MUL;
+const DIV_VALUE = FUNCTION_IDS.DIV;
+const NEG_VALUE = FUNCTION_IDS.NEG;
+const LT_VALUE = FUNCTION_IDS.LT;
+const LE_VALUE = FUNCTION_IDS.LE;
+const GT_VALUE = FUNCTION_IDS.GT;
+const GE_VALUE = FUNCTION_IDS.GE;
+const EQ_VALUE = FUNCTION_IDS.EQ;
+const NE_VALUE = FUNCTION_IDS.NE;
+const AND_VALUE = FUNCTION_IDS.AND;
+const OR_VALUE = FUNCTION_IDS.OR;
+const XOR_VALUE = FUNCTION_IDS.XOR;
+const NOT_VALUE = FUNCTION_IDS.NOT;
+const BLANK = Parameter.newKnown(PARAMETER_IDS.BLANK, "_");
+const LHS = Parameter.newKnown(PARAMETER_IDS.LHS, "lhs");
+const RHS = Parameter.newKnown(PARAMETER_IDS.RHS, "rhs");
+const BLANK_VALUE = PARAMETER_IDS.BLANK;
+const LHS_VALUE = PARAMETER_IDS.LHS;
+const RHS_VALUE = PARAMETER_IDS.RHS;
+var LazyStore = class {
+	#store;
+	#initializer;
+	constructor(initializer) {
+		this.#initializer = initializer;
+	}
+	get() {
+		this.#store ??= this.#initializer();
+		return this.#store;
+	}
+};
+const GLOBAL_FUNCTIONS = new LazyStore(() => new FunctionsStore([
+	ADD,
+	SUB,
+	MUL,
+	DIV,
+	NEG,
+	LT,
+	LE,
+	GT,
+	GE,
+	EQ,
+	NE,
+	AND,
+	OR,
+	XOR,
+	NOT
+]));
+const GLOBAL_PARAMETERS = new LazyStore(() => new ParametersStore([
+	BLANK,
+	LHS,
+	RHS
+]));
 var Expression = class Expression {
 	#function;
 	#parameters = /* @__PURE__ */ new Map();
@@ -2225,7 +2567,7 @@ var Expression = class Expression {
 	}
 	withParameter(param, value) {
 		const key = typeof param === "number" ? param.toString() : param;
-		this.#parameters.set(key, new Parameter(param, Envelope.new(value)));
+		this.#parameters.set(key, Parameter.withValue(param, Envelope.new(value)));
 		this.#envelope = null;
 		return this;
 	}
@@ -2235,7 +2577,7 @@ var Expression = class Expression {
 	}
 	getParameter(param) {
 		const key = typeof param === "number" ? param.toString() : param;
-		return this.#parameters.get(key)?.value();
+		return this.#parameters.get(key)?.paramValue();
 	}
 	hasParameter(param) {
 		const key = typeof param === "number" ? param.toString() : param;
@@ -2245,29 +2587,33 @@ var Expression = class Expression {
 		if (this.#envelope !== null) return this.#envelope;
 		let env = this.#function.envelope();
 		for (const param of this.#parameters.values()) {
-			const assertion = param.envelope().assertions()[0];
-			if (assertion !== void 0) {
-				const predicate = assertion.subject().asPredicate();
-				const object = assertion.subject().asObject();
-				if (predicate !== void 0 && object !== void 0) env = env.addAssertion(predicate.asText(), object);
+			const paramCase = param.envelope().case();
+			if (paramCase.type === "assertion") {
+				const predicate = paramCase.assertion.predicate();
+				const object = paramCase.assertion.object();
+				const predText = predicate.asText();
+				if (predText !== void 0) env = env.addAssertion(predText, object);
 			}
 		}
 		this.#envelope = env;
 		return env;
 	}
+	intoEnvelope() {
+		return this.envelope();
+	}
 	static fromEnvelope(envelope) {
 		const subjectText = envelope.subject().asText();
 		if (subjectText === void 0) throw EnvelopeError.general("Not a valid function envelope");
-		let funcId;
+		let func;
 		if (subjectText.startsWith("«") && subjectText.endsWith("»")) {
 			const inner = subjectText.slice(1, -1);
-			if (inner.startsWith("\"") && inner.endsWith("\"")) funcId = inner.slice(1, -1);
-			else funcId = parseInt(inner, 10);
+			if (inner.startsWith("\"") && inner.endsWith("\"")) func = Function.newNamed(inner.slice(1, -1));
+			else func = Function.newKnown(parseInt(inner, 10));
 		} else throw EnvelopeError.general("Not a valid function envelope");
-		const expr = new Expression(new Function(funcId));
+		const expr = new Expression(func);
 		for (const assertion of envelope.assertions()) try {
 			const pred = assertion.subject().asPredicate();
-			const obj = assertion.subject().asObject();
+			const obj = assertion.asObject();
 			if (pred !== void 0 && obj !== void 0) {
 				const predText = pred.asText();
 				if (predText !== void 0 && predText.startsWith("❰") && predText.endsWith("❱")) {
@@ -2289,37 +2635,49 @@ var Expression = class Expression {
 	}
 };
 function add(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.ADD).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(ADD).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function sub(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.SUB).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(SUB).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function mul(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.MUL).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(MUL).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function div(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.DIV).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(DIV).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function neg(value) {
-	return Function.fromNumeric(FUNCTION_IDS.NEG).withParameter(PARAMETER_IDS.BLANK, value);
+	return new Expression(NEG).withParameter(PARAMETER_IDS.BLANK, value);
 }
 function lt(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.LT).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(LT).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+}
+function le(lhs, rhs) {
+	return new Expression(LE).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function gt(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.GT).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(GT).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+}
+function ge(lhs, rhs) {
+	return new Expression(GE).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function eq(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.EQ).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(EQ).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+}
+function ne(lhs, rhs) {
+	return new Expression(NE).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function and(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.AND).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(AND).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function or(lhs, rhs) {
-	return Function.fromNumeric(FUNCTION_IDS.OR).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+	return new Expression(OR).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
+}
+function xor(lhs, rhs) {
+	return new Expression(XOR).withParameter(PARAMETER_IDS.LHS, lhs).withParameter(PARAMETER_IDS.RHS, rhs);
 }
 function not(value) {
-	return Function.fromNumeric(FUNCTION_IDS.NOT).withParameter(PARAMETER_IDS.BLANK, value);
+	return new Expression(NOT).withParameter(PARAMETER_IDS.BLANK, value);
 }
 
 //#endregion
@@ -2351,7 +2709,7 @@ function revealSetOfSet(envelope, target) {
 function revealSets(envelope, target, current, result) {
 	const newCurrent = new Set(current);
 	newCurrent.add(envelope.digest());
-	if (containsDigest(target, envelope.digest())) for (const digest of newCurrent) result.add(digest);
+	if (containsDigest$1(target, envelope.digest())) for (const digest of newCurrent) result.add(digest);
 	const envelopeCase = envelope.case();
 	if (envelopeCase.type === "node") {
 		revealSets(envelopeCase.subject, target, newCurrent, result);
@@ -2370,7 +2728,7 @@ function containsAll(envelope, target) {
 	return targetCopy.size === 0;
 }
 function removeAllFound(envelope, target) {
-	if (containsDigest(target, envelope.digest())) removeDigest(target, envelope.digest());
+	if (containsDigest$1(target, envelope.digest())) removeDigest(target, envelope.digest());
 	if (target.size === 0) return;
 	const envelopeCase = envelope.case();
 	if (envelopeCase.type === "node") {
@@ -2387,7 +2745,7 @@ function removeAllFound(envelope, target) {
 		if (target.size > 0) removeAllFound(object, target);
 	}
 }
-function containsDigest(set, digest) {
+function containsDigest$1(set, digest) {
 	const hexToFind = digest.hex();
 	for (const d of set) if (d.hex() === hexToFind) return true;
 	return false;
@@ -2400,121 +2758,780 @@ function removeDigest(set, digest) {
 	}
 }
 function isSubset(subset, superset) {
-	for (const digest of subset) if (!containsDigest(superset, digest)) return false;
+	for (const digest of subset) if (!containsDigest$1(superset, digest)) return false;
 	return true;
 }
+function registerProofExtension() {}
 
 //#endregion
-//#region src/format/hex.ts
-Envelope.prototype.hex = function() {
-	const bytes = this.cborBytes();
-	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+//#region src/extension/secret.ts
+Envelope.prototype.lockSubject = function(method, secret) {
+	const contentKey = _bcts_components.SymmetricKey.new();
+	const componentsKey = _bcts_components.SymmetricKey.fromData(contentKey.data());
+	const encryptedKey = _bcts_components.EncryptedKey.lock(method, secret, componentsKey);
+	return this.encryptSubject(contentKey).addAssertion(_bcts_known_values.HAS_SECRET, encryptedKey);
 };
-Envelope.prototype.cborBytes = function() {
-	return (0, _bcts_dcbor.cborData)(this.taggedCbor());
+Envelope.prototype.unlockSubject = function(secret) {
+	const assertions = this.assertionsWithPredicate(_bcts_known_values.HAS_SECRET);
+	for (const assertion of assertions) {
+		const obj = assertion.asObject();
+		if (obj === void 0) continue;
+		if (obj.isObscured()) continue;
+		try {
+			const componentsKey = obj.extractSubject((cbor$1) => _bcts_components.EncryptedKey.fromTaggedCbor(cbor$1)).unlock(secret);
+			const contentKey = _bcts_components.SymmetricKey.from(componentsKey.data());
+			return this.decryptSubject(contentKey);
+		} catch {
+			continue;
+		}
+	}
+	throw EnvelopeError.unknownSecret();
+};
+Envelope.prototype.isLockedWithPassword = function() {
+	const assertions = this.assertionsWithPredicate(_bcts_known_values.HAS_SECRET);
+	for (const assertion of assertions) {
+		const obj = assertion.asObject();
+		if (obj === void 0) continue;
+		try {
+			if (obj.extractSubject((cbor$1) => _bcts_components.EncryptedKey.fromTaggedCbor(cbor$1)).isPasswordBased()) return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
+};
+Envelope.prototype.isLockedWithSshAgent = function() {
+	const assertions = this.assertionsWithPredicate(_bcts_known_values.HAS_SECRET);
+	for (const assertion of assertions) {
+		const obj = assertion.asObject();
+		if (obj === void 0) continue;
+		try {
+			if (obj.extractSubject((cbor$1) => _bcts_components.EncryptedKey.fromTaggedCbor(cbor$1)).isSshAgent()) return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
 };
+Envelope.prototype.addSecret = function(method, secret, contentKey) {
+	const componentsKey = _bcts_components.SymmetricKey.fromData(contentKey.data());
+	const encryptedKey = _bcts_components.EncryptedKey.lock(method, secret, componentsKey);
+	return this.addAssertion(_bcts_known_values.HAS_SECRET, encryptedKey);
+};
+Envelope.prototype.lock = function(method, secret) {
+	return this.wrap().lockSubject(method, secret);
+};
+Envelope.prototype.unlock = function(secret) {
+	return this.unlockSubject(secret).tryUnwrap();
+};
+const registerSecretExtension = () => {};
 
 //#endregion
-//#region src/format/diagnostic.ts
-function cborToDiagnostic(cbor$1, indent = 0) {
-	if (typeof cbor$1 === "object" && cbor$1 !== null && "tag" in cbor$1 && "value" in cbor$1) {
-		const tagged = cbor$1;
-		return `${tagged.tag}(${cborToDiagnostic(tagged.value, indent)})`;
-	}
-	if (Array.isArray(cbor$1)) {
-		if (cbor$1.length === 0) return "[]";
-		return `[${cbor$1.map((item) => cborToDiagnostic(item, indent + 2)).join(", ")}]`;
+//#region src/extension/sskr.ts
+const addSskrShare = (envelope, share) => {
+	return envelope.addAssertion(_bcts_known_values.SSKR_SHARE, share);
+};
+Envelope.prototype.sskrSplit = function(spec, contentKey) {
+	const shareGroups = (0, _bcts_components.sskrGenerateShares)(spec, _bcts_components.SSKRSecret.new(contentKey.data()));
+	const result = [];
+	for (const group of shareGroups) {
+		const groupResult = [];
+		for (const share of group) {
+			const shareEnvelope = addSskrShare(this, share);
+			groupResult.push(shareEnvelope);
+		}
+		result.push(groupResult);
 	}
-	if (cbor$1 instanceof Map) {
-		if (cbor$1.size === 0) return "{}";
-		const entries = [];
-		for (const [key, value] of cbor$1) {
-			const keyStr = cborToDiagnostic(key, indent + 2);
-			const valueStr = cborToDiagnostic(value, indent + 2);
-			entries.push(`${keyStr}: ${valueStr}`);
+	return result;
+};
+Envelope.prototype.sskrSplitFlattened = function(spec, contentKey) {
+	return this.sskrSplit(spec, contentKey).flat();
+};
+Envelope.prototype.sskrSplitUsing = function(spec, contentKey, rng) {
+	const shareGroups = (0, _bcts_components.sskrGenerateUsing)(spec, _bcts_components.SSKRSecret.new(contentKey.data()), rng);
+	const result = [];
+	for (const group of shareGroups) {
+		const groupResult = [];
+		for (const shareData of group) {
+			const share = _bcts_components.SSKRShareCbor.fromData(shareData);
+			const shareEnvelope = addSskrShare(this, share);
+			groupResult.push(shareEnvelope);
 		}
-		return `{${entries.join(", ")}}`;
+		result.push(groupResult);
 	}
-	if (cbor$1 instanceof Uint8Array) return `h'${Array.from(cbor$1).map((b) => b.toString(16).padStart(2, "0")).join("")}'`;
-	if (typeof cbor$1 === "string") return JSON.stringify(cbor$1);
-	if (typeof cbor$1 === "object" && cbor$1 !== null && "type" in cbor$1) {
-		const typed = cbor$1;
-		switch (typed.type) {
-			case 0: return String(typed.value);
-			case 1: return String(-1 - Number(typed.value));
-			case 7: {
-				const simpleValue = typed.value;
-				if (simpleValue !== null && typeof simpleValue === "object" && "type" in simpleValue) {
-					const floatValue = simpleValue;
-					if (floatValue.type === "Float") return String(floatValue.value);
-				}
-				if (simpleValue === 20) return "false";
-				if (simpleValue === 21) return "true";
-				if (simpleValue === 22) return "null";
-				if (simpleValue === 23) return "undefined";
-				return `simple(${String(simpleValue)})`;
+	return result;
+};
+const extractSskrSharesGrouped = (envelopes) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const envelope of envelopes) {
+		const assertions = envelope.assertionsWithPredicate(_bcts_known_values.SSKR_SHARE);
+		for (const assertion of assertions) {
+			const obj = assertion.asObject();
+			if (obj === void 0) continue;
+			if (obj.isObscured()) continue;
+			try {
+				const share = obj.extractSubject((cbor$1) => _bcts_components.SSKRShareCbor.fromTaggedCbor(cbor$1));
+				const identifier = share.identifier();
+				const existing = result.get(identifier);
+				if (existing !== void 0) existing.push(share);
+				else result.set(identifier, [share]);
+			} catch {
+				continue;
 			}
 		}
 	}
-	if (typeof cbor$1 === "boolean") return String(cbor$1);
-	if (typeof cbor$1 === "number") return String(cbor$1);
-	if (typeof cbor$1 === "bigint") return String(cbor$1);
-	if (cbor$1 === null) return "null";
-	if (cbor$1 === void 0) return "undefined";
-	try {
-		return JSON.stringify(cbor$1);
+	return result;
+};
+Envelope.sskrJoin = function(envelopes) {
+	if (envelopes.length === 0) throw EnvelopeError.invalidShares();
+	const groupedShares = extractSskrSharesGrouped(envelopes);
+	for (const shares of groupedShares.values()) try {
+		const secret = (0, _bcts_components.sskrCombineShares)(shares);
+		const contentKey = _bcts_components.SymmetricKey.from(secret.getData());
+		return envelopes[0].decryptSubject(contentKey).subject();
 	} catch {
-		return String(cbor$1);
+		continue;
 	}
-}
-Envelope.prototype.diagnostic = function() {
-	return cborToDiagnostic(this.taggedCbor());
+	throw EnvelopeError.invalidShares();
 };
+const registerSskrExtension = () => {};
 
 //#endregion
-//#region src/format/tree.ts
-Envelope.prototype.shortId = function(format = "short") {
-	const digest = this.digest();
-	if (format === "full") return digest.hex();
-	return digest.short();
-};
-Envelope.prototype.summary = function(maxLength = 40) {
-	switch (this.case().type) {
-		case "node": return "NODE";
-		case "leaf": {
-			try {
-				const text = this.asText();
-				if (text !== void 0) {
-					const truncated = text.length > maxLength ? `${text.substring(0, maxLength)}...` : text;
-					return JSON.stringify(truncated);
-				}
-			} catch {}
-			try {
-				const num = this.extractNumber();
-				return String(num);
-			} catch {}
-			try {
-				const bool = this.extractBoolean();
-				return String(bool);
-			} catch {}
-			if (this.isNull()) return "null";
-			const bytes = this.asByteString();
-			if (bytes !== void 0 && bytes.length <= 16) return `h'${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}'`;
-			return "LEAF";
-		}
-		case "wrapped": return "WRAPPED";
-		case "assertion": return "ASSERTION";
-		case "elided": return "ELIDED";
-		case "encrypted": return "ENCRYPTED";
-		case "compressed": return "COMPRESSED";
-		case "knownValue": return "KNOWN_VALUE";
-		default: return "UNKNOWN";
-	}
-};
-Envelope.prototype.treeFormat = function(options = {}) {
-	const hideNodes = options.hideNodes ?? false;
-	const highlightDigests = options.highlightDigests ?? /* @__PURE__ */ new Set();
-	const digestDisplay = options.digestDisplay ?? "short";
+//#region src/extension/request.ts
+/**
+* Request type for distributed function calls.
+*
+* Ported from bc-envelope-rust/src/extension/expressions/request.rs
+*
+* A Request represents a message requesting execution of a function with
+* parameters. Requests are part of the expression system that enables
+* distributed function calls and communication between systems.
+*
+* Each request:
+* - Contains a body (an Expression) that represents the function to be executed
+* - Has a unique identifier (ARID) for tracking and correlation
+* - May include optional metadata like a note and timestamp
+*
+* Requests are designed to be paired with Response objects that contain the
+* results of executing the requested function.
+*
+* When serialized to an envelope, requests are tagged with REQUEST tag.
+*/
+/**
+* A Request represents a message requesting execution of a function with parameters.
+*
+* @example
+* ```typescript
+* import { Request, ARID } from '@bcts/envelope';
+*
+* // Create a random request ID
+* const requestId = ARID.new();
+*
+* // Create a request to execute a function with parameters
+* const request = Request.new("getBalance", requestId)
+*   .withParameter("account", "alice")
+*   .withParameter("currency", "USD")
+*   .withNote("Monthly balance check");
+*
+* // Convert to an envelope
+* const envelope = request.toEnvelope();
+* ```
+*/
+var Request = class Request {
+	#body;
+	#id;
+	#note;
+	#date;
+	constructor(body, id, note = "", date) {
+		this.#body = body;
+		this.#id = id;
+		this.#note = note;
+		this.#date = date;
+	}
+	/**
+	* Creates a new request with the specified expression body and ID.
+	*/
+	static newWithBody(body, id) {
+		return new Request(body, id);
+	}
+	/**
+	* Creates a new request with a function and ID.
+	*
+	* This is a convenience method that creates an expression from the
+	* function and then creates a request with that expression.
+	*/
+	static new(func, id) {
+		const f = typeof func === "string" ? Function.newNamed(func) : typeof func === "number" ? Function.newKnown(func) : func;
+		return Request.newWithBody(new Expression(f), id);
+	}
+	/**
+	* Returns a human-readable summary of the request.
+	*/
+	summary() {
+		return `id: ${this.#id.shortDescription()}, body: ${this.#body.envelope().formatFlat()}`;
+	}
+	withParameter(param, value) {
+		this.#body.withParameter(param, value);
+		return this;
+	}
+	withNote(note) {
+		this.#note = note;
+		return this;
+	}
+	withDate(date) {
+		this.#date = date;
+		return this;
+	}
+	body() {
+		return this.#body;
+	}
+	id() {
+		return this.#id;
+	}
+	note() {
+		return this.#note;
+	}
+	date() {
+		return this.#date;
+	}
+	function() {
+		return this.#body.function();
+	}
+	expressionEnvelope() {
+		return this.#body.envelope();
+	}
+	/**
+	* Converts the request to an envelope.
+	*
+	* The envelope's subject is the request's ID tagged with TAG_REQUEST,
+	* and assertions include the request's body, note (if not empty), and date (if present).
+	*/
+	toEnvelope() {
+		const taggedArid = (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.REQUEST, this.#id.untaggedCbor());
+		let envelope = Envelope.newLeaf(taggedArid).addAssertion(_bcts_known_values.BODY, this.#body.envelope());
+		if (this.#note !== "") envelope = envelope.addAssertion(_bcts_known_values.NOTE, this.#note);
+		if (this.#date !== void 0) envelope = envelope.addAssertion(_bcts_known_values.DATE, this.#date.toISOString());
+		return envelope;
+	}
+	/**
+	* Converts this request into an envelope (EnvelopeEncodable implementation).
+	*/
+	intoEnvelope() {
+		return this.toEnvelope();
+	}
+	/**
+	* Creates a request from an envelope.
+	*/
+	static fromEnvelope(envelope, expectedFunction) {
+		const bodyEnvelope = envelope.objectForPredicate(_bcts_known_values.BODY);
+		if (bodyEnvelope === void 0) throw EnvelopeError.general("Request envelope missing body");
+		const body = Expression.fromEnvelope(bodyEnvelope);
+		if (expectedFunction !== void 0 && !body.function().equals(expectedFunction)) throw EnvelopeError.general("Request function mismatch");
+		const leaf = envelope.subject().asLeaf();
+		if (leaf === void 0) throw EnvelopeError.general("Request envelope has invalid subject");
+		const aridBytes = leaf.expectTag(_bcts_tags.REQUEST).toByteString();
+		const id = _bcts_components.ARID.fromData(aridBytes);
+		let note = "";
+		try {
+			const noteObj = envelope.objectForPredicate(_bcts_known_values.NOTE);
+			if (noteObj !== void 0) note = noteObj.asText() ?? "";
+		} catch {}
+		let date;
+		try {
+			const dateObj = envelope.objectForPredicate(_bcts_known_values.DATE);
+			if (dateObj !== void 0) {
+				const dateStr = dateObj.asText();
+				if (dateStr !== void 0) date = new Date(dateStr);
+			}
+		} catch {}
+		return new Request(body, id, note, date);
+	}
+	/**
+	* Returns a string representation of the request.
+	*/
+	toString() {
+		return `Request(${this.summary()})`;
+	}
+	/**
+	* Checks equality with another request.
+	*/
+	equals(other) {
+		return this.#id.equals(other.#id) && this.#note === other.#note && this.#date?.getTime() === other.#date?.getTime();
+	}
+};
+
+//#endregion
+//#region src/extension/response.ts
+/**
+* Response type for distributed function calls.
+*
+* Ported from bc-envelope-rust/src/extension/expressions/response.rs
+*
+* A Response represents a reply to a Request containing either a
+* successful result or an error.
+*
+* Responses are part of the expression system that enables distributed
+* function calls. Each response contains:
+* - A reference to the original request's ID (ARID) for correlation
+* - Either a successful result or an error message
+*
+* When serialized to an envelope, responses are tagged with RESPONSE tag.
+*/
+/**
+* A Response represents a reply to a Request containing either a
+* successful result or an error.
+*
+* @example
+* ```typescript
+* import { Response, ARID } from '@bcts/envelope';
+*
+* // Create a request ID (normally this would come from the original request)
+* const requestId = ARID.new();
+*
+* // Create a successful response
+* const successResponse = Response.newSuccess(requestId)
+*   .withResult("Transaction completed");
+*
+* // Create an error response
+* const errorResponse = Response.newFailure(requestId)
+*   .withError("Insufficient funds");
+*
+* // Convert to envelopes
+* const successEnvelope = successResponse.toEnvelope();
+* const errorEnvelope = errorResponse.toEnvelope();
+* ```
+*/
+var Response = class Response {
+	#result;
+	constructor(result) {
+		this.#result = result;
+	}
+	/**
+	* Creates a new successful response with the specified request ID.
+	*
+	* By default, the result will be the 'OK' known value. Use `withResult`
+	* to set a specific result value.
+	*/
+	static newSuccess(id) {
+		return new Response({
+			ok: true,
+			id,
+			result: Response.ok()
+		});
+	}
+	/**
+	* Creates a new failure response with the specified request ID.
+	*
+	* By default, the error will be the 'Unknown' known value. Use
+	* `withError` to set a specific error message.
+	*/
+	static newFailure(id) {
+		return new Response({
+			ok: false,
+			id,
+			error: Response.unknown()
+		});
+	}
+	/**
+	* Creates a new early failure response without a request ID.
+	*
+	* An early failure occurs when the error happens before the request
+	* has been fully processed, so the request ID is not known.
+	*/
+	static newEarlyFailure() {
+		return new Response({
+			ok: false,
+			id: void 0,
+			error: Response.unknown()
+		});
+	}
+	/**
+	* Creates an envelope containing the 'Unknown' known value.
+	*/
+	static unknown() {
+		return Envelope.new(_bcts_known_values.UNKNOWN_VALUE);
+	}
+	/**
+	* Creates an envelope containing the 'OK' known value.
+	*/
+	static ok() {
+		return Envelope.new(_bcts_known_values.OK_VALUE);
+	}
+	/**
+	* Returns a human-readable summary of the response.
+	*/
+	summary() {
+		if (this.#result.ok) return `id: ${this.#result.id.shortDescription()}, result: ${this.#result.result.formatFlat()}`;
+		else return `id: ${this.#result.id !== void 0 ? this.#result.id.shortDescription() : "'Unknown'"}, error: ${this.#result.error.formatFlat()}`;
+	}
+	withResult(result) {
+		if (!this.#result.ok) throw new Error("Cannot set result on a failed response");
+		this.#result = {
+			ok: true,
+			id: this.#result.id,
+			result: Envelope.new(result)
+		};
+		return this;
+	}
+	withOptionalResult(result) {
+		if (result !== void 0) return this.withResult(result);
+		return this.withResult(null);
+	}
+	withError(error) {
+		if (this.#result.ok) throw new Error("Cannot set error on a successful response");
+		this.#result = {
+			ok: false,
+			id: this.#result.id,
+			error: Envelope.new(error)
+		};
+		return this;
+	}
+	withOptionalError(error) {
+		if (error !== void 0) return this.withError(error);
+		return this;
+	}
+	isOk() {
+		return this.#result.ok;
+	}
+	isErr() {
+		return !this.#result.ok;
+	}
+	id() {
+		return this.#result.id;
+	}
+	expectId() {
+		const id = this.id();
+		if (id === void 0) throw new Error("Expected an ID");
+		return id;
+	}
+	result() {
+		if (!this.#result.ok) throw EnvelopeError.general("Cannot get result from failed response");
+		return this.#result.result;
+	}
+	error() {
+		if (this.#result.ok) throw EnvelopeError.general("Cannot get error from successful response");
+		return this.#result.error;
+	}
+	/**
+	* Extracts a typed result value from a successful response.
+	*/
+	extractResult(decoder) {
+		return this.result().extractSubject(decoder);
+	}
+	/**
+	* Extracts a typed error value from a failure response.
+	*/
+	extractError(decoder) {
+		return this.error().extractSubject(decoder);
+	}
+	/**
+	* Converts the response to an envelope.
+	*
+	* Successful responses have the request ID as the subject and a 'result'
+	* assertion. Failure responses have the request ID (or 'Unknown' if not known)
+	* as the subject and an 'error' assertion.
+	*/
+	toEnvelope() {
+		if (this.#result.ok) {
+			const taggedArid = (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.RESPONSE, this.#result.id.untaggedCbor());
+			return Envelope.newLeaf(taggedArid).addAssertion(_bcts_known_values.RESULT, this.#result.result);
+		} else {
+			let subject;
+			if (this.#result.id !== void 0) {
+				const taggedArid = (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.RESPONSE, this.#result.id.untaggedCbor());
+				subject = Envelope.newLeaf(taggedArid);
+			} else {
+				const taggedUnknown = (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.RESPONSE, _bcts_known_values.UNKNOWN_VALUE.untaggedCbor());
+				subject = Envelope.newLeaf(taggedUnknown);
+			}
+			return subject.addAssertion(_bcts_known_values.ERROR, this.#result.error);
+		}
+	}
+	/**
+	* Converts this response into an envelope (EnvelopeEncodable implementation).
+	*/
+	intoEnvelope() {
+		return this.toEnvelope();
+	}
+	/**
+	* Creates a response from an envelope.
+	*/
+	static fromEnvelope(envelope) {
+		let hasResult = false;
+		let hasError = false;
+		try {
+			hasResult = envelope.objectForPredicate(_bcts_known_values.RESULT) !== void 0;
+		} catch {}
+		try {
+			hasError = envelope.objectForPredicate(_bcts_known_values.ERROR) !== void 0;
+		} catch {}
+		if (hasResult === hasError) throw EnvelopeError.invalidResponse();
+		const leaf = envelope.subject().asLeaf();
+		if (leaf === void 0) throw EnvelopeError.general("Response envelope has invalid subject");
+		const content = leaf.expectTag(_bcts_tags.RESPONSE);
+		let id;
+		const bytes = content.asByteString();
+		if (bytes !== void 0) id = _bcts_components.ARID.fromData(bytes);
+		if (hasResult) {
+			const resultEnvelope = envelope.objectForPredicate(_bcts_known_values.RESULT);
+			if (id === void 0) throw EnvelopeError.general("Successful response must have an ID");
+			return new Response({
+				ok: true,
+				id,
+				result: resultEnvelope ?? Response.ok()
+			});
+		} else {
+			const errorEnvelope = envelope.objectForPredicate(_bcts_known_values.ERROR);
+			return new Response({
+				ok: false,
+				id,
+				error: errorEnvelope ?? Response.unknown()
+			});
+		}
+	}
+	/**
+	* Returns a string representation of the response.
+	*/
+	toString() {
+		return `Response(${this.summary()})`;
+	}
+	/**
+	* Checks equality with another response.
+	*/
+	equals(other) {
+		if (this.#result.ok !== other.#result.ok) return false;
+		if (this.#result.ok && other.#result.ok) return this.#result.id.equals(other.#result.id);
+		if (!this.#result.ok && !other.#result.ok) {
+			if (this.#result.id === void 0 && other.#result.id === void 0) return true;
+			if (this.#result.id !== void 0 && other.#result.id !== void 0) return this.#result.id.equals(other.#result.id);
+			return false;
+		}
+		return false;
+	}
+};
+
+//#endregion
+//#region src/extension/event.ts
+/**
+* Event type for notifications and messages.
+*
+* Ported from bc-envelope-rust/src/extension/expressions/event.rs
+*
+* An Event represents a notification or message that doesn't expect a
+* response.
+*
+* Unlike Request and Response which form a pair, an Event is a
+* standalone message that can be used for broadcasting information, logging,
+* or publishing notifications. Events are used when the sender does not expect
+* or require a response from the recipients.
+*
+* Each event contains:
+* - Content of a generic type that holds the event payload
+* - A unique identifier (ARID) for tracking and correlation
+* - Optional metadata like a note and timestamp
+*
+* When serialized to an envelope, events are tagged with EVENT tag.
+*/
+/**
+* An Event represents a notification or message that doesn't expect a response.
+*
+* @example
+* ```typescript
+* import { Event, ARID } from '@bcts/envelope';
+*
+* // Create a status update event
+* const eventId = ARID.new();
+* const timestamp = new Date("2024-08-15T13:45:30Z");
+*
+* const statusEvent = Event.new("System online", eventId)
+*   .withNote("Regular status update")
+*   .withDate(timestamp);
+*
+* // Convert to an envelope for transmission
+* const envelope = statusEvent.toEnvelope();
+* ```
+*
+* @typeParam T - The type of content this event carries
+*/
+var Event = class Event {
+	#content;
+	#id;
+	#note;
+	#date;
+	constructor(content, id, note = "", date) {
+		this.#content = content;
+		this.#id = id;
+		this.#note = note;
+		this.#date = date;
+	}
+	/**
+	* Creates a new event with the specified content and ID.
+	*/
+	static new(content, id) {
+		return new Event(content, id);
+	}
+	/**
+	* Returns a human-readable summary of the event.
+	*/
+	summary() {
+		const contentEnvelope = Envelope.new(this.#content);
+		return `id: ${this.#id.shortDescription()}, content: ${contentEnvelope.formatFlat()}`;
+	}
+	withNote(note) {
+		this.#note = note;
+		return this;
+	}
+	withDate(date) {
+		this.#date = date;
+		return this;
+	}
+	content() {
+		return this.#content;
+	}
+	id() {
+		return this.#id;
+	}
+	note() {
+		return this.#note;
+	}
+	date() {
+		return this.#date;
+	}
+	/**
+	* Converts the event to an envelope.
+	*
+	* The envelope's subject is the event's ID tagged with TAG_EVENT,
+	* and assertions include the event's content, note (if not empty), and date
+	* (if present).
+	*/
+	toEnvelope() {
+		const taggedArid = (0, _bcts_dcbor.toTaggedValue)(_bcts_tags.EVENT, this.#id.untaggedCbor());
+		const contentEnvelope = Envelope.new(this.#content);
+		let envelope = Envelope.newLeaf(taggedArid).addAssertion(_bcts_known_values.CONTENT, contentEnvelope);
+		if (this.#note !== "") envelope = envelope.addAssertion(_bcts_known_values.NOTE, this.#note);
+		if (this.#date !== void 0) envelope = envelope.addAssertion(_bcts_known_values.DATE, this.#date.toISOString());
+		return envelope;
+	}
+	/**
+	* Converts this event into an envelope (EnvelopeEncodable implementation).
+	*/
+	intoEnvelope() {
+		return this.toEnvelope();
+	}
+	/**
+	* Creates an event from an envelope.
+	*
+	* @typeParam T - The type to extract the content as
+	*/
+	static fromEnvelope(envelope, contentExtractor) {
+		const contentEnvelope = envelope.objectForPredicate(_bcts_known_values.CONTENT);
+		if (contentEnvelope === void 0) throw EnvelopeError.general("Event envelope missing content");
+		const content = contentExtractor(contentEnvelope);
+		const leaf = envelope.subject().asLeaf();
+		if (leaf === void 0) throw EnvelopeError.general("Event envelope has invalid subject");
+		const aridBytes = leaf.expectTag(_bcts_tags.EVENT).toByteString();
+		const id = _bcts_components.ARID.fromData(aridBytes);
+		let note = "";
+		try {
+			const noteObj = envelope.objectForPredicate(_bcts_known_values.NOTE);
+			if (noteObj !== void 0) note = noteObj.asText() ?? "";
+		} catch {}
+		let date;
+		try {
+			const dateObj = envelope.objectForPredicate(_bcts_known_values.DATE);
+			if (dateObj !== void 0) {
+				const dateStr = dateObj.asText();
+				if (dateStr !== void 0) date = new Date(dateStr);
+			}
+		} catch {}
+		return new Event(content, id, note, date);
+	}
+	/**
+	* Creates a string event from an envelope.
+	*/
+	static stringFromEnvelope(envelope) {
+		return Event.fromEnvelope(envelope, (env) => env.asText() ?? "");
+	}
+	/**
+	* Returns a string representation of the event.
+	*/
+	toString() {
+		return `Event(${this.summary()})`;
+	}
+	/**
+	* Checks equality with another event.
+	*/
+	equals(other) {
+		return this.#id.equals(other.#id) && this.#note === other.#note && this.#date?.getTime() === other.#date?.getTime();
+	}
+};
+
+//#endregion
+//#region src/format/tree.ts
+/**
+* Specifies the format for displaying envelope digests in tree output.
+*
+* Ported from bc-envelope-rust/src/format/tree/format/digest.rs
+*/
+let DigestDisplayFormat = /* @__PURE__ */ function(DigestDisplayFormat$1) {
+	/**
+	* Short format: first 7 hex characters of the digest.
+	* This is the default format.
+	*/
+	DigestDisplayFormat$1["Short"] = "short";
+	/**
+	* Full format: complete 64 hex character digest.
+	*/
+	DigestDisplayFormat$1["Full"] = "full";
+	/**
+	* UR format: digest encoded as a UR string.
+	*/
+	DigestDisplayFormat$1["UR"] = "ur";
+	return DigestDisplayFormat$1;
+}({});
+Envelope.prototype.shortId = function(format = "short") {
+	const digest = this.digest();
+	if (format === "full") return digest.hex();
+	if (format === "ur") return digest.urString();
+	return digest.short();
+};
+Envelope.prototype.summary = function(maxLength = 40) {
+	switch (this.case().type) {
+		case "node": return "NODE";
+		case "leaf": {
+			try {
+				const text = this.asText();
+				if (text !== void 0) {
+					const truncated = text.length > maxLength ? `${text.substring(0, maxLength)}...` : text;
+					return JSON.stringify(truncated);
+				}
+			} catch {}
+			try {
+				const num = this.extractNumber();
+				return String(num);
+			} catch {}
+			try {
+				const bool = this.extractBoolean();
+				return String(bool);
+			} catch {}
+			if (this.isNull()) return "null";
+			const bytes = this.asByteString();
+			if (bytes !== void 0 && bytes.length <= 16) return `h'${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}'`;
+			return "LEAF";
+		}
+		case "wrapped": return "WRAPPED";
+		case "assertion": return "ASSERTION";
+		case "elided": return "ELIDED";
+		case "encrypted": return "ENCRYPTED";
+		case "compressed": return "COMPRESSED";
+		case "knownValue": return "KNOWN_VALUE";
+		default: return "UNKNOWN";
+	}
+};
+Envelope.prototype.treeFormat = function(options = {}) {
+	const hideNodes = options.hideNodes ?? false;
+	const highlightDigests = options.highlightDigests ?? /* @__PURE__ */ new Set();
+	const digestDisplay = options.digestDisplay ?? "short";
 	const elements = [];
 	this.walk(hideNodes, void 0, (envelope, level, incomingEdge, _state) => {
 		const digestStr = envelope.digest().short();
@@ -2540,6 +3557,650 @@ Envelope.prototype.treeFormat = function(options = {}) {
 	}).join("\n");
 };
 
+//#endregion
+//#region src/format/format-context.ts
+const formatContextNone = () => ({ type: "none" });
+const formatContextGlobal = () => ({ type: "global" });
+const formatContextCustom = (context) => ({
+	type: "custom",
+	context
+});
+var FormatContext = class FormatContext {
+	#tags;
+	#knownValues;
+	constructor(tags, knownValues) {
+		this.#tags = tags ?? new _bcts_dcbor.TagsStore();
+		this.#knownValues = knownValues ?? new _bcts_known_values.KnownValuesStore();
+	}
+	tags() {
+		return this.#tags;
+	}
+	knownValues() {
+		return this.#knownValues;
+	}
+	assignedNameForTag(tag) {
+		return this.#tags.assignedNameForTag(tag);
+	}
+	nameForTag(tag) {
+		return this.#tags.nameForTag(tag);
+	}
+	tagForValue(value) {
+		return this.#tags.tagForValue(value);
+	}
+	tagForName(name) {
+		return this.#tags.tagForName(name);
+	}
+	nameForValue(value) {
+		return this.#tags.nameForValue(value);
+	}
+	summarizer(tag) {
+		return this.#tags.summarizer(tag);
+	}
+	registerTag(value, name) {
+		this.#tags.insert({
+			value: BigInt(value),
+			name
+		});
+	}
+	clone() {
+		return new FormatContext(this.#tags, this.#knownValues);
+	}
+};
+let _globalFormatContextInstance;
+let isInitialized = false;
+const getGlobalFormatContext = () => {
+	if (!isInitialized) {
+		(0, _bcts_dcbor.registerTags)();
+		_globalFormatContextInstance = new FormatContext((0, _bcts_dcbor.getGlobalTagsStore)(), _bcts_known_values.KNOWN_VALUES.get());
+		isInitialized = true;
+		setupKnownValueSummarizer(_globalFormatContextInstance);
+	}
+	return _globalFormatContextInstance;
+};
+const withFormatContext = (action) => {
+	return action(getGlobalFormatContext());
+};
+const withFormatContextMut = (action) => {
+	return action(getGlobalFormatContext());
+};
+const setupKnownValueSummarizer = (context) => {
+	const knownValues = context.knownValues();
+	const tags = context.tags();
+	const summarizer = (cbor$1, _flat) => {
+		try {
+			const kv = _bcts_known_values.KnownValue.fromUntaggedCbor(cbor$1);
+			return {
+				ok: true,
+				value: `'${knownValues.name(kv)}'`
+			};
+		} catch {
+			return {
+				ok: true,
+				value: "'<unknown>'"
+			};
+		}
+	};
+	tags.setSummarizer(BigInt(_bcts_known_values.TAG_KNOWN_VALUE), summarizer);
+};
+const registerTagsIn = (context) => {
+	(0, _bcts_dcbor.registerTags)();
+	setupKnownValueSummarizer(context);
+};
+const registerTags = () => {
+	withFormatContextMut((context) => {
+		registerTagsIn(context);
+	});
+};
+const globalFormatContext = getGlobalFormatContext;
+const GLOBAL_FORMAT_CONTEXT = { get: getGlobalFormatContext };
+
+//#endregion
+//#region src/format/envelope-summary.ts
+const flankedBy = (s, prefix, suffix) => {
+	return `${prefix}${s}${suffix}`;
+};
+const cborEnvelopeSummary = (cbor$1, maxLength, context) => {
+	if ((0, _bcts_dcbor.isUnsigned)(cbor$1)) return String(cbor$1);
+	if ((0, _bcts_dcbor.isNegative)(cbor$1)) {
+		const n = cbor$1;
+		return String(-1n - n);
+	}
+	if ((0, _bcts_dcbor.isBytes)(cbor$1)) return `Bytes(${cbor$1.length})`;
+	if ((0, _bcts_dcbor.isText)(cbor$1)) {
+		let text = (0, _bcts_dcbor.asText)(cbor$1) ?? "";
+		if (text.length > maxLength) text = `${text.substring(0, maxLength)}…`;
+		text = text.replace(/\n/g, "\\n");
+		return flankedBy(text, "\"", "\"");
+	}
+	if ((0, _bcts_dcbor.isSimple)(cbor$1)) {
+		const value = cbor$1;
+		if (value === true) return "true";
+		if (value === false) return "false";
+		if (value === null) return "null";
+		if (value === void 0) return "undefined";
+		if (typeof value === "number") {
+			if (Number.isNaN(value)) return "NaN";
+			if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
+			return String(value);
+		}
+		return (0, _bcts_dcbor.diagnosticOpt)(cbor$1, { summarize: true });
+	}
+	if ((0, _bcts_dcbor.isArray)(cbor$1) || (0, _bcts_dcbor.isMap)(cbor$1) || (0, _bcts_dcbor.isTagged)(cbor$1)) {
+		const opts = { summarize: true };
+		if (context.type === "custom") return (0, _bcts_dcbor.diagnosticOpt)(cbor$1, {
+			...opts,
+			tags: context.context.tags()
+		});
+		else if (context.type === "global") {
+			const ctx = getGlobalFormatContext();
+			return (0, _bcts_dcbor.diagnosticOpt)(cbor$1, {
+				...opts,
+				tags: ctx.tags()
+			});
+		} else return (0, _bcts_dcbor.diagnosticOpt)(cbor$1, opts);
+	}
+	return String(cbor$1);
+};
+Envelope.prototype.summaryWithContext = function(maxLength, context) {
+	const c = this.case();
+	switch (c.type) {
+		case "node": return "NODE";
+		case "leaf": return cborEnvelopeSummary(c.cbor, maxLength, {
+			type: "custom",
+			context
+		});
+		case "wrapped": return "WRAPPED";
+		case "assertion": return "ASSERTION";
+		case "elided": return "ELIDED";
+		case "knownValue": return flankedBy(context.knownValues().name(c.value), "'", "'");
+		case "encrypted": return "ENCRYPTED";
+		case "compressed": return "COMPRESSED";
+		default: return "UNKNOWN";
+	}
+};
+
+//#endregion
+//#region src/format/notation.ts
+const defaultFormatOpts = () => ({
+	flat: false,
+	context: formatContextGlobal()
+});
+const flatFormatOpts = () => ({
+	flat: true,
+	context: formatContextGlobal()
+});
+const formatBegin = (value) => ({
+	type: "begin",
+	value
+});
+const formatEnd = (value) => ({
+	type: "end",
+	value
+});
+const formatItem = (value) => ({
+	type: "item",
+	value
+});
+const formatSeparator = () => ({ type: "separator" });
+const formatList = (items) => ({
+	type: "list",
+	items
+});
+const flatten = (item) => {
+	if (item.type === "list") return item.items.flatMap(flatten);
+	return [item];
+};
+const nicen = (items) => {
+	const input = [...items];
+	const result = [];
+	while (input.length > 0) {
+		const current = input.shift();
+		if (input.length === 0) {
+			result.push(current);
+			break;
+		}
+		if (current.type === "end" && input[0]?.type === "begin") {
+			const endString = current.value;
+			const beginString = input[0].value;
+			result.push(formatEnd(`${endString} ${beginString}`));
+			result.push(formatBegin(""));
+			input.shift();
+		} else result.push(current);
+	}
+	return result;
+};
+const indent = (level) => " ".repeat(level * 4);
+const addSpaceAtEndIfNeeded = (s) => {
+	if (s.length === 0) return " ";
+	if (s.endsWith(" ")) return s;
+	return `${s} `;
+};
+const formatFlat = (item) => {
+	let line = "";
+	const items = flatten(item);
+	for (const i of items) switch (i.type) {
+		case "begin":
+			if (!line.endsWith(" ")) line += " ";
+			line += `${i.value} `;
+			break;
+		case "end":
+			if (!line.endsWith(" ")) line += " ";
+			line += `${i.value} `;
+			break;
+		case "item":
+			line += i.value;
+			break;
+		case "separator":
+			line = `${line.trimEnd()}, `;
+			break;
+		case "list":
+			for (const subItem of i.items) line += formatFlat(subItem);
+			break;
+	}
+	return line;
+};
+const formatHierarchical = (item) => {
+	const lines = [];
+	let level = 0;
+	let currentLine = "";
+	const items = nicen(flatten(item));
+	for (const i of items) switch (i.type) {
+		case "begin": {
+			const delimiter = i.value;
+			if (delimiter.length > 0) {
+				const c = currentLine.length === 0 ? delimiter : `${addSpaceAtEndIfNeeded(currentLine)}${delimiter}`;
+				lines.push(`${indent(level)}${c}\n`);
+			}
+			level += 1;
+			currentLine = "";
+			break;
+		}
+		case "end": {
+			const delimiter = i.value;
+			if (currentLine.length > 0) {
+				lines.push(`${indent(level)}${currentLine}\n`);
+				currentLine = "";
+			}
+			level -= 1;
+			lines.push(`${indent(level)}${delimiter}\n`);
+			break;
+		}
+		case "item":
+			currentLine += i.value;
+			break;
+		case "separator":
+			if (currentLine.length > 0) {
+				lines.push(`${indent(level)}${currentLine}\n`);
+				currentLine = "";
+			}
+			break;
+		case "list":
+			lines.push("<list>");
+			break;
+	}
+	if (currentLine.length > 0) lines.push(currentLine);
+	return lines.join("");
+};
+const formatFormatItem = (item, opts) => {
+	if (opts.flat) return formatFlat(item);
+	return formatHierarchical(item);
+};
+const formatCbor = (cbor$1, opts) => {
+	if ((0, _bcts_dcbor.isTagged)(cbor$1)) {
+		const tag = (0, _bcts_dcbor.tagValue)(cbor$1);
+		if (tag === 200n || tag === 200) try {
+			return formatEnvelope(Envelope.fromTaggedCbor(cbor$1), opts);
+		} catch {
+			return formatItem("<error>");
+		}
+	}
+	return formatItem(cborEnvelopeSummary(cbor$1, Number.MAX_SAFE_INTEGER, opts.context));
+};
+const formatAssertion = (assertion, opts) => {
+	return formatList([
+		formatEnvelope(assertion.predicate(), opts),
+		formatItem(": "),
+		formatEnvelope(assertion.object(), opts)
+	]);
+};
+const formatEnvelope = (envelope, opts) => {
+	const c = envelope.case();
+	switch (c.type) {
+		case "leaf": return formatCbor(c.cbor, opts);
+		case "wrapped": return formatList([
+			formatBegin("{"),
+			formatEnvelope(c.envelope, opts),
+			formatEnd("}")
+		]);
+		case "assertion": return formatAssertion(c.assertion, opts);
+		case "knownValue": {
+			let name;
+			if (opts.context.type === "custom") name = opts.context.context.knownValues().assignedName(c.value) ?? c.value.name();
+			else if (opts.context.type === "global") name = getGlobalFormatContext().knownValues().assignedName(c.value) ?? c.value.name();
+			else name = c.value.name();
+			return formatItem(`'${name}'`);
+		}
+		case "encrypted": return formatItem("ENCRYPTED");
+		case "compressed": return formatItem("COMPRESSED");
+		case "elided": return formatItem("ELIDED");
+		case "node": {
+			const items = [];
+			const subjectItem = formatEnvelope(c.subject, opts);
+			let elidedCount = 0;
+			let encryptedCount = 0;
+			let compressedCount = 0;
+			const typeAssertionItems = [];
+			const assertionItems = [];
+			for (const assertion of c.assertions) switch (assertion.case().type) {
+				case "elided":
+					elidedCount += 1;
+					break;
+				case "encrypted":
+					encryptedCount += 1;
+					break;
+				case "compressed":
+					compressedCount += 1;
+					break;
+				case "node":
+				case "leaf":
+				case "wrapped":
+				case "assertion":
+				case "knownValue": {
+					const item = [formatEnvelope(assertion, opts)];
+					let isTypeAssertion = false;
+					if (assertion.asPredicate()?.subject().asKnownValue()?.equals(_bcts_known_values.IS_A) === true) isTypeAssertion = true;
+					if (isTypeAssertion) typeAssertionItems.push(item);
+					else assertionItems.push(item);
+					break;
+				}
+			}
+			typeAssertionItems.sort((a, b) => compareFormatItems(a[0], b[0]));
+			assertionItems.sort((a, b) => compareFormatItems(a[0], b[0]));
+			const allAssertionItems = [...typeAssertionItems, ...assertionItems];
+			if (compressedCount > 1) allAssertionItems.push([formatItem(`COMPRESSED (${compressedCount})`)]);
+			else if (compressedCount > 0) allAssertionItems.push([formatItem("COMPRESSED")]);
+			if (elidedCount > 1) allAssertionItems.push([formatItem(`ELIDED (${elidedCount})`)]);
+			else if (elidedCount > 0) allAssertionItems.push([formatItem("ELIDED")]);
+			if (encryptedCount > 1) allAssertionItems.push([formatItem(`ENCRYPTED (${encryptedCount})`)]);
+			else if (encryptedCount > 0) allAssertionItems.push([formatItem("ENCRYPTED")]);
+			const joinedAssertionItems = [];
+			for (let i = 0; i < allAssertionItems.length; i++) {
+				if (i > 0) joinedAssertionItems.push(formatSeparator());
+				joinedAssertionItems.push(...allAssertionItems[i]);
+			}
+			const needsBraces = c.subject.isSubjectAssertion();
+			if (needsBraces) items.push(formatBegin("{"));
+			items.push(subjectItem);
+			if (needsBraces) items.push(formatEnd("}"));
+			items.push(formatBegin("["));
+			items.push(...joinedAssertionItems);
+			items.push(formatEnd("]"));
+			return formatList(items);
+		}
+	}
+};
+const compareFormatItems = (a, b) => {
+	const getIndex = (item) => {
+		switch (item.type) {
+			case "begin": return 1;
+			case "end": return 2;
+			case "item": return 3;
+			case "separator": return 4;
+			case "list": return 5;
+		}
+	};
+	const aIndex = getIndex(a);
+	const bIndex = getIndex(b);
+	if (aIndex !== bIndex) return aIndex - bIndex;
+	if (a.type === "item" && b.type === "item") return a.value.localeCompare(b.value);
+	if (a.type === "begin" && b.type === "begin") return a.value.localeCompare(b.value);
+	if (a.type === "end" && b.type === "end") return a.value.localeCompare(b.value);
+	return 0;
+};
+Envelope.prototype.formatOpt = function(opts) {
+	return formatFormatItem(formatEnvelope(this, opts), opts).trim();
+};
+Envelope.prototype.format = function() {
+	return this.formatOpt(defaultFormatOpts());
+};
+Envelope.prototype.formatFlat = function() {
+	return this.formatOpt(flatFormatOpts());
+};
+
+//#endregion
+//#region src/format/mermaid.ts
+let MermaidOrientation = /* @__PURE__ */ function(MermaidOrientation$1) {
+	MermaidOrientation$1["LeftToRight"] = "LR";
+	MermaidOrientation$1["TopToBottom"] = "TB";
+	MermaidOrientation$1["RightToLeft"] = "RL";
+	MermaidOrientation$1["BottomToTop"] = "BT";
+	return MermaidOrientation$1;
+}({});
+let MermaidTheme = /* @__PURE__ */ function(MermaidTheme$1) {
+	MermaidTheme$1["Default"] = "default";
+	MermaidTheme$1["Neutral"] = "neutral";
+	MermaidTheme$1["Dark"] = "dark";
+	MermaidTheme$1["Forest"] = "forest";
+	MermaidTheme$1["Base"] = "base";
+	return MermaidTheme$1;
+}({});
+const defaultMermaidOpts = () => ({
+	hideNodes: false,
+	monochrome: false,
+	theme: MermaidTheme.Default,
+	orientation: MermaidOrientation.LeftToRight,
+	highlightingTarget: /* @__PURE__ */ new Set()
+});
+Envelope.prototype.mermaidFormat = function() {
+	return this.mermaidFormatOpt(defaultMermaidOpts());
+};
+Envelope.prototype.mermaidFormatOpt = function(opts) {
+	const hideNodes = opts.hideNodes ?? false;
+	const monochrome = opts.monochrome ?? false;
+	const theme = opts.theme ?? MermaidTheme.Default;
+	const orientation = opts.orientation ?? MermaidOrientation.LeftToRight;
+	const highlightingTarget = opts.highlightingTarget ?? /* @__PURE__ */ new Set();
+	const elements = [];
+	let nextId = 0;
+	const parentStack = [];
+	this.walk(hideNodes, void 0, (envelope, level, incomingEdge, _state) => {
+		const id = nextId++;
+		let parent;
+		while (parentStack.length > 0 && parentStack[parentStack.length - 1].level >= level) parentStack.pop();
+		if (parentStack.length > 0) parent = parentStack[parentStack.length - 1];
+		const isHighlighted = containsDigest(highlightingTarget, envelope.digest());
+		const elem = {
+			id,
+			level,
+			envelope,
+			incomingEdge,
+			showId: !hideNodes,
+			isHighlighted,
+			parent
+		};
+		elements.push(elem);
+		parentStack.push(elem);
+		return [void 0, false];
+	});
+	const formattedIds = /* @__PURE__ */ new Set();
+	const lines = [`%%{ init: { 'theme': '${theme}', 'flowchart': { 'curve': 'basis' } } }%%`, `graph ${orientation}`];
+	const nodeStyles = [];
+	const linkStyles = [];
+	let linkIndex = 0;
+	for (const element of elements) {
+		const indent$1 = "    ".repeat(element.level);
+		let content;
+		if (element.parent !== void 0) {
+			const thisLinkStyles = [];
+			if (!monochrome) {
+				const strokeColor = linkStrokeColor(element.incomingEdge);
+				if (strokeColor !== void 0) thisLinkStyles.push(`stroke:${strokeColor}`);
+			}
+			if (element.isHighlighted && element.parent.isHighlighted) thisLinkStyles.push("stroke-width:4px");
+			else thisLinkStyles.push("stroke-width:2px");
+			if (thisLinkStyles.length > 0) linkStyles.push(`linkStyle ${linkIndex} ${thisLinkStyles.join(",")}`);
+			linkIndex++;
+			content = formatEdge(element, formattedIds);
+		} else content = formatNode(element, formattedIds);
+		const thisNodeStyles = [];
+		if (!monochrome) {
+			const strokeColor = nodeColor(element.envelope);
+			thisNodeStyles.push(`stroke:${strokeColor}`);
+		}
+		if (element.isHighlighted) thisNodeStyles.push("stroke-width:6px");
+		else thisNodeStyles.push("stroke-width:4px");
+		if (thisNodeStyles.length > 0) nodeStyles.push(`style ${element.id} ${thisNodeStyles.join(",")}`);
+		lines.push(`${indent$1}${content}`);
+	}
+	for (const style of nodeStyles) lines.push(style);
+	for (const style of linkStyles) lines.push(style);
+	return lines.join("\n");
+};
+const containsDigest = (set, digest) => {
+	for (const d of set) if (d.equals(digest)) return true;
+	return false;
+};
+const formatNode = (element, formattedIds) => {
+	if (!formattedIds.has(element.id)) {
+		formattedIds.add(element.id);
+		const lines = [];
+		const summary = withFormatContext((ctx) => {
+			return element.envelope.summaryWithContext(20, ctx).replace(/"/g, "&quot;");
+		});
+		lines.push(summary);
+		if (element.showId) {
+			const id = element.envelope.digest().short();
+			lines.push(id);
+		}
+		const content = lines.join("<br>");
+		const [frameL, frameR] = mermaidFrame(element.envelope);
+		return `${element.id}${frameL}"${content}"${frameR}`;
+	} else return `${element.id}`;
+};
+const formatEdge = (element, formattedIds) => {
+	const parent = element.parent;
+	const label = edgeLabel(element.incomingEdge);
+	const arrow = label !== void 0 ? `-- ${label} -->` : "-->";
+	return `${formatNode(parent, formattedIds)} ${arrow} ${formatNode(element, formattedIds)}`;
+};
+const mermaidFrame = (envelope) => {
+	switch (envelope.case().type) {
+		case "node": return ["((", "))"];
+		case "leaf": return ["[", "]"];
+		case "wrapped": return ["[/", "\\]"];
+		case "assertion": return ["([", "])"];
+		case "elided": return ["{{", "}}"];
+		case "knownValue": return ["[/", "/]"];
+		case "encrypted": return [">", "]"];
+		case "compressed": return ["[[", "]]"];
+		default: return ["[", "]"];
+	}
+};
+const nodeColor = (envelope) => {
+	switch (envelope.case().type) {
+		case "node": return "red";
+		case "leaf": return "teal";
+		case "wrapped": return "blue";
+		case "assertion": return "green";
+		case "elided": return "gray";
+		case "knownValue": return "goldenrod";
+		case "encrypted": return "coral";
+		case "compressed": return "purple";
+		default: return "gray";
+	}
+};
+const linkStrokeColor = (edgeType) => {
+	switch (edgeType) {
+		case EdgeType.Subject: return "red";
+		case EdgeType.Content: return "blue";
+		case EdgeType.Predicate: return "cyan";
+		case EdgeType.Object: return "magenta";
+		case EdgeType.None:
+		case EdgeType.Assertion: return;
+	}
+};
+const registerMermaidExtension = () => {};
+
+//#endregion
+//#region src/format/hex.ts
+Envelope.prototype.hex = function() {
+	const bytes = this.cborBytes();
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+Envelope.prototype.cborBytes = function() {
+	return (0, _bcts_dcbor.cborData)(this.taggedCbor());
+};
+
+//#endregion
+//#region src/format/diagnostic.ts
+function cborToDiagnostic(cbor$1, indent$1 = 0) {
+	if (typeof cbor$1 === "object" && cbor$1 !== null && "tag" in cbor$1 && "value" in cbor$1) {
+		const tagged = cbor$1;
+		return `${tagged.tag}(${cborToDiagnostic(tagged.value, indent$1)})`;
+	}
+	if (Array.isArray(cbor$1)) {
+		if (cbor$1.length === 0) return "[]";
+		return `[${cbor$1.map((item) => cborToDiagnostic(item, indent$1 + 2)).join(", ")}]`;
+	}
+	if (cbor$1 instanceof Map) {
+		if (cbor$1.size === 0) return "{}";
+		const entries = [];
+		for (const [key, value] of cbor$1) {
+			const keyStr = cborToDiagnostic(key, indent$1 + 2);
+			const valueStr = cborToDiagnostic(value, indent$1 + 2);
+			entries.push(`${keyStr}: ${valueStr}`);
+		}
+		return `{${entries.join(", ")}}`;
+	}
+	if (cbor$1 instanceof Uint8Array) return `h'${Array.from(cbor$1).map((b) => b.toString(16).padStart(2, "0")).join("")}'`;
+	if (typeof cbor$1 === "string") return JSON.stringify(cbor$1);
+	if (typeof cbor$1 === "object" && cbor$1 !== null && "type" in cbor$1) {
+		const typed = cbor$1;
+		switch (typed.type) {
+			case 0: return String(typed.value);
+			case 1: return String(-1 - Number(typed.value));
+			case 7: {
+				const simpleValue = typed.value;
+				if (simpleValue !== null && typeof simpleValue === "object" && "type" in simpleValue) {
+					const floatValue = simpleValue;
+					if (floatValue.type === "Float") return String(floatValue.value);
+				}
+				if (simpleValue === 20) return "false";
+				if (simpleValue === 21) return "true";
+				if (simpleValue === 22) return "null";
+				if (simpleValue === 23) return "undefined";
+				return `simple(${String(simpleValue)})`;
+			}
+		}
+	}
+	if (typeof cbor$1 === "boolean") return String(cbor$1);
+	if (typeof cbor$1 === "number") return String(cbor$1);
+	if (typeof cbor$1 === "bigint") return String(cbor$1);
+	if (cbor$1 === null) return "null";
+	if (cbor$1 === void 0) return "undefined";
+	try {
+		return JSON.stringify(cbor$1);
+	} catch {
+		return String(cbor$1);
+	}
+}
+Envelope.prototype.diagnostic = function() {
+	return cborToDiagnostic(this.taggedCbor());
+};
+
+//#endregion
+//#region src/seal.ts
+Envelope.prototype.encryptToRecipient = function(recipient) {
+	return this.wrap().encryptSubjectToRecipient(recipient);
+};
+Envelope.prototype.seal = function(sender, recipient) {
+	return this.addSignature(sender).encryptToRecipient(recipient);
+};
+Envelope.prototype.unseal = function(senderPublicKey, recipient) {
+	return this.decryptToRecipient(recipient).verifySignatureFrom(senderPublicKey);
+};
+const registerSealExtension = () => {};
+
 //#endregion
 //#region src/utils/string.ts
 /**
@@ -2576,16 +4237,38 @@ registerCompressExtension();
 const VERSION = "0.37.0";
 
 //#endregion
+exports.ADD = ADD;
+exports.ADD_VALUE = ADD_VALUE;
+exports.AND = AND;
+exports.AND_VALUE = AND_VALUE;
 exports.ATTACHMENT = ATTACHMENT;
 exports.Assertion = Assertion;
 exports.Attachments = Attachments;
+exports.BLANK = BLANK;
+exports.BLANK_VALUE = BLANK_VALUE;
 exports.CBOR_TAG_FUNCTION = CBOR_TAG_FUNCTION;
 exports.CBOR_TAG_PARAMETER = CBOR_TAG_PARAMETER;
 exports.CBOR_TAG_PLACEHOLDER = CBOR_TAG_PLACEHOLDER;
 exports.CBOR_TAG_REPLACEMENT = CBOR_TAG_REPLACEMENT;
 exports.CONFORMS_TO = CONFORMS_TO;
+Object.defineProperty(exports, 'ComponentsSealedMessage', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.SealedMessage;
+  }
+});
 exports.Compressed = Compressed;
-exports.Digest = Digest;
+exports.DIV = DIV;
+exports.DIV_VALUE = DIV_VALUE;
+Object.defineProperty(exports, 'Digest', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.Digest;
+  }
+});
+exports.DigestDisplayFormat = DigestDisplayFormat;
+exports.EQ = EQ;
+exports.EQ_VALUE = EQ_VALUE;
 exports.EdgeType = EdgeType;
 exports.EncryptedMessage = EncryptedMessage;
 exports.Envelope = Envelope;
@@ -2595,35 +4278,112 @@ exports.EnvelopeCBORTaggedEncodable = EnvelopeCBORTaggedEncodable;
 exports.EnvelopeDecoder = EnvelopeDecoder;
 exports.EnvelopeError = EnvelopeError;
 exports.ErrorCode = ErrorCode;
+exports.Event = Event;
 exports.Expression = Expression;
 exports.FUNCTION_IDS = FUNCTION_IDS;
+exports.FormatContext = FormatContext;
 exports.Function = Function;
+exports.FunctionsStore = FunctionsStore;
+exports.GE = GE;
+exports.GE_VALUE = GE_VALUE;
+exports.GLOBAL_FORMAT_CONTEXT = GLOBAL_FORMAT_CONTEXT;
+exports.GLOBAL_FUNCTIONS = GLOBAL_FUNCTIONS;
+exports.GLOBAL_PARAMETERS = GLOBAL_PARAMETERS;
+exports.GT = GT;
+exports.GT_VALUE = GT_VALUE;
 exports.HAS_RECIPIENT = HAS_RECIPIENT;
-exports.IS_A = IS_A;
+Object.defineProperty(exports, 'IS_A', {
+  enumerable: true,
+  get: function () {
+    return _bcts_known_values.IS_A;
+  }
+});
+exports.LE = LE;
+exports.LE_VALUE = LE_VALUE;
+exports.LHS = LHS;
+exports.LHS_VALUE = LHS_VALUE;
+exports.LT = LT;
+exports.LT_VALUE = LT_VALUE;
+exports.LazyStore = LazyStore;
+exports.MUL = MUL;
+exports.MUL_VALUE = MUL_VALUE;
+exports.MermaidOrientation = MermaidOrientation;
+exports.MermaidTheme = MermaidTheme;
+exports.NE = NE;
+exports.NEG = NEG;
+exports.NEG_VALUE = NEG_VALUE;
+exports.NE_VALUE = NE_VALUE;
+exports.NOT = NOT;
 exports.NOTE = NOTE;
+exports.NOT_VALUE = NOT_VALUE;
+exports.OR = OR;
+exports.OR_VALUE = OR_VALUE;
 exports.ObscureType = ObscureType;
 exports.PARAMETER_IDS = PARAMETER_IDS;
 exports.Parameter = Parameter;
-exports.PrivateKeyBase = PrivateKeyBase;
-exports.PublicKeyBase = PublicKeyBase;
+exports.ParametersStore = ParametersStore;
+Object.defineProperty(exports, 'PrivateKeyBase', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.PrivateKeys;
+  }
+});
+Object.defineProperty(exports, 'PublicKeyBase', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.EncapsulationPublicKey;
+  }
+});
+exports.RHS = RHS;
+exports.RHS_VALUE = RHS_VALUE;
+exports.Request = Request;
+exports.Response = Response;
 exports.SALT = SALT;
 exports.SIGNED = SIGNED;
+exports.SUB = SUB;
+exports.SUB_VALUE = SUB_VALUE;
 exports.SealedMessage = SealedMessage;
-exports.Signature = Signature;
+Object.defineProperty(exports, 'Signature', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.Signature;
+  }
+});
 exports.SignatureMetadata = SignatureMetadata;
-exports.SigningPrivateKey = SigningPrivateKey;
-exports.SigningPublicKey = SigningPublicKey;
-exports.SymmetricKey = SymmetricKey;
+Object.defineProperty(exports, 'SigningPrivateKey', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.SigningPrivateKey;
+  }
+});
+Object.defineProperty(exports, 'SigningPublicKey', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.SigningPublicKey;
+  }
+});
+Object.defineProperty(exports, 'SymmetricKey', {
+  enumerable: true,
+  get: function () {
+    return _bcts_components.SymmetricKey;
+  }
+});
 exports.VENDOR = VENDOR;
 exports.VERIFIED_BY = VERIFIED_BY;
 exports.VERSION = VERSION;
+exports.XOR = XOR;
+exports.XOR_VALUE = XOR_VALUE;
 exports.add = add;
 exports.and = and;
+exports.cborEnvelopeSummary = cborEnvelopeSummary;
+exports.defaultFormatOpts = defaultFormatOpts;
+exports.defaultMermaidOpts = defaultMermaidOpts;
 exports.div = div;
 exports.edgeLabel = edgeLabel;
 exports.elideAction = elideAction;
 exports.envelopeFromBytes = envelopeFromBytes;
 exports.envelopeFromCbor = envelopeFromCbor;
+exports.envelopeSummary = cborEnvelopeSummary;
 exports.envelopeToBytes = envelopeToBytes;
 exports.envelopeToCbor = envelopeToCbor;
 exports.eq = eq;
@@ -2631,16 +4391,49 @@ exports.extractBoolean = extractBoolean;
 exports.extractBytes = extractBytes;
 exports.extractNull = extractNull;
 exports.extractNumber = extractNumber;
+exports.extractObjectForPredicateWithDefault = extractObjectForPredicateWithDefault;
+exports.extractObjectsForPredicate = extractObjectsForPredicate;
 exports.extractString = extractString;
+exports.extractSubject = extractSubject;
 exports.flanked = flanked;
+exports.flatFormatOpts = flatFormatOpts;
+exports.formatAssertion = formatAssertion;
+exports.formatBegin = formatBegin;
+exports.formatCbor = formatCbor;
+exports.formatContextCustom = formatContextCustom;
+exports.formatContextGlobal = formatContextGlobal;
+exports.formatContextNone = formatContextNone;
+exports.formatEnd = formatEnd;
+exports.formatEnvelope = formatEnvelope;
+exports.formatItem = formatItem;
+exports.formatList = formatList;
+exports.formatSeparator = formatSeparator;
+exports.ge = ge;
+exports.getGlobalFormatContext = getGlobalFormatContext;
+exports.globalFormatContext = globalFormatContext;
 exports.gt = gt;
 exports.isEnvelopeEncodable = isEnvelopeEncodable;
+exports.le = le;
 exports.lt = lt;
 exports.mul = mul;
+exports.ne = ne;
 exports.neg = neg;
 exports.not = not;
 exports.or = or;
 exports.registerCompressExtension = registerCompressExtension;
 exports.registerEncryptExtension = registerEncryptExtension;
+exports.registerMermaidExtension = registerMermaidExtension;
+exports.registerProofExtension = registerProofExtension;
+exports.registerSealExtension = registerSealExtension;
+exports.registerSecretExtension = registerSecretExtension;
+exports.registerSskrExtension = registerSskrExtension;
+exports.registerTags = registerTags;
+exports.registerTagsIn = registerTagsIn;
 exports.sub = sub;
+exports.tryObjectForPredicate = tryObjectForPredicate;
+exports.tryObjectsForPredicate = tryObjectsForPredicate;
+exports.tryOptionalObjectForPredicate = tryOptionalObjectForPredicate;
+exports.withFormatContext = withFormatContext;
+exports.withFormatContextMut = withFormatContextMut;
+exports.xor = xor;
 //# sourceMappingURL=index.cjs.map