@bcts/envelope 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,2552 @@
+import { ECDSA_PRIVATE_KEY_SIZE, ECDSA_PUBLIC_KEY_SIZE, ECDSA_UNCOMPRESSED_PUBLIC_KEY_SIZE, SYMMETRIC_AUTH_SIZE, SYMMETRIC_KEY_SIZE, SYMMETRIC_NONCE_SIZE, X25519_PRIVATE_KEY_SIZE, X25519_PUBLIC_KEY_SIZE, aeadChaCha20Poly1305DecryptWithAad, aeadChaCha20Poly1305EncryptWithAad, ecdsaPublicKeyFromPrivateKey, ecdsaSign, ecdsaVerify, hkdfHmacSha256, sha256, x25519NewPrivateKeyUsing, x25519PublicKeyFromPrivateKey, x25519SharedKey } from "@bcts/crypto";
+import { CborMap, MajorType, TAG_ENCODED_CBOR, asArray, asByteString, asCborArray, asCborMap, asMap, asTaggedValue, asText, cbor, cborData, decodeCbor, isNaN, isNull, isNumber, tagsForValues, toTaggedValue, tryExpectedTaggedValue, tryIntoBool, tryIntoByteString, tryIntoText } from "@bcts/dcbor";
+import { KnownValue } from "@bcts/known-values";
+import { COMPRESSED, ENCRYPTED, ENVELOPE, LEAF } from "@bcts/components";
+import * as pako from "pako";
+import { SecureRandomNumberGenerator, rngNextInClosedRangeI32, rngRandomData } from "@bcts/rand";
+
+//#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(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));
+	}
+};
+
+//#endregion
+//#region src/base/error.ts
+let ErrorCode = /* @__PURE__ */ function(ErrorCode$1) {
+	ErrorCode$1["ALREADY_ELIDED"] = "ALREADY_ELIDED";
+	ErrorCode$1["AMBIGUOUS_PREDICATE"] = "AMBIGUOUS_PREDICATE";
+	ErrorCode$1["INVALID_DIGEST"] = "INVALID_DIGEST";
+	ErrorCode$1["INVALID_FORMAT"] = "INVALID_FORMAT";
+	ErrorCode$1["MISSING_DIGEST"] = "MISSING_DIGEST";
+	ErrorCode$1["NONEXISTENT_PREDICATE"] = "NONEXISTENT_PREDICATE";
+	ErrorCode$1["NOT_WRAPPED"] = "NOT_WRAPPED";
+	ErrorCode$1["NOT_LEAF"] = "NOT_LEAF";
+	ErrorCode$1["NOT_ASSERTION"] = "NOT_ASSERTION";
+	ErrorCode$1["INVALID_ASSERTION"] = "INVALID_ASSERTION";
+	ErrorCode$1["INVALID_ATTACHMENT"] = "INVALID_ATTACHMENT";
+	ErrorCode$1["NONEXISTENT_ATTACHMENT"] = "NONEXISTENT_ATTACHMENT";
+	ErrorCode$1["AMBIGUOUS_ATTACHMENT"] = "AMBIGUOUS_ATTACHMENT";
+	ErrorCode$1["ALREADY_COMPRESSED"] = "ALREADY_COMPRESSED";
+	ErrorCode$1["NOT_COMPRESSED"] = "NOT_COMPRESSED";
+	ErrorCode$1["ALREADY_ENCRYPTED"] = "ALREADY_ENCRYPTED";
+	ErrorCode$1["NOT_ENCRYPTED"] = "NOT_ENCRYPTED";
+	ErrorCode$1["NOT_KNOWN_VALUE"] = "NOT_KNOWN_VALUE";
+	ErrorCode$1["UNKNOWN_RECIPIENT"] = "UNKNOWN_RECIPIENT";
+	ErrorCode$1["UNKNOWN_SECRET"] = "UNKNOWN_SECRET";
+	ErrorCode$1["UNVERIFIED_SIGNATURE"] = "UNVERIFIED_SIGNATURE";
+	ErrorCode$1["INVALID_OUTER_SIGNATURE_TYPE"] = "INVALID_OUTER_SIGNATURE_TYPE";
+	ErrorCode$1["INVALID_INNER_SIGNATURE_TYPE"] = "INVALID_INNER_SIGNATURE_TYPE";
+	ErrorCode$1["UNVERIFIED_INNER_SIGNATURE"] = "UNVERIFIED_INNER_SIGNATURE";
+	ErrorCode$1["INVALID_SIGNATURE_TYPE"] = "INVALID_SIGNATURE_TYPE";
+	ErrorCode$1["INVALID_SHARES"] = "INVALID_SHARES";
+	ErrorCode$1["SSKR"] = "SSKR";
+	ErrorCode$1["INVALID_TYPE"] = "INVALID_TYPE";
+	ErrorCode$1["AMBIGUOUS_TYPE"] = "AMBIGUOUS_TYPE";
+	ErrorCode$1["UNEXPECTED_RESPONSE_ID"] = "UNEXPECTED_RESPONSE_ID";
+	ErrorCode$1["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+	ErrorCode$1["CBOR"] = "CBOR";
+	ErrorCode$1["COMPONENTS"] = "COMPONENTS";
+	ErrorCode$1["GENERAL"] = "GENERAL";
+	return ErrorCode$1;
+}({});
+var EnvelopeError = class EnvelopeError extends Error {
+	code;
+	constructor(code, message, cause) {
+		super(message);
+		this.name = "EnvelopeError";
+		this.code = code;
+		if (cause !== void 0) this.cause = cause;
+		if ("captureStackTrace" in Error) Error.captureStackTrace(this, EnvelopeError);
+	}
+	static alreadyElided() {
+		return new EnvelopeError(ErrorCode.ALREADY_ELIDED, "envelope was elided, so it cannot be compressed or encrypted");
+	}
+	static ambiguousPredicate() {
+		return new EnvelopeError(ErrorCode.AMBIGUOUS_PREDICATE, "more than one assertion matches the predicate");
+	}
+	static invalidDigest() {
+		return new EnvelopeError(ErrorCode.INVALID_DIGEST, "digest did not match");
+	}
+	static invalidFormat() {
+		return new EnvelopeError(ErrorCode.INVALID_FORMAT, "invalid format");
+	}
+	static missingDigest() {
+		return new EnvelopeError(ErrorCode.MISSING_DIGEST, "a digest was expected but not found");
+	}
+	static nonexistentPredicate() {
+		return new EnvelopeError(ErrorCode.NONEXISTENT_PREDICATE, "no assertion matches the predicate");
+	}
+	static notWrapped() {
+		return new EnvelopeError(ErrorCode.NOT_WRAPPED, "cannot unwrap an envelope that was not wrapped");
+	}
+	static notLeaf() {
+		return new EnvelopeError(ErrorCode.NOT_LEAF, "the envelope's subject is not a leaf");
+	}
+	static notAssertion() {
+		return new EnvelopeError(ErrorCode.NOT_ASSERTION, "the envelope's subject is not an assertion");
+	}
+	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 nonexistentAttachment() {
+		return new EnvelopeError(ErrorCode.NONEXISTENT_ATTACHMENT, "nonexistent attachment");
+	}
+	static ambiguousAttachment() {
+		return new EnvelopeError(ErrorCode.AMBIGUOUS_ATTACHMENT, "ambiguous attachment");
+	}
+	static alreadyCompressed() {
+		return new EnvelopeError(ErrorCode.ALREADY_COMPRESSED, "envelope was already compressed");
+	}
+	static notCompressed() {
+		return new EnvelopeError(ErrorCode.NOT_COMPRESSED, "cannot decompress an envelope that was not compressed");
+	}
+	static alreadyEncrypted() {
+		return new EnvelopeError(ErrorCode.ALREADY_ENCRYPTED, "envelope was already encrypted or compressed, so it cannot be encrypted");
+	}
+	static notEncrypted() {
+		return new EnvelopeError(ErrorCode.NOT_ENCRYPTED, "cannot decrypt an envelope that was not encrypted");
+	}
+	static notKnownValue() {
+		return new EnvelopeError(ErrorCode.NOT_KNOWN_VALUE, "the envelope's subject is not a known value");
+	}
+	static unknownRecipient() {
+		return new EnvelopeError(ErrorCode.UNKNOWN_RECIPIENT, "unknown recipient");
+	}
+	static unknownSecret() {
+		return new EnvelopeError(ErrorCode.UNKNOWN_SECRET, "secret not found");
+	}
+	static unverifiedSignature() {
+		return new EnvelopeError(ErrorCode.UNVERIFIED_SIGNATURE, "could not verify a signature");
+	}
+	static invalidOuterSignatureType() {
+		return new EnvelopeError(ErrorCode.INVALID_OUTER_SIGNATURE_TYPE, "unexpected outer signature object type");
+	}
+	static invalidInnerSignatureType() {
+		return new EnvelopeError(ErrorCode.INVALID_INNER_SIGNATURE_TYPE, "unexpected inner signature object type");
+	}
+	static unverifiedInnerSignature() {
+		return new EnvelopeError(ErrorCode.UNVERIFIED_INNER_SIGNATURE, "inner signature not made with same key as outer signature");
+	}
+	static invalidSignatureType() {
+		return new EnvelopeError(ErrorCode.INVALID_SIGNATURE_TYPE, "unexpected signature object type");
+	}
+	static invalidShares() {
+		return new EnvelopeError(ErrorCode.INVALID_SHARES, "invalid SSKR shares");
+	}
+	static sskr(message, cause) {
+		return new EnvelopeError(ErrorCode.SSKR, `sskr error: ${message}`, cause);
+	}
+	static invalidType() {
+		return new EnvelopeError(ErrorCode.INVALID_TYPE, "invalid type");
+	}
+	static ambiguousType() {
+		return new EnvelopeError(ErrorCode.AMBIGUOUS_TYPE, "ambiguous type");
+	}
+	static unexpectedResponseId() {
+		return new EnvelopeError(ErrorCode.UNEXPECTED_RESPONSE_ID, "unexpected response ID");
+	}
+	static invalidResponse() {
+		return new EnvelopeError(ErrorCode.INVALID_RESPONSE, "invalid response");
+	}
+	static cbor(message, cause) {
+		return new EnvelopeError(ErrorCode.CBOR, `dcbor error: ${message}`, cause);
+	}
+	static components(message, cause) {
+		return new EnvelopeError(ErrorCode.COMPONENTS, `components error: ${message}`, cause);
+	}
+	static general(message, cause) {
+		return new EnvelopeError(ErrorCode.GENERAL, `general error: ${message}`, cause);
+	}
+	static msg(message) {
+		return EnvelopeError.general(message);
+	}
+};
+
+//#endregion
+//#region src/base/assertion.ts
+var Assertion = class Assertion {
+	#predicate;
+	#object;
+	#digest;
+	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()]);
+	}
+	predicate() {
+		return this.#predicate;
+	}
+	object() {
+		return this.#object;
+	}
+	digest() {
+		return this.#digest;
+	}
+	equals(other) {
+		return this.#digest.equals(other.#digest);
+	}
+	toCbor() {
+		const map = new CborMap();
+		map.set(this.#predicate.untaggedCbor(), this.#object.untaggedCbor());
+		return map;
+	}
+	static fromCbor(cbor$1) {
+		if (!(cbor$1 instanceof CborMap)) throw EnvelopeError.invalidAssertion();
+		return Assertion.fromCborMap(cbor$1);
+	}
+	static fromCborMap(map) {
+		if (map.size !== 1) throw EnvelopeError.invalidAssertion();
+		const firstEntry = Array.from(map.entries())[0];
+		if (firstEntry === void 0) throw EnvelopeError.invalidAssertion();
+		const [predicateCbor, objectCbor] = firstEntry;
+		return new Assertion(Envelope.fromUntaggedCbor(predicateCbor), Envelope.fromUntaggedCbor(objectCbor));
+	}
+	toString() {
+		return `Assertion(${String(this.#predicate)}: ${String(this.#object)})`;
+	}
+	clone() {
+		return this;
+	}
+};
+
+//#endregion
+//#region src/extension/compress.ts
+var Compressed = class Compressed {
+	#compressedData;
+	#digest;
+	constructor(compressedData, digest) {
+		this.#compressedData = compressedData;
+		if (digest !== void 0) this.#digest = digest;
+	}
+	static fromDecompressedData(decompressedData, digest) {
+		return new Compressed(pako.deflate(decompressedData), digest);
+	}
+	compressedData() {
+		return this.#compressedData;
+	}
+	digestOpt() {
+		return this.#digest;
+	}
+	decompress() {
+		return pako.inflate(this.#compressedData);
+	}
+};
+function registerCompressExtension() {
+	if (Envelope?.prototype === void 0) return;
+	if (typeof Envelope.prototype.compress === "function") return;
+	Envelope.prototype.compress = function() {
+		const c = this.case();
+		if (c.type === "compressed") return this;
+		if (c.type === "encrypted") throw EnvelopeError.general("Cannot compress encrypted envelope");
+		if (c.type === "elided") throw EnvelopeError.general("Cannot compress elided envelope");
+		const decompressedData = cborData(this.taggedCbor());
+		const compressed = Compressed.fromDecompressedData(decompressedData, this.digest());
+		return Envelope.fromCase({
+			type: "compressed",
+			value: compressed
+		});
+	};
+	Envelope.prototype.decompress = function() {
+		const c = this.case();
+		if (c.type !== "compressed") throw EnvelopeError.general("Envelope is not compressed");
+		const compressed = c.value;
+		const digest = compressed.digestOpt();
+		if (digest === void 0) throw EnvelopeError.general("Missing digest in compressed envelope");
+		if (!digest.equals(this.digest())) throw EnvelopeError.general("Invalid digest in compressed envelope");
+		const cbor$1 = decodeCbor(compressed.decompress());
+		const envelope = Envelope.fromTaggedCbor(cbor$1);
+		if (!envelope.digest().equals(digest)) throw EnvelopeError.general("Invalid digest after decompression");
+		return envelope;
+	};
+	Envelope.prototype.compressSubject = function() {
+		if (this.subject().isCompressed()) return this;
+		const subject = this.subject().compress();
+		return this.replaceSubject(subject);
+	};
+	Envelope.prototype.decompressSubject = function() {
+		if (this.subject().isCompressed()) {
+			const subject = this.subject().decompress();
+			return this.replaceSubject(subject);
+		}
+		return this;
+	};
+	Envelope.prototype.isCompressed = function() {
+		return this.case().type === "compressed";
+	};
+}
+registerCompressExtension();
+
+//#endregion
+//#region src/extension/encrypt.ts
+function createSecureRng$1() {
+	return new SecureRandomNumberGenerator();
+}
+var SymmetricKey = class SymmetricKey {
+	#key;
+	constructor(key) {
+		if (key.length !== SYMMETRIC_KEY_SIZE) throw new Error(`Symmetric key must be ${SYMMETRIC_KEY_SIZE} bytes`);
+		this.#key = key;
+	}
+	static generate() {
+		return new SymmetricKey(rngRandomData(createSecureRng$1(), SYMMETRIC_KEY_SIZE));
+	}
+	static from(key) {
+		return new SymmetricKey(key);
+	}
+	data() {
+		return this.#key;
+	}
+	encrypt(plaintext, digest) {
+		const nonce = rngRandomData(createSecureRng$1(), SYMMETRIC_NONCE_SIZE);
+		const aad = digest.data();
+		const [ciphertext, authTag] = 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 aeadChaCha20Poly1305DecryptWithAad(message.ciphertext(), this.#key, message.nonce(), aad, message.authTag());
+		} catch (_error) {
+			throw EnvelopeError.general("Decryption failed: invalid key or corrupted data");
+		}
+	}
+};
+var EncryptedMessage = class {
+	#ciphertext;
+	#nonce;
+	#authTag;
+	#aadDigest;
+	constructor(ciphertext, nonce, authTag, aadDigest) {
+		this.#ciphertext = ciphertext;
+		this.#nonce = nonce;
+		this.#authTag = authTag;
+		if (aadDigest !== void 0) this.#aadDigest = aadDigest;
+	}
+	ciphertext() {
+		return this.#ciphertext;
+	}
+	nonce() {
+		return this.#nonce;
+	}
+	authTag() {
+		return this.#authTag;
+	}
+	aadDigest() {
+		return this.#aadDigest;
+	}
+	digest() {
+		if (this.#aadDigest === void 0) throw new Error("Encrypted message missing AAD digest");
+		return this.#aadDigest;
+	}
+};
+function registerEncryptExtension() {
+	if (Envelope?.prototype === void 0) return;
+	if (typeof Envelope.prototype.encryptSubject === "function") return;
+	Envelope.prototype.encryptSubject = function(key) {
+		const c = this.case();
+		if (c.type === "encrypted") throw EnvelopeError.general("Envelope is already encrypted");
+		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 = cborData(c.subject.taggedCbor());
+			const subjectDigest = c.subject.digest();
+			const encryptedMessage$1 = key.encrypt(encodedCbor$1, subjectDigest);
+			const encryptedSubject = Envelope.fromCase({
+				type: "encrypted",
+				message: encryptedMessage$1
+			});
+			return Envelope.newWithAssertions(encryptedSubject, c.assertions);
+		}
+		const encodedCbor = cborData(this.taggedCbor());
+		const digest = this.digest();
+		const encryptedMessage = key.encrypt(encodedCbor, digest);
+		return Envelope.fromCase({
+			type: "encrypted",
+			message: encryptedMessage
+		});
+	};
+	Envelope.prototype.decryptSubject = function(key) {
+		const subjectCase = this.subject().case();
+		if (subjectCase.type !== "encrypted") throw EnvelopeError.general("Subject is not encrypted");
+		const message = subjectCase.message;
+		const subjectDigest = message.aadDigest();
+		if (subjectDigest === void 0) throw EnvelopeError.general("Missing digest in encrypted message");
+		const cbor$1 = decodeCbor(key.decrypt(message));
+		const resultSubject = Envelope.fromTaggedCbor(cbor$1);
+		if (!resultSubject.digest().equals(subjectDigest)) throw EnvelopeError.general("Invalid digest after decryption");
+		const c = this.case();
+		if (c.type === "node") {
+			const result = Envelope.newWithAssertions(resultSubject, c.assertions);
+			if (!result.digest().equals(c.digest)) throw EnvelopeError.general("Invalid envelope digest after decryption");
+			return result;
+		}
+		return resultSubject;
+	};
+	Envelope.prototype.encrypt = function(key) {
+		return this.wrap().encryptSubject(key);
+	};
+	Envelope.prototype.decrypt = function(key) {
+		return this.decryptSubject(key).unwrap();
+	};
+	Envelope.prototype.isEncrypted = function() {
+		return this.case().type === "encrypted";
+	};
+}
+registerEncryptExtension();
+
+//#endregion
+//#region src/base/envelope.ts
+const TAG_ENVELOPE$1 = ENVELOPE.value;
+const TAG_LEAF = LEAF.value;
+const TAG_ENCRYPTED = ENCRYPTED.value;
+const TAG_COMPRESSED = COMPRESSED.value;
+var Envelope = class Envelope {
+	#case;
+	constructor(envelopeCase) {
+		this.#case = envelopeCase;
+	}
+	case() {
+		return this.#case;
+	}
+	static new(subject) {
+		if (subject instanceof Envelope) return subject;
+		return Envelope.newLeaf(subject);
+	}
+	static newOrNull(subject) {
+		if (subject === void 0 || subject === null) return Envelope.null();
+		return Envelope.new(subject);
+	}
+	static newOrNone(subject) {
+		if (subject === void 0 || subject === null) return;
+		return Envelope.new(subject);
+	}
+	static fromCase(envelopeCase) {
+		return new Envelope(envelopeCase);
+	}
+	static newAssertion(predicate, object) {
+		const predicateEnv = predicate instanceof Envelope ? predicate : Envelope.new(predicate);
+		const objectEnv = object instanceof Envelope ? object : Envelope.new(object);
+		return Envelope.newWithAssertion(new Assertion(predicateEnv, objectEnv));
+	}
+	static null() {
+		return Envelope.newLeaf(null);
+	}
+	static newWithUncheckedAssertions(subject, uncheckedAssertions) {
+		if (uncheckedAssertions.length === 0) throw new Error("Assertions array cannot be empty");
+		const sortedAssertions = [...uncheckedAssertions].sort((a, b) => {
+			const aHex = a.digest().hex();
+			const bHex = b.digest().hex();
+			return aHex.localeCompare(bHex);
+		});
+		const digests = [subject.digest(), ...sortedAssertions.map((a) => a.digest())];
+		return new Envelope({
+			type: "node",
+			subject,
+			assertions: sortedAssertions,
+			digest: Digest.fromDigests(digests)
+		});
+	}
+	static newWithAssertions(subject, assertions) {
+		for (const assertion of assertions) if (!assertion.isSubjectAssertion() && !assertion.isSubjectObscured()) throw EnvelopeError.invalidFormat();
+		return Envelope.newWithUncheckedAssertions(subject, assertions);
+	}
+	static newWithAssertion(assertion) {
+		return new Envelope({
+			type: "assertion",
+			assertion
+		});
+	}
+	static newWithKnownValue(value) {
+		const knownValue = value instanceof KnownValue ? value : new KnownValue(value);
+		return new Envelope({
+			type: "knownValue",
+			value: knownValue,
+			digest: Digest.fromImage(knownValue.toCborData())
+		});
+	}
+	static newWithEncrypted(encryptedMessage) {
+		return new Envelope({
+			type: "encrypted",
+			message: encryptedMessage
+		});
+	}
+	static newWithCompressed(compressed) {
+		return new Envelope({
+			type: "compressed",
+			value: compressed
+		});
+	}
+	static newElided(digest) {
+		return new Envelope({
+			type: "elided",
+			digest
+		});
+	}
+	static newLeaf(value) {
+		const cbor$1 = Envelope.valueToCbor(value);
+		const cborBytes = Envelope.cborToBytes(cbor$1);
+		return new Envelope({
+			type: "leaf",
+			cbor: cbor$1,
+			digest: Digest.fromImage(cborBytes)
+		});
+	}
+	static newWrapped(envelope) {
+		return new Envelope({
+			type: "wrapped",
+			envelope,
+			digest: Digest.fromDigests([envelope.digest()])
+		});
+	}
+	digest() {
+		const c = this.#case;
+		switch (c.type) {
+			case "node":
+			case "leaf":
+			case "wrapped":
+			case "elided":
+			case "knownValue": return c.digest;
+			case "assertion": return c.assertion.digest();
+			case "encrypted": {
+				const digest = c.message.aadDigest();
+				if (digest === void 0) throw new Error("Encrypted envelope missing digest");
+				return digest;
+			}
+			case "compressed": {
+				const digest = c.value.digestOpt();
+				if (digest === void 0) throw new Error("Compressed envelope missing digest");
+				return digest;
+			}
+		}
+	}
+	subject() {
+		const c = this.#case;
+		switch (c.type) {
+			case "node": return c.subject;
+			case "leaf":
+			case "wrapped":
+			case "assertion":
+			case "elided":
+			case "knownValue":
+			case "encrypted":
+			case "compressed": return this;
+		}
+	}
+	isSubjectAssertion() {
+		return this.#case.type === "assertion";
+	}
+	isSubjectObscured() {
+		const t = this.#case.type;
+		return t === "elided" || t === "encrypted" || t === "compressed";
+	}
+	static valueToCbor(value) {
+		return cbor(value);
+	}
+	static cborToBytes(cbor$1) {
+		return cborData(cbor$1);
+	}
+	untaggedCbor() {
+		const c = this.#case;
+		switch (c.type) {
+			case "node": {
+				const result = [c.subject.untaggedCbor()];
+				for (const assertion of c.assertions) result.push(assertion.untaggedCbor());
+				return Envelope.valueToCbor(result);
+			}
+			case "leaf": return toTaggedValue(TAG_LEAF, c.cbor);
+			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 "encrypted": {
+				const message = c.message;
+				const digest = message.aadDigest();
+				const arr = digest !== void 0 ? [
+					message.ciphertext(),
+					message.nonce(),
+					message.authTag(),
+					digest.data()
+				] : [
+					message.ciphertext(),
+					message.nonce(),
+					message.authTag()
+				];
+				return toTaggedValue(TAG_ENCRYPTED, Envelope.valueToCbor(arr));
+			}
+			case "compressed": {
+				const digest = c.value.digestOpt();
+				const data = c.value.compressedData();
+				const arr = digest !== void 0 ? [data, digest.data()] : [data];
+				return toTaggedValue(TAG_COMPRESSED, Envelope.valueToCbor(arr));
+			}
+		}
+	}
+	taggedCbor() {
+		return toTaggedValue(TAG_ENVELOPE$1, this.untaggedCbor());
+	}
+	static fromUntaggedCbor(cbor$1) {
+		const tagged = asTaggedValue(cbor$1);
+		if (tagged !== void 0) {
+			const [tag, item] = tagged;
+			switch (tag.value) {
+				case TAG_LEAF:
+				case TAG_ENCODED_CBOR: return Envelope.newLeaf(item);
+				case TAG_ENVELOPE$1: {
+					const envelope = Envelope.fromUntaggedCbor(item);
+					return Envelope.newWrapped(envelope);
+				}
+				case TAG_COMPRESSED: {
+					const arr = asCborArray(item);
+					if (arr === void 0 || arr.length < 1 || arr.length > 2) throw EnvelopeError.cbor("compressed envelope must have 1 or 2 elements");
+					const compressedData = asByteString(arr.get(0));
+					if (compressedData === void 0) throw EnvelopeError.cbor("compressed data must be byte string");
+					const digestBytes = arr.length === 2 ? 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);
+					return Envelope.fromCase({
+						type: "compressed",
+						value: compressed
+					});
+				}
+				case TAG_ENCRYPTED: {
+					const arr = asCborArray(item);
+					if (arr === void 0 || arr.length < 3 || arr.length > 4) throw EnvelopeError.cbor("encrypted envelope must have 3 or 4 elements");
+					const ciphertext = asByteString(arr.get(0));
+					const nonce = asByteString(arr.get(1));
+					const authTag = asByteString(arr.get(2));
+					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 ? 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);
+					return Envelope.fromCase({
+						type: "encrypted",
+						message
+					});
+				}
+				default: throw EnvelopeError.cbor(`unknown envelope tag: ${tag.value}`);
+			}
+		}
+		const bytes = 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));
+		}
+		const array = asCborArray(cbor$1);
+		if (array !== void 0) {
+			if (array.length < 2) throw EnvelopeError.cbor("node must have at least two elements");
+			const subjectCbor = array.get(0);
+			if (subjectCbor === void 0) throw EnvelopeError.cbor("node subject is missing");
+			const subject = Envelope.fromUntaggedCbor(subjectCbor);
+			const assertions = [];
+			for (let i = 1; i < array.length; i++) {
+				const assertionCbor = array.get(i);
+				if (assertionCbor === void 0) throw EnvelopeError.cbor(`node assertion at index ${i} is missing`);
+				assertions.push(Envelope.fromUntaggedCbor(assertionCbor));
+			}
+			return Envelope.newWithAssertions(subject, assertions);
+		}
+		const map = asCborMap(cbor$1);
+		if (map !== void 0) {
+			const assertion = Assertion.fromCborMap(map);
+			return Envelope.newWithAssertion(assertion);
+		}
+		if (cbor$1.type === MajorType.Unsigned) {
+			const knownValue = new KnownValue(cbor$1.value);
+			return Envelope.newWithKnownValue(knownValue);
+		}
+		throw EnvelopeError.cbor("invalid envelope format");
+	}
+	static fromTaggedCbor(cbor$1) {
+		try {
+			const untagged = tryExpectedTaggedValue(cbor$1, TAG_ENVELOPE$1);
+			return Envelope.fromUntaggedCbor(untagged);
+		} catch (error) {
+			throw EnvelopeError.cbor(`expected TAG_ENVELOPE (${TAG_ENVELOPE$1})`, error instanceof Error ? error : void 0);
+		}
+	}
+	addAssertion(predicate, object) {
+		const assertion = Envelope.newAssertion(predicate, object);
+		return this.addAssertionEnvelope(assertion);
+	}
+	addAssertionEnvelope(assertion) {
+		const c = this.#case;
+		if (c.type === "node") return Envelope.newWithAssertions(c.subject, [...c.assertions, assertion]);
+		return Envelope.newWithAssertions(this, [assertion]);
+	}
+	toString() {
+		return `Envelope(${this.#case.type})`;
+	}
+	clone() {
+		return this;
+	}
+};
+
+//#endregion
+//#region src/base/envelope-encodable.ts
+function isEnvelopeEncodable(value) {
+	return typeof value === "object" && value !== null && "intoEnvelope" in value && typeof value.intoEnvelope === "function";
+}
+
+//#endregion
+//#region src/base/cbor.ts
+const TAG_ENVELOPE = ENVELOPE.value;
+var EnvelopeCBORTagged = class {
+	cborTags() {
+		return tagsForValues([TAG_ENVELOPE]);
+	}
+	static cborTags() {
+		return tagsForValues([TAG_ENVELOPE]).map((tag) => Number(tag.value));
+	}
+};
+var EnvelopeCBORTaggedEncodable = class {
+	constructor(envelope) {
+		this.envelope = envelope;
+	}
+	cborTags() {
+		return tagsForValues([TAG_ENVELOPE]);
+	}
+	untaggedCbor() {
+		return this.envelope.untaggedCbor();
+	}
+	taggedCbor() {
+		return this.envelope.taggedCbor();
+	}
+};
+var EnvelopeCBORTaggedDecodable = class {
+	cborTags() {
+		return tagsForValues([TAG_ENVELOPE]);
+	}
+	static fromUntaggedCbor(cbor$1) {
+		return Envelope.fromUntaggedCbor(cbor$1);
+	}
+	static fromTaggedCbor(cbor$1) {
+		return Envelope.fromTaggedCbor(cbor$1);
+	}
+	fromUntaggedCbor(cbor$1) {
+		return Envelope.fromUntaggedCbor(cbor$1);
+	}
+	fromTaggedCbor(cbor$1) {
+		return Envelope.fromTaggedCbor(cbor$1);
+	}
+};
+function envelopeToCbor(envelope) {
+	return envelope.taggedCbor();
+}
+function envelopeFromCbor(cbor$1) {
+	return Envelope.fromTaggedCbor(cbor$1);
+}
+function envelopeToBytes(envelope) {
+	return cborData(envelope.taggedCbor());
+}
+function envelopeFromBytes(bytes) {
+	const cbor$1 = decodeCbor(bytes);
+	return Envelope.fromTaggedCbor(cbor$1);
+}
+
+//#endregion
+//#region src/base/envelope-decodable.ts
+function extractString(envelope) {
+	const cbor$1 = envelope.tryLeaf();
+	try {
+		return tryIntoText(cbor$1);
+	} catch (error) {
+		throw EnvelopeError.cbor("envelope does not contain a string", error instanceof Error ? error : void 0);
+	}
+}
+function extractNumber(envelope) {
+	const cbor$1 = envelope.tryLeaf();
+	if ("type" in cbor$1) switch (cbor$1.type) {
+		case 0: return typeof cbor$1.value === "bigint" ? Number(cbor$1.value) : cbor$1.value;
+		case 1: return -(typeof cbor$1.value === "bigint" ? Number(cbor$1.value) : cbor$1.value) - 1;
+		case 7:
+			if (typeof cbor$1.value === "object" && cbor$1.value !== null && "type" in cbor$1.value && cbor$1.value.type === "Float") return cbor$1.value.value;
+			break;
+		case 2:
+		case 3:
+		case 4:
+		case 5:
+		case 6: break;
+	}
+	throw EnvelopeError.cbor("envelope does not contain a number");
+}
+function extractBoolean(envelope) {
+	const cbor$1 = envelope.tryLeaf();
+	try {
+		return tryIntoBool(cbor$1);
+	} catch (error) {
+		throw EnvelopeError.cbor("envelope does not contain a boolean", error instanceof Error ? error : void 0);
+	}
+}
+function extractBytes(envelope) {
+	const cbor$1 = envelope.tryLeaf();
+	try {
+		return tryIntoByteString(cbor$1);
+	} catch (error) {
+		throw EnvelopeError.cbor("envelope does not contain bytes", error instanceof Error ? error : void 0);
+	}
+}
+function extractNull(envelope) {
+	if (isNull(envelope.tryLeaf())) return null;
+	throw EnvelopeError.cbor("envelope does not contain null");
+}
+var EnvelopeDecoder = class EnvelopeDecoder {
+	static tryFromCbor(cbor$1) {
+		try {
+			return Envelope.fromTaggedCbor(cbor$1);
+		} catch (error) {
+			throw EnvelopeError.cbor("invalid envelope CBOR", error instanceof Error ? error : void 0);
+		}
+	}
+	static tryFromCborData(data) {
+		try {
+			const cbor$1 = decodeCbor(data);
+			return EnvelopeDecoder.tryFromCbor(cbor$1);
+		} catch (error) {
+			throw EnvelopeError.cbor("invalid envelope CBOR data", error instanceof Error ? error : void 0);
+		}
+	}
+};
+Envelope.prototype.tryLeaf = function() {
+	const c = this.case();
+	if (c.type !== "leaf") throw EnvelopeError.notLeaf();
+	return c.cbor;
+};
+Envelope.prototype.extractString = function() {
+	return extractString(this);
+};
+Envelope.prototype.extractNumber = function() {
+	return extractNumber(this);
+};
+Envelope.prototype.extractBoolean = function() {
+	return extractBoolean(this);
+};
+Envelope.prototype.extractBytes = function() {
+	return extractBytes(this);
+};
+Envelope.prototype.extractNull = function() {
+	return extractNull(this);
+};
+
+//#endregion
+//#region src/base/elide.ts
+let ObscureType = /* @__PURE__ */ function(ObscureType$1) {
+	ObscureType$1["Elided"] = "elided";
+	ObscureType$1["Encrypted"] = "encrypted";
+	ObscureType$1["Compressed"] = "compressed";
+	return ObscureType$1;
+}({});
+function elideAction() {
+	return { type: "elide" };
+}
+Envelope.prototype.elide = function() {
+	if (this.case().type === "elided") return this;
+	return Envelope.newElided(this.digest());
+};
+function elideSetWithAction(envelope, target, isRevealing, action) {
+	const selfDigest = envelope.digest();
+	if (Array.from(target).some((d) => d.equals(selfDigest)) !== isRevealing) {
+		if (action.type === "elide") return envelope.elide();
+		else if (action.type === "encrypt") throw new Error("Encryption not yet implemented");
+		else if (action.type === "compress") throw new Error("Compression not yet implemented");
+	}
+	const c = envelope.case();
+	if (c.type === "assertion") {
+		const elidedAssertion = new Assertion(elideSetWithAction(c.assertion.predicate(), target, isRevealing, action), elideSetWithAction(c.assertion.object(), target, isRevealing, action));
+		return Envelope.newWithAssertion(elidedAssertion);
+	} else if (c.type === "node") {
+		const elidedSubject = elideSetWithAction(c.subject, target, isRevealing, action);
+		const elidedAssertions = c.assertions.map((a) => elideSetWithAction(a, target, isRevealing, action));
+		return Envelope.newWithUncheckedAssertions(elidedSubject, elidedAssertions);
+	} else if (c.type === "wrapped") {
+		const elidedEnvelope = elideSetWithAction(c.envelope, target, isRevealing, action);
+		return Envelope.newWrapped(elidedEnvelope);
+	}
+	return envelope;
+}
+Envelope.prototype.elideRemovingSetWithAction = function(target, action) {
+	return elideSetWithAction(this, target, false, action);
+};
+Envelope.prototype.elideRemovingSet = function(target) {
+	return elideSetWithAction(this, target, false, elideAction());
+};
+Envelope.prototype.elideRemovingArrayWithAction = function(target, action) {
+	const targetSet = new Set(target.map((p) => p.digest()));
+	return elideSetWithAction(this, targetSet, false, action);
+};
+Envelope.prototype.elideRemovingArray = function(target) {
+	const targetSet = new Set(target.map((p) => p.digest()));
+	return elideSetWithAction(this, targetSet, false, elideAction());
+};
+Envelope.prototype.elideRemovingTargetWithAction = function(target, action) {
+	return this.elideRemovingArrayWithAction([target], action);
+};
+Envelope.prototype.elideRemovingTarget = function(target) {
+	return this.elideRemovingArray([target]);
+};
+Envelope.prototype.elideRevealingSetWithAction = function(target, action) {
+	return elideSetWithAction(this, target, true, action);
+};
+Envelope.prototype.elideRevealingSet = function(target) {
+	return elideSetWithAction(this, target, true, elideAction());
+};
+Envelope.prototype.elideRevealingArrayWithAction = function(target, action) {
+	const targetSet = new Set(target.map((p) => p.digest()));
+	return elideSetWithAction(this, targetSet, true, action);
+};
+Envelope.prototype.elideRevealingArray = function(target) {
+	const targetSet = new Set(target.map((p) => p.digest()));
+	return elideSetWithAction(this, targetSet, true, elideAction());
+};
+Envelope.prototype.elideRevealingTargetWithAction = function(target, action) {
+	return this.elideRevealingArrayWithAction([target], action);
+};
+Envelope.prototype.elideRevealingTarget = function(target) {
+	return this.elideRevealingArray([target]);
+};
+Envelope.prototype.unelide = function(envelope) {
+	if (this.digest().equals(envelope.digest())) return envelope;
+	throw EnvelopeError.invalidDigest();
+};
+Envelope.prototype.nodesMatching = function(targetDigests, obscureTypes) {
+	const result = /* @__PURE__ */ new Set();
+	const visitor = (envelope) => {
+		if (!(targetDigests === void 0 || Array.from(targetDigests).some((d) => d.equals(envelope.digest())))) return;
+		if (obscureTypes.length === 0) {
+			result.add(envelope.digest());
+			return;
+		}
+		const c = envelope.case();
+		if (obscureTypes.some((obscureType) => {
+			if (obscureType === ObscureType.Elided && c.type === "elided") return true;
+			if (obscureType === ObscureType.Encrypted && c.type === "encrypted") return true;
+			if (obscureType === ObscureType.Compressed && c.type === "compressed") return true;
+			return false;
+		})) result.add(envelope.digest());
+	};
+	walkEnvelope(this, visitor);
+	return result;
+};
+function walkEnvelope(envelope, visitor) {
+	visitor(envelope);
+	const c = envelope.case();
+	if (c.type === "node") {
+		walkEnvelope(c.subject, visitor);
+		for (const assertion of c.assertions) walkEnvelope(assertion, visitor);
+	} else if (c.type === "assertion") {
+		walkEnvelope(c.assertion.predicate(), visitor);
+		walkEnvelope(c.assertion.object(), visitor);
+	} else if (c.type === "wrapped") walkEnvelope(c.envelope, visitor);
+}
+Envelope.prototype.walkUnelide = function(envelopes) {
+	const envelopeMap = /* @__PURE__ */ new Map();
+	for (const env of envelopes) envelopeMap.set(env.digest().hex(), env);
+	return walkUnelideWithMap(this, envelopeMap);
+};
+function walkUnelideWithMap(envelope, envelopeMap) {
+	const c = envelope.case();
+	if (c.type === "elided") return envelopeMap.get(envelope.digest().hex()) ?? envelope;
+	if (c.type === "node") {
+		const newSubject = walkUnelideWithMap(c.subject, envelopeMap);
+		const newAssertions = c.assertions.map((a) => walkUnelideWithMap(a, envelopeMap));
+		if (newSubject.isIdenticalTo(c.subject) && newAssertions.every((a, i) => a.isIdenticalTo(c.assertions[i]))) return envelope;
+		return Envelope.newWithUncheckedAssertions(newSubject, newAssertions);
+	}
+	if (c.type === "wrapped") {
+		const newEnvelope = walkUnelideWithMap(c.envelope, envelopeMap);
+		if (newEnvelope.isIdenticalTo(c.envelope)) return envelope;
+		return Envelope.newWrapped(newEnvelope);
+	}
+	if (c.type === "assertion") {
+		const newPredicate = walkUnelideWithMap(c.assertion.predicate(), envelopeMap);
+		const newObject = walkUnelideWithMap(c.assertion.object(), envelopeMap);
+		if (newPredicate.isIdenticalTo(c.assertion.predicate()) && newObject.isIdenticalTo(c.assertion.object())) return envelope;
+		return Envelope.newAssertion(newPredicate, newObject);
+	}
+	return envelope;
+}
+Envelope.prototype.walkReplace = function(target, replacement) {
+	if (Array.from(target).some((d) => d.equals(this.digest()))) return replacement;
+	const c = this.case();
+	if (c.type === "node") {
+		const newSubject = c.subject.walkReplace(target, replacement);
+		const newAssertions = c.assertions.map((a) => a.walkReplace(target, replacement));
+		if (newSubject.isIdenticalTo(c.subject) && newAssertions.every((a, i) => a.isIdenticalTo(c.assertions[i]))) return this;
+		return Envelope.newWithAssertions(newSubject, newAssertions);
+	}
+	if (c.type === "wrapped") {
+		const newEnvelope = c.envelope.walkReplace(target, replacement);
+		if (newEnvelope.isIdenticalTo(c.envelope)) return this;
+		return Envelope.newWrapped(newEnvelope);
+	}
+	if (c.type === "assertion") {
+		const newPredicate = c.assertion.predicate().walkReplace(target, replacement);
+		const newObject = c.assertion.object().walkReplace(target, replacement);
+		if (newPredicate.isIdenticalTo(c.assertion.predicate()) && newObject.isIdenticalTo(c.assertion.object())) return this;
+		return Envelope.newAssertion(newPredicate, newObject);
+	}
+	return this;
+};
+Envelope.prototype.isIdenticalTo = function(other) {
+	return this.digest().equals(other.digest()) && this.case().type === other.case().type;
+};
+
+//#endregion
+//#region src/base/walk.ts
+let EdgeType = /* @__PURE__ */ function(EdgeType$1) {
+	EdgeType$1["None"] = "none";
+	EdgeType$1["Subject"] = "subject";
+	EdgeType$1["Assertion"] = "assertion";
+	EdgeType$1["Predicate"] = "predicate";
+	EdgeType$1["Object"] = "object";
+	EdgeType$1["Content"] = "content";
+	return EdgeType$1;
+}({});
+function edgeLabel(edgeType) {
+	switch (edgeType) {
+		case EdgeType.Subject: return "subj";
+		case EdgeType.Content: return "cont";
+		case EdgeType.Predicate: return "pred";
+		case EdgeType.Object: return "obj";
+		case EdgeType.None:
+		case EdgeType.Assertion: return;
+		default: return;
+	}
+}
+Envelope.prototype.walk = function(hideNodes, state, visit) {
+	if (hideNodes) walkTree(this, 0, EdgeType.None, state, visit);
+	else walkStructure(this, 0, EdgeType.None, state, visit);
+};
+function walkStructure(envelope, level, incomingEdge, state, visit) {
+	const [newState, stop] = visit(envelope, level, incomingEdge, state);
+	if (stop) return;
+	const nextLevel = level + 1;
+	const c = envelope.case();
+	switch (c.type) {
+		case "node":
+			walkStructure(c.subject, nextLevel, EdgeType.Subject, newState, visit);
+			for (const assertion of c.assertions) walkStructure(assertion, nextLevel, EdgeType.Assertion, newState, visit);
+			break;
+		case "wrapped":
+			walkStructure(c.envelope, nextLevel, EdgeType.Content, newState, visit);
+			break;
+		case "assertion":
+			walkStructure(c.assertion.predicate(), nextLevel, EdgeType.Predicate, newState, visit);
+			walkStructure(c.assertion.object(), nextLevel, EdgeType.Object, newState, visit);
+			break;
+		case "leaf":
+		case "elided":
+		case "knownValue":
+		case "encrypted":
+		case "compressed": break;
+	}
+}
+function walkTree(envelope, level, incomingEdge, state, visit) {
+	let currentState = state;
+	let subjectLevel = level;
+	if (!envelope.isNode()) {
+		const [newState, stop] = visit(envelope, level, incomingEdge, currentState);
+		if (stop) return newState;
+		currentState = newState;
+		subjectLevel = level + 1;
+	}
+	const c = envelope.case();
+	switch (c.type) {
+		case "node": {
+			const assertionState = walkTree(c.subject, subjectLevel, EdgeType.Subject, currentState, visit);
+			const assertionLevel = subjectLevel + 1;
+			for (const assertion of c.assertions) walkTree(assertion, assertionLevel, EdgeType.Assertion, assertionState, visit);
+			break;
+		}
+		case "wrapped":
+			walkTree(c.envelope, subjectLevel, EdgeType.Content, currentState, visit);
+			break;
+		case "assertion":
+			walkTree(c.assertion.predicate(), subjectLevel, EdgeType.Predicate, currentState, visit);
+			walkTree(c.assertion.object(), subjectLevel, EdgeType.Object, currentState, visit);
+			break;
+		case "leaf":
+		case "elided":
+		case "knownValue":
+		case "encrypted":
+		case "compressed": break;
+	}
+	return currentState;
+}
+
+//#endregion
+//#region src/base/assertions.ts
+Envelope.prototype.addAssertionEnvelopes = function(assertions) {
+	return assertions.reduce((result, assertion) => result.addAssertionEnvelope(assertion), this);
+};
+Envelope.prototype.addOptionalAssertionEnvelope = function(assertion) {
+	if (assertion === void 0) return this;
+	if (!assertion.isSubjectAssertion() && !assertion.isSubjectObscured()) throw EnvelopeError.invalidFormat();
+	const c = this.case();
+	if (c.type === "node") {
+		if (c.assertions.some((a) => a.digest().equals(assertion.digest()))) return this;
+		return Envelope.newWithUncheckedAssertions(c.subject, [...c.assertions, assertion]);
+	}
+	return Envelope.newWithUncheckedAssertions(this.subject(), [assertion]);
+};
+Envelope.prototype.addOptionalAssertion = function(predicate, object) {
+	if (object === void 0 || object === null) return this;
+	return this.addAssertion(predicate, object);
+};
+Envelope.prototype.addNonemptyStringAssertion = function(predicate, str) {
+	if (str.length === 0) return this;
+	return this.addAssertion(predicate, str);
+};
+Envelope.prototype.addAssertions = function(envelopes) {
+	return envelopes.reduce((result, envelope) => result.addAssertionEnvelope(envelope), this);
+};
+Envelope.prototype.addAssertionIf = function(condition, predicate, object) {
+	if (condition) return this.addAssertion(predicate, object);
+	return this;
+};
+Envelope.prototype.addAssertionEnvelopeIf = function(condition, assertionEnvelope) {
+	if (condition) return this.addAssertionEnvelope(assertionEnvelope);
+	return this;
+};
+Envelope.prototype.removeAssertion = function(target) {
+	const assertions = this.assertions();
+	const targetDigest = target.digest();
+	const index = assertions.findIndex((a) => a.digest().equals(targetDigest));
+	if (index === -1) return this;
+	const newAssertions = [...assertions.slice(0, index), ...assertions.slice(index + 1)];
+	if (newAssertions.length === 0) return this.subject();
+	return Envelope.newWithUncheckedAssertions(this.subject(), newAssertions);
+};
+Envelope.prototype.replaceAssertion = function(assertion, newAssertion) {
+	return this.removeAssertion(assertion).addAssertionEnvelope(newAssertion);
+};
+Envelope.prototype.replaceSubject = function(subject) {
+	return this.assertions().reduce((e, a) => e.addAssertionEnvelope(a), subject);
+};
+Envelope.prototype.assertions = function() {
+	const c = this.case();
+	if (c.type === "node") return c.assertions;
+	return [];
+};
+
+//#endregion
+//#region src/base/leaf.ts
+Envelope.false = function() {
+	return Envelope.newLeaf(false);
+};
+Envelope.true = function() {
+	return Envelope.newLeaf(true);
+};
+Envelope.prototype.isFalse = function() {
+	try {
+		return this.extractBoolean() === false;
+	} catch {
+		return false;
+	}
+};
+Envelope.prototype.isTrue = function() {
+	try {
+		return this.extractBoolean() === true;
+	} catch {
+		return false;
+	}
+};
+Envelope.prototype.isBool = function() {
+	try {
+		return typeof this.extractBoolean() === "boolean";
+	} catch {
+		return false;
+	}
+};
+Envelope.prototype.isNumber = function() {
+	const leaf = this.asLeaf();
+	if (leaf === void 0) return false;
+	return isNumber(leaf);
+};
+Envelope.prototype.isSubjectNumber = function() {
+	return this.subject().isNumber();
+};
+Envelope.prototype.isNaN = function() {
+	const leaf = this.asLeaf();
+	if (leaf === void 0) return false;
+	if ("type" in leaf && leaf.type === 7) return isNaN(leaf);
+	return false;
+};
+Envelope.prototype.isSubjectNaN = function() {
+	return this.subject().isNaN();
+};
+Envelope.prototype.isNull = function() {
+	try {
+		this.extractNull();
+		return true;
+	} catch (_error) {
+		return false;
+	}
+};
+Envelope.prototype.tryByteString = function() {
+	return this.extractBytes();
+};
+Envelope.prototype.asByteString = function() {
+	try {
+		return this.extractBytes();
+	} catch {
+		return;
+	}
+};
+Envelope.prototype.asArray = function() {
+	const leaf = this.asLeaf();
+	if (leaf === void 0) return;
+	return asArray(leaf);
+};
+Envelope.prototype.asMap = function() {
+	const leaf = this.asLeaf();
+	if (leaf === void 0) return;
+	return asMap(leaf);
+};
+Envelope.prototype.asText = function() {
+	const leaf = this.asLeaf();
+	if (leaf === void 0) return;
+	return asText(leaf);
+};
+Envelope.prototype.asLeaf = function() {
+	const c = this.case();
+	if (c.type === "leaf") return c.cbor;
+};
+
+//#endregion
+//#region src/base/queries.ts
+Envelope.prototype.hasAssertions = function() {
+	const c = this.case();
+	return c.type === "node" && c.assertions.length > 0;
+};
+Envelope.prototype.asAssertion = function() {
+	return this.case().type === "assertion" ? this : void 0;
+};
+Envelope.prototype.tryAssertion = function() {
+	const result = this.asAssertion();
+	if (result === void 0) throw EnvelopeError.notAssertion();
+	return result;
+};
+Envelope.prototype.asPredicate = function() {
+	const c = this.subject().case();
+	if (c.type === "assertion") return c.assertion.predicate();
+};
+Envelope.prototype.tryPredicate = function() {
+	const result = this.asPredicate();
+	if (result === void 0) throw EnvelopeError.notAssertion();
+	return result;
+};
+Envelope.prototype.asObject = function() {
+	const c = this.subject().case();
+	if (c.type === "assertion") return c.assertion.object();
+};
+Envelope.prototype.tryObject = function() {
+	const result = this.asObject();
+	if (result === void 0) throw EnvelopeError.notAssertion();
+	return result;
+};
+Envelope.prototype.isAssertion = function() {
+	return this.case().type === "assertion";
+};
+Envelope.prototype.isElided = function() {
+	return this.case().type === "elided";
+};
+Envelope.prototype.isLeaf = function() {
+	return this.case().type === "leaf";
+};
+Envelope.prototype.isNode = function() {
+	return this.case().type === "node";
+};
+Envelope.prototype.isWrapped = function() {
+	return this.case().type === "wrapped";
+};
+Envelope.prototype.isInternal = function() {
+	const type = this.case().type;
+	return type === "node" || type === "wrapped" || type === "assertion";
+};
+Envelope.prototype.isObscured = function() {
+	const type = this.case().type;
+	return type === "elided" || type === "encrypted" || type === "compressed";
+};
+Envelope.prototype.assertionsWithPredicate = function(predicate) {
+	const predicateDigest = Envelope.new(predicate).digest();
+	return this.assertions().filter((assertion) => {
+		return assertion.subject().asPredicate()?.digest().equals(predicateDigest) === true;
+	});
+};
+Envelope.prototype.assertionWithPredicate = function(predicate) {
+	const matches = this.assertionsWithPredicate(predicate);
+	if (matches.length === 0) throw EnvelopeError.nonexistentPredicate();
+	if (matches.length > 1) throw EnvelopeError.ambiguousPredicate();
+	return matches[0];
+};
+Envelope.prototype.optionalAssertionWithPredicate = function(predicate) {
+	const matches = this.assertionsWithPredicate(predicate);
+	if (matches.length === 0) return;
+	if (matches.length > 1) throw EnvelopeError.ambiguousPredicate();
+	return matches[0];
+};
+Envelope.prototype.objectForPredicate = function(predicate) {
+	const obj = this.assertionWithPredicate(predicate).asObject();
+	if (obj === void 0) throw EnvelopeError.notAssertion();
+	return obj;
+};
+Envelope.prototype.optionalObjectForPredicate = function(predicate) {
+	const matches = this.assertionsWithPredicate(predicate);
+	if (matches.length === 0) return;
+	if (matches.length > 1) throw EnvelopeError.ambiguousPredicate();
+	return matches[0].subject().asObject();
+};
+Envelope.prototype.objectsForPredicate = function(predicate) {
+	return this.assertionsWithPredicate(predicate).map((assertion) => {
+		const obj = assertion.asObject();
+		if (obj === void 0) throw EnvelopeError.notAssertion();
+		return obj;
+	});
+};
+Envelope.prototype.elementsCount = function() {
+	let count = 1;
+	const c = this.case();
+	switch (c.type) {
+		case "node":
+			count += c.subject.elementsCount();
+			for (const assertion of c.assertions) count += assertion.elementsCount();
+			break;
+		case "assertion":
+			count += c.assertion.predicate().elementsCount();
+			count += c.assertion.object().elementsCount();
+			break;
+		case "wrapped":
+			count += c.envelope.elementsCount();
+			break;
+		case "leaf":
+		case "elided":
+		case "knownValue":
+		case "encrypted":
+		case "compressed": break;
+	}
+	return count;
+};
+
+//#endregion
+//#region src/base/wrap.ts
+Envelope.prototype.wrap = function() {
+	return Envelope.newWrapped(this);
+};
+Envelope.prototype.tryUnwrap = function() {
+	const c = this.subject().case();
+	if (c.type === "wrapped") return c.envelope;
+	throw EnvelopeError.notWrapped();
+};
+Envelope.prototype.unwrap = function() {
+	return this.tryUnwrap();
+};
+
+//#endregion
+//#region src/extension/types.ts
+const IS_A = "isA";
+if (Envelope?.prototype) {
+	Envelope.prototype.addType = function(object) {
+		return this.addAssertion(IS_A, object);
+	};
+	Envelope.prototype.types = function() {
+		return this.objectsForPredicate(IS_A);
+	};
+	Envelope.prototype.getType = function() {
+		const t = this.types();
+		if (t.length === 0) throw EnvelopeError.invalidType();
+		if (t.length === 1) return t[0];
+		throw EnvelopeError.ambiguousType();
+	};
+	Envelope.prototype.hasType = function(t) {
+		const e = Envelope.new(t);
+		return this.types().some((x) => x.digest().equals(e.digest()));
+	};
+	Envelope.prototype.checkType = function(t) {
+		if (!this.hasType(t)) throw EnvelopeError.invalidType();
+	};
+}
+
+//#endregion
+//#region src/extension/salt.ts
+const SALT = "salt";
+const MIN_SALT_SIZE = 8;
+function createSecureRng() {
+	return new SecureRandomNumberGenerator();
+}
+function generateRandomBytes(length, rng) {
+	return rngRandomData(rng ?? createSecureRng(), length);
+}
+function calculateProportionalSaltSize(envelopeSize, rng) {
+	const actualRng = rng ?? createSecureRng();
+	const count = envelopeSize;
+	const minSize = Math.max(8, Math.ceil(count * .05));
+	return rngNextInClosedRangeI32(actualRng, minSize, Math.max(minSize + 8, Math.ceil(count * .25)));
+}
+if (Envelope?.prototype) {
+	Envelope.prototype.addSalt = function() {
+		const rng = createSecureRng();
+		const envelopeSize = this.cborBytes().length;
+		const saltBytes = generateRandomBytes(calculateProportionalSaltSize(envelopeSize, rng), rng);
+		return this.addAssertion(SALT, saltBytes);
+	};
+	Envelope.prototype.addSaltWithLength = function(count) {
+		if (count < MIN_SALT_SIZE) throw EnvelopeError.general(`Salt must be at least ${MIN_SALT_SIZE} bytes, got ${count}`);
+		const saltBytes = generateRandomBytes(count);
+		return this.addAssertion(SALT, saltBytes);
+	};
+	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);
+	};
+	Envelope.prototype.addSaltInRange = function(min, max) {
+		if (min < MIN_SALT_SIZE) throw EnvelopeError.general(`Minimum salt size must be at least ${MIN_SALT_SIZE} bytes, got ${min}`);
+		if (max < min) throw EnvelopeError.general(`Maximum salt size must be at least minimum, got min=${min} max=${max}`);
+		const rng = createSecureRng();
+		const saltBytes = generateRandomBytes(rngNextInClosedRangeI32(rng, min, max), rng);
+		return this.addAssertion(SALT, saltBytes);
+	};
+}
+
+//#endregion
+//#region src/extension/signature.ts
+/**
+* Signature Extension for Gordian Envelope
+*
+* Provides functionality for digitally signing Envelopes and verifying signatures,
+* with optional metadata support.
+*
+* The signature extension allows:
+* - Signing envelope subjects to validate their authenticity
+* - Adding metadata to signatures (e.g., signer identity, date, purpose)
+* - Verification of signatures, both with and without metadata
+* - Support for multiple signatures on a single envelope
+*/
+/**
+* Known value for the 'signed' predicate.
+* This is the standard predicate used for signature assertions.
+*/
+const SIGNED = "signed";
+/**
+* Known value for the 'verifiedBy' predicate.
+* Used to indicate verification status.
+*/
+const VERIFIED_BY = "verifiedBy";
+/**
+* Known value for the 'note' predicate.
+* Used for adding notes/comments to signatures.
+*/
+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 !== ECDSA_PRIVATE_KEY_SIZE) throw new Error(`Private key must be ${ECDSA_PRIVATE_KEY_SIZE} bytes`);
+		this.#privateKey = privateKey;
+	}
+	/**
+	* Generates a new random private key.
+	*/
+	static generate() {
+		return new SigningPrivateKey(rngRandomData(new SecureRandomNumberGenerator(), 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(ecdsaPublicKeyFromPrivateKey(this.#privateKey));
+	}
+	/**
+	* Signs data and returns a Signature.
+	*/
+	sign(data) {
+		return new Signature(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.
+*/
+var SigningPublicKey = class SigningPublicKey {
+	#publicKey;
+	constructor(publicKey) {
+		if (publicKey.length !== ECDSA_PUBLIC_KEY_SIZE && publicKey.length !== ECDSA_UNCOMPRESSED_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${ECDSA_PUBLIC_KEY_SIZE} bytes (compressed) or ${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 ecdsaVerify(this.#publicKey, signature.data(), data);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Returns the raw public key bytes.
+	*/
+	data() {
+		return this.#publicKey;
+	}
+	/**
+	* Returns the hex-encoded public key.
+	*/
+	hex() {
+		return Array.from(this.#publicKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+};
+/**
+* Metadata that can be attached to a signature.
+*/
+var SignatureMetadata = class SignatureMetadata {
+	#assertions = [];
+	/**
+	* Adds an assertion to the metadata.
+	*/
+	withAssertion(predicate, object) {
+		const metadata = new SignatureMetadata();
+		metadata.#assertions.push(...this.#assertions);
+		metadata.#assertions.push([predicate, object]);
+		return metadata;
+	}
+	/**
+	* Returns all assertions in the metadata.
+	*/
+	assertions() {
+		return this.#assertions;
+	}
+	/**
+	* Returns true if this metadata has any assertions.
+	*/
+	hasAssertions() {
+		return this.#assertions.length > 0;
+	}
+};
+if (Envelope?.prototype) {
+	Envelope.prototype.addSignature = function(signer) {
+		return this.addSignatureWithMetadata(signer, void 0);
+	};
+	Envelope.prototype.addSignatureWithMetadata = function(signer, metadata) {
+		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;
+						}
+					}
+				}
+			}
+		}
+		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");
+		});
+	};
+}
+
+//#endregion
+//#region src/extension/attachment.ts
+/**
+* Attachment Extension for Gordian Envelope
+*
+* Provides functionality for attaching vendor-specific metadata to envelopes.
+* Attachments enable flexible, extensible data storage without modifying
+* the core data model, facilitating interoperability and future compatibility.
+*
+* Each attachment has:
+* - A payload (arbitrary data)
+* - A required vendor identifier (typically a reverse domain name)
+* - An optional conformsTo URI that indicates the format of the attachment
+*
+* See BCR-2023-006: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-006-envelope-attachment.md
+*/
+/**
+* Known value for the 'attachment' predicate.
+*/
+const ATTACHMENT = "attachment";
+/**
+* Known value for the 'vendor' predicate.
+*/
+const VENDOR = "vendor";
+/**
+* Known value for the 'conformsTo' predicate.
+*/
+const CONFORMS_TO = "conformsTo";
+/**
+* A container for vendor-specific metadata attachments.
+*
+* Attachments provides a flexible mechanism for attaching arbitrary metadata
+* to envelopes without modifying their core structure.
+*/
+var Attachments = class Attachments {
+	#envelopes = /* @__PURE__ */ new Map();
+	/**
+	* Creates a new empty attachments container.
+	*/
+	constructor() {}
+	/**
+	* Adds a new attachment with the specified payload and metadata.
+	*
+	* @param payload - The data to attach
+	* @param vendor - A string identifying the entity that defined the attachment format
+	* @param conformsTo - Optional URI identifying the structure the payload conforms to
+	*/
+	add(payload, vendor, conformsTo) {
+		const attachment = Envelope.newAttachment(payload, vendor, conformsTo);
+		this.#envelopes.set(attachment.digest().hex(), attachment);
+	}
+	/**
+	* Retrieves an attachment by its digest.
+	*
+	* @param digest - The unique digest of the attachment to retrieve
+	* @returns The envelope if found, or undefined
+	*/
+	get(digest) {
+		return this.#envelopes.get(digest.hex());
+	}
+	/**
+	* Removes an attachment by its digest.
+	*
+	* @param digest - The unique digest of the attachment to remove
+	* @returns The removed envelope if found, or undefined
+	*/
+	remove(digest) {
+		const envelope = this.#envelopes.get(digest.hex());
+		this.#envelopes.delete(digest.hex());
+		return envelope;
+	}
+	/**
+	* Removes all attachments from the container.
+	*/
+	clear() {
+		this.#envelopes.clear();
+	}
+	/**
+	* Returns whether the container has any attachments.
+	*/
+	isEmpty() {
+		return this.#envelopes.size === 0;
+	}
+	/**
+	* Adds all attachments from this container to an envelope.
+	*
+	* @param envelope - The envelope to add attachments to
+	* @returns A new envelope with all attachments added as assertions
+	*/
+	addToEnvelope(envelope) {
+		let result = envelope;
+		for (const attachment of this.#envelopes.values()) result = result.addAssertion(ATTACHMENT, attachment);
+		return result;
+	}
+	/**
+	* Creates an Attachments container from an envelope's attachment assertions.
+	*
+	* @param envelope - The envelope to extract attachments from
+	* @returns A new Attachments container with the envelope's attachments
+	*/
+	static fromEnvelope(envelope) {
+		const attachments = new Attachments();
+		const attachmentEnvelopes = envelope.attachments();
+		for (const attachment of attachmentEnvelopes) attachments.#envelopes.set(attachment.digest().hex(), attachment);
+		return attachments;
+	}
+};
+/**
+* Creates a new attachment envelope.
+*/
+Envelope.newAttachment = function(payload, vendor, conformsTo) {
+	let attachmentObj = Envelope.new(payload).wrap().addAssertion(VENDOR, vendor);
+	if (conformsTo !== void 0) attachmentObj = attachmentObj.addAssertion(CONFORMS_TO, conformsTo);
+	return Envelope.new(ATTACHMENT).addAssertion(ATTACHMENT, attachmentObj).assertions()[0];
+};
+/**
+* Adds an attachment to an envelope.
+*/
+if (Envelope?.prototype) {
+	Envelope.prototype.addAttachment = function(payload, vendor, conformsTo) {
+		let attachmentObj = Envelope.new(payload).wrap().addAssertion(VENDOR, vendor);
+		if (conformsTo !== void 0) attachmentObj = attachmentObj.addAssertion(CONFORMS_TO, conformsTo);
+		return this.addAssertion(ATTACHMENT, attachmentObj);
+	};
+	/**
+	* Returns the payload of an attachment envelope.
+	*/
+	Envelope.prototype.attachmentPayload = function() {
+		const c = this.case();
+		if (c.type !== "assertion") throw EnvelopeError.general("Envelope is not an attachment assertion");
+		return c.assertion.object().unwrap();
+	};
+	/**
+	* Returns the vendor of an attachment envelope.
+	*/
+	Envelope.prototype.attachmentVendor = function() {
+		const c = this.case();
+		if (c.type !== "assertion") throw EnvelopeError.general("Envelope is not an attachment assertion");
+		const vendor = c.assertion.object().objectForPredicate(VENDOR).asText();
+		if (vendor === void 0 || vendor === "") throw EnvelopeError.general("Attachment has no vendor");
+		return vendor;
+	};
+	/**
+	* Returns the conformsTo of an attachment envelope.
+	*/
+	Envelope.prototype.attachmentConformsTo = function() {
+		const c = this.case();
+		if (c.type !== "assertion") throw EnvelopeError.general("Envelope is not an attachment assertion");
+		const conformsToEnv = c.assertion.object().optionalObjectForPredicate(CONFORMS_TO);
+		if (conformsToEnv === void 0) return;
+		return conformsToEnv.asText();
+	};
+	/**
+	* Returns all attachment assertions.
+	*/
+	Envelope.prototype.attachments = function() {
+		return this.assertionsWithPredicate(ATTACHMENT).map((a) => {
+			const c = a.case();
+			if (c.type === "assertion") return c.assertion.object();
+			throw EnvelopeError.general("Invalid attachment assertion");
+		});
+	};
+	/**
+	* Returns attachments matching vendor and/or conformsTo.
+	*/
+	Envelope.prototype.attachmentsWithVendorAndConformsTo = function(vendor, conformsTo) {
+		return this.attachments().filter((attachment) => {
+			try {
+				if (vendor !== void 0) {
+					if (attachment.objectForPredicate(VENDOR).asText() !== vendor) return false;
+				}
+				if (conformsTo !== void 0) {
+					const conformsToEnv = attachment.optionalObjectForPredicate(CONFORMS_TO);
+					if (conformsToEnv === void 0) return false;
+					if (conformsToEnv.asText() !== conformsTo) return false;
+				}
+				return true;
+			} catch {
+				return false;
+			}
+		});
+	};
+}
+
+//#endregion
+//#region src/extension/recipient.ts
+const HAS_RECIPIENT = "hasRecipient";
+var PublicKeyBase = class PublicKeyBase {
+	#publicKey;
+	constructor(publicKey) {
+		if (publicKey.length !== X25519_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${X25519_PUBLIC_KEY_SIZE} bytes`);
+		this.#publicKey = publicKey;
+	}
+	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 = x25519NewPrivateKeyUsing(new SecureRandomNumberGenerator());
+		return new PrivateKeyBase(privateKey, x25519PublicKeyFromPrivateKey(privateKey));
+	}
+	static fromBytes(privateKey, publicKey) {
+		if (privateKey.length !== X25519_PRIVATE_KEY_SIZE) throw new Error(`Private key must be ${X25519_PRIVATE_KEY_SIZE} bytes`);
+		if (publicKey.length !== X25519_PUBLIC_KEY_SIZE) throw new Error(`Public key must be ${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);
+	}
+	publicKeys() {
+		return this.#publicKey;
+	}
+	data() {
+		return this.#privateKey;
+	}
+	hex() {
+		return Array.from(this.#privateKey).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	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 SecureRandomNumberGenerator();
+		const ephemeralPrivate = x25519NewPrivateKeyUsing(rng);
+		const ephemeralPublic = x25519PublicKeyFromPrivateKey(ephemeralPrivate);
+		const encryptionKey = hkdfHmacSha256(x25519SharedKey(ephemeralPrivate, recipientPublicKey.data()), new TextEncoder().encode("sealed_message"), 32);
+		const nonce = rngRandomData(rng, SYMMETRIC_NONCE_SIZE);
+		const [ciphertext, authTag] = 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 = X25519_PUBLIC_KEY_SIZE + SYMMETRIC_NONCE_SIZE + 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 + X25519_PUBLIC_KEY_SIZE);
+		offset += X25519_PUBLIC_KEY_SIZE;
+		const nonce = this.#data.slice(offset, offset + SYMMETRIC_NONCE_SIZE);
+		offset += SYMMETRIC_NONCE_SIZE;
+		const ciphertextAndTag = this.#data.slice(offset);
+		const ciphertext = ciphertextAndTag.slice(0, -SYMMETRIC_AUTH_SIZE);
+		const authTag = ciphertextAndTag.slice(-SYMMETRIC_AUTH_SIZE);
+		return aeadChaCha20Poly1305DecryptWithAad(ciphertext, hkdfHmacSha256(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);
+	}
+};
+if (Envelope?.prototype) {
+	Envelope.prototype.encryptSubjectToRecipient = function(recipientPublicKey) {
+		const contentKey = SymmetricKey.generate();
+		return this.encryptSubject(contentKey).addRecipient(recipientPublicKey, contentKey);
+	};
+	Envelope.prototype.encryptSubjectToRecipients = function(recipients) {
+		if (recipients.length === 0) throw EnvelopeError.general("Must provide at least one recipient");
+		const contentKey = SymmetricKey.generate();
+		let result = this.encryptSubject(contentKey);
+		for (const recipient of recipients) 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) => {
+			try {
+				const predicate = assertion.subject().asPredicate();
+				if (predicate === void 0) return false;
+				return predicate.asText() === HAS_RECIPIENT;
+			} catch {
+				return false;
+			}
+		});
+		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);
+			break;
+		} catch {
+			continue;
+		}
+		if (contentKey === null) throw EnvelopeError.general("Not a valid recipient");
+		return this.decryptSubject(contentKey);
+	};
+	Envelope.prototype.decryptToRecipient = function(recipientPrivateKey) {
+		return this.decryptSubjectToRecipient(recipientPrivateKey).unwrap();
+	};
+	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
+//#region src/extension/expression.ts
+const CBOR_TAG_FUNCTION = 40006;
+const CBOR_TAG_PARAMETER = 40007;
+const CBOR_TAG_PLACEHOLDER = 40008;
+const CBOR_TAG_REPLACEMENT = 40009;
+const FUNCTION_IDS = {
+	ADD: 1,
+	SUB: 2,
+	MUL: 3,
+	DIV: 4,
+	NEG: 5,
+	LT: 6,
+	LE: 7,
+	GT: 8,
+	GE: 9,
+	EQ: 10,
+	NE: 11,
+	AND: 12,
+	OR: 13,
+	XOR: 14,
+	NOT: 15
+};
+const PARAMETER_IDS = {
+	BLANK: 1,
+	LHS: 2,
+	RHS: 3
+};
+var Function = class Function {
+	#id;
+	constructor(id) {
+		this.#id = id;
+	}
+	id() {
+		return this.#id;
+	}
+	isNumeric() {
+		return typeof this.#id === "number";
+	}
+	isString() {
+		return typeof this.#id === "string";
+	}
+	envelope() {
+		const functionStr = typeof this.#id === "number" ? `«${this.#id}»` : `«"${this.#id}"»`;
+		return Envelope.new(functionStr);
+	}
+	withParameter(param, value) {
+		return new Expression(this).withParameter(param, value);
+	}
+	static fromNumeric(id) {
+		return new Function(id);
+	}
+	static fromString(name) {
+		return new Function(name);
+	}
+	toString() {
+		return typeof this.#id === "number" ? `«${this.#id}»` : `«"${this.#id}"»`;
+	}
+};
+var Parameter = class Parameter {
+	#id;
+	#value;
+	constructor(id, value) {
+		this.#id = id;
+		this.#value = value;
+	}
+	id() {
+		return this.#id;
+	}
+	value() {
+		return this.#value;
+	}
+	isNumeric() {
+		return typeof this.#id === "number";
+	}
+	isString() {
+		return typeof this.#id === "string";
+	}
+	envelope() {
+		const paramStr = typeof this.#id === "number" ? `❰${this.#id}❱` : `❰"${this.#id}"❱`;
+		return Envelope.newAssertion(paramStr, this.#value);
+	}
+	static blank(value) {
+		return new Parameter(PARAMETER_IDS.BLANK, Envelope.new(value));
+	}
+	static lhs(value) {
+		return new Parameter(PARAMETER_IDS.LHS, Envelope.new(value));
+	}
+	static rhs(value) {
+		return new Parameter(PARAMETER_IDS.RHS, Envelope.new(value));
+	}
+	toString() {
+		return `${typeof this.#id === "number" ? `❰${this.#id}❱` : `❰"${this.#id}"❱`}: ${this.#value.asText()}`;
+	}
+};
+var Expression = class Expression {
+	#function;
+	#parameters = /* @__PURE__ */ new Map();
+	#envelope = null;
+	constructor(func) {
+		this.#function = func;
+	}
+	function() {
+		return this.#function;
+	}
+	parameters() {
+		return Array.from(this.#parameters.values());
+	}
+	withParameter(param, value) {
+		const key = typeof param === "number" ? param.toString() : param;
+		this.#parameters.set(key, new Parameter(param, Envelope.new(value)));
+		this.#envelope = null;
+		return this;
+	}
+	withParameters(params) {
+		for (const [key, value] of Object.entries(params)) this.withParameter(key, value);
+		return this;
+	}
+	getParameter(param) {
+		const key = typeof param === "number" ? param.toString() : param;
+		return this.#parameters.get(key)?.value();
+	}
+	hasParameter(param) {
+		const key = typeof param === "number" ? param.toString() : param;
+		return this.#parameters.has(key);
+	}
+	envelope() {
+		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);
+			}
+		}
+		this.#envelope = env;
+		return env;
+	}
+	static fromEnvelope(envelope) {
+		const subjectText = envelope.subject().asText();
+		if (subjectText === void 0) throw EnvelopeError.general("Not a valid function envelope");
+		let funcId;
+		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);
+		} else throw EnvelopeError.general("Not a valid function envelope");
+		const expr = new Expression(new Function(funcId));
+		for (const assertion of envelope.assertions()) try {
+			const pred = assertion.subject().asPredicate();
+			const obj = assertion.subject().asObject();
+			if (pred !== void 0 && obj !== void 0) {
+				const predText = pred.asText();
+				if (predText !== void 0 && predText.startsWith("❰") && predText.endsWith("❱")) {
+					const inner = predText.slice(1, -1);
+					let paramId;
+					if (inner.startsWith("\"") && inner.endsWith("\"")) paramId = inner.slice(1, -1);
+					else paramId = parseInt(inner, 10);
+					expr.withParameter(paramId, obj);
+				}
+			}
+		} catch {
+			continue;
+		}
+		return expr;
+	}
+	toString() {
+		const params = Array.from(this.#parameters.values()).map((p) => p.toString()).join(", ");
+		return `${this.#function.toString()} [${params}]`;
+	}
+};
+function add(lhs, rhs) {
+	return Function.fromNumeric(FUNCTION_IDS.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);
+}
+function mul(lhs, rhs) {
+	return Function.fromNumeric(FUNCTION_IDS.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);
+}
+function neg(value) {
+	return Function.fromNumeric(FUNCTION_IDS.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);
+}
+function gt(lhs, rhs) {
+	return Function.fromNumeric(FUNCTION_IDS.GT).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);
+}
+function and(lhs, rhs) {
+	return Function.fromNumeric(FUNCTION_IDS.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);
+}
+function not(value) {
+	return Function.fromNumeric(FUNCTION_IDS.NOT).withParameter(PARAMETER_IDS.BLANK, value);
+}
+
+//#endregion
+//#region src/extension/proof.ts
+if (Envelope?.prototype) {
+	Envelope.prototype.proofContainsSet = function(target) {
+		const revealSet = revealSetOfSet(this, target);
+		if (!isSubset(target, revealSet)) return;
+		return this.elideRevealingSet(revealSet).elideRemovingSet(target);
+	};
+	Envelope.prototype.proofContainsTarget = function(target) {
+		const targetSet = new Set([target.digest()]);
+		return this.proofContainsSet(targetSet);
+	};
+	Envelope.prototype.confirmContainsSet = function(target, proof) {
+		if (this.digest().hex() !== proof.digest().hex()) return false;
+		return containsAll(proof, target);
+	};
+	Envelope.prototype.confirmContainsTarget = function(target, proof) {
+		const targetSet = new Set([target.digest()]);
+		return this.confirmContainsSet(targetSet, proof);
+	};
+}
+function revealSetOfSet(envelope, target) {
+	const result = /* @__PURE__ */ new Set();
+	revealSets(envelope, target, /* @__PURE__ */ new Set(), result);
+	return result;
+}
+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);
+	const envelopeCase = envelope.case();
+	if (envelopeCase.type === "node") {
+		revealSets(envelopeCase.subject, target, newCurrent, result);
+		for (const assertion of envelopeCase.assertions) revealSets(assertion, target, newCurrent, result);
+	} else if (envelopeCase.type === "wrapped") revealSets(envelopeCase.envelope, target, newCurrent, result);
+	else if (envelopeCase.type === "assertion") {
+		const predicate = envelopeCase.assertion.predicate();
+		const object = envelopeCase.assertion.object();
+		revealSets(predicate, target, newCurrent, result);
+		revealSets(object, target, newCurrent, result);
+	}
+}
+function containsAll(envelope, target) {
+	const targetCopy = new Set(target);
+	removeAllFound(envelope, targetCopy);
+	return targetCopy.size === 0;
+}
+function removeAllFound(envelope, target) {
+	if (containsDigest(target, envelope.digest())) removeDigest(target, envelope.digest());
+	if (target.size === 0) return;
+	const envelopeCase = envelope.case();
+	if (envelopeCase.type === "node") {
+		removeAllFound(envelopeCase.subject, target);
+		for (const assertion of envelopeCase.assertions) {
+			removeAllFound(assertion, target);
+			if (target.size === 0) break;
+		}
+	} else if (envelopeCase.type === "wrapped") removeAllFound(envelopeCase.envelope, target);
+	else if (envelopeCase.type === "assertion") {
+		const predicate = envelopeCase.assertion.predicate();
+		const object = envelopeCase.assertion.object();
+		removeAllFound(predicate, target);
+		if (target.size > 0) removeAllFound(object, target);
+	}
+}
+function containsDigest(set, digest) {
+	const hexToFind = digest.hex();
+	for (const d of set) if (d.hex() === hexToFind) return true;
+	return false;
+}
+function removeDigest(set, digest) {
+	const hexToFind = digest.hex();
+	for (const d of set) if (d.hex() === hexToFind) {
+		set.delete(d);
+		return;
+	}
+}
+function isSubset(subset, superset) {
+	for (const digest of subset) if (!containsDigest(superset, digest)) return false;
+	return true;
+}
+
+//#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 cborData(this.taggedCbor());
+};
+
+//#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(", ")}]`;
+	}
+	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 `{${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/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";
+	const elements = [];
+	this.walk(hideNodes, void 0, (envelope, level, incomingEdge, _state) => {
+		const digestStr = envelope.digest().short();
+		const isHighlighted = highlightDigests.has(digestStr);
+		elements.push({
+			level,
+			envelope,
+			incomingEdge,
+			showId: !hideNodes,
+			isHighlighted
+		});
+		return [void 0, false];
+	});
+	return elements.map((elem) => {
+		const parts = [];
+		if (elem.isHighlighted) parts.push("*");
+		if (elem.showId) parts.push(elem.envelope.shortId(digestDisplay));
+		const label = edgeLabel(elem.incomingEdge);
+		if (label !== void 0 && label !== "") parts.push(label);
+		parts.push(elem.envelope.summary(40));
+		const line = parts.join(" ");
+		return " ".repeat(elem.level * 4) + line;
+	}).join("\n");
+};
+
+//#endregion
+//#region src/utils/string.ts
+/**
+* String utility functions used throughout the envelope library.
+*
+* Provides helper methods for string formatting and manipulation.
+*/
+/**
+* Flanks a string with specified left and right delimiters.
+*
+* @param str - The string to flank
+* @param left - The left delimiter
+* @param right - The right delimiter
+* @returns The flanked string
+*
+* @example
+* ```typescript
+* flanked('hello', '"', '"')  // Returns: "hello"
+* flanked('name', "'", "'")   // Returns: 'name'
+* flanked('item', '[', ']')   // Returns: [item]
+* ```
+*/
+function flanked(str, left, right) {
+	return `${left}${str}${right}`;
+}
+String.prototype.flankedBy = function(left, right) {
+	return flanked(this, left, right);
+};
+
+//#endregion
+//#region src/index.ts
+registerEncryptExtension();
+registerCompressExtension();
+const VERSION = "0.37.0";
+
+//#endregion
+export { ATTACHMENT, Assertion, Attachments, CBOR_TAG_FUNCTION, CBOR_TAG_PARAMETER, CBOR_TAG_PLACEHOLDER, CBOR_TAG_REPLACEMENT, CONFORMS_TO, Compressed, Digest, EdgeType, EncryptedMessage, Envelope, EnvelopeCBORTagged, EnvelopeCBORTaggedDecodable, EnvelopeCBORTaggedEncodable, EnvelopeDecoder, EnvelopeError, ErrorCode, Expression, FUNCTION_IDS, Function, HAS_RECIPIENT, IS_A, NOTE, ObscureType, PARAMETER_IDS, Parameter, PrivateKeyBase, PublicKeyBase, SALT, SIGNED, SealedMessage, Signature, SignatureMetadata, SigningPrivateKey, SigningPublicKey, SymmetricKey, VENDOR, VERIFIED_BY, VERSION, add, and, div, edgeLabel, elideAction, envelopeFromBytes, envelopeFromCbor, envelopeToBytes, envelopeToCbor, eq, extractBoolean, extractBytes, extractNull, extractNumber, extractString, flanked, gt, isEnvelopeEncodable, lt, mul, neg, not, or, registerCompressExtension, registerEncryptExtension, sub };
+//# sourceMappingURL=index.mjs.map