@bcts/envelope-pattern 1.0.0-alpha.23 → 1.0.0-beta.0

package/dist/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _bcts_dcbor_pattern = require("@bcts/dcbor-pattern");
 let _bcts_known_values = require("@bcts/known-values");
-let _bcts_envelope = require("@bcts/envelope");
 let _bcts_dcbor = require("@bcts/dcbor");
+let _bcts_envelope = require("@bcts/envelope");
 let _bcts_dcbor_parse = require("@bcts/dcbor-parse");
 //#region src/error.ts
 /**
@@ -306,6 +306,14 @@ function formatPathsOpts() {
 /**
 * Gets a summary of an envelope for display.
 *
+* Mirrors Rust `envelope_summary` in `format.rs`: defers to
+* `Envelope::format_flat()` for nodes / wrapped / assertions and to
+* `cbor.envelope_summary(usize::MAX, ...)` for raw CBOR leaves. The
+* obscured cases (`elided` / `encrypted` / `compressed`) emit just the
+* keyword. KnownValue envelopes look up the canonical name via
+* `KnownValue.name()`, matching the Rust call to
+* `KnownValuesStore::known_value_for_raw_value(value, …)`.
+*
 * @param env - The envelope to summarize
 * @returns A string summary of the envelope
 */
@@ -314,25 +322,17 @@ function envelopeSummary(env) {
 	const c = env.case();
 	let summary;
 	switch (c.type) {
-		case "node": {
-			const subjectSummary = env.subject().summary(Number.MAX_SAFE_INTEGER);
-			const assertions = env.assertions();
-			if (assertions.length > 0) summary = `NODE ${subjectSummary} [ ${assertions.map((a) => {
-				const ac = a.case();
-				if (ac.type === "assertion") return `${ac.assertion.predicate().summary(Number.MAX_SAFE_INTEGER)}: ${ac.assertion.object().summary(Number.MAX_SAFE_INTEGER)}`;
-				return a.summary(Number.MAX_SAFE_INTEGER);
-			}).join(", ")} ]`;
-			else summary = `NODE ${subjectSummary}`;
+		case "node":
+			summary = `NODE ${env.formatFlat()}`;
 			break;
-		}
 		case "leaf":
 			summary = `LEAF ${env.summary(Number.MAX_SAFE_INTEGER)}`;
 			break;
 		case "wrapped":
-			summary = `WRAPPED ${env.summary(Number.MAX_SAFE_INTEGER)}`;
+			summary = `WRAPPED ${env.formatFlat()}`;
 			break;
 		case "assertion":
-			summary = `ASSERTION ${c.assertion.predicate().summary(Number.MAX_SAFE_INTEGER)}: ${c.assertion.object().summary(Number.MAX_SAFE_INTEGER)}`;
+			summary = `ASSERTION ${env.formatFlat()}`;
 			break;
 		case "elided":
 			summary = "ELIDED";
@@ -378,8 +378,8 @@ function formatPathOpt(path, opts = defaultFormatPathsOpts()) {
 		if (element === void 0) return "";
 		switch (opts.elementFormat.type) {
 			case "Summary": return truncateWithEllipsis(envelopeSummary(element), opts.elementFormat.maxLength);
-			case "EnvelopeUR": return element.digest().toString();
-			case "DigestUR": return element.digest().toString();
+			case "EnvelopeUR": return element.urString();
+			case "DigestUR": return element.digest().urString();
 		}
 	}
 	switch (opts.elementFormat.type) {
@@ -394,8 +394,8 @@ function formatPathOpt(path, opts = defaultFormatPathsOpts()) {
 			}
 			return lines.join("\n");
 		}
-		case "EnvelopeUR": return path.map((element) => element.digest().toString()).join(" ");
-		case "DigestUR": return path.map((element) => element.digest().toString()).join(" ");
+		case "EnvelopeUR": return path.map((element) => element.urString()).join(" ");
+		case "DigestUR": return path.map((element) => element.digest().urString()).join(" ");
 	}
 }
 /**
@@ -1237,25 +1237,16 @@ var DatePattern = class DatePattern {
 };
 //#endregion
 //#region src/pattern/leaf/array-pattern.ts
-/**
-* Copyright © 2023-2026 Blockchain Commons, LLC
-* Copyright © 2025-2026 Parity Technologies
-*
-*
-* @bcts/envelope-pattern - Array pattern matching
-*
-* This is a 1:1 TypeScript port of bc-envelope-pattern-rust array_pattern.rs
-*
-* @module envelope-pattern/pattern/leaf/array-pattern
-*/
 let createLeafArrayPattern;
 function registerArrayPatternFactory(factory) {
 	createLeafArrayPattern = factory;
 }
 /**
-* Pattern for matching array values in envelope leaf nodes.
+* Pattern for matching arrays.
 *
-* Corresponds to the Rust `ArrayPattern` struct in array_pattern.rs
+* Mirrors Rust `ArrayPattern(dcbor_pattern::ArrayPattern)` from
+* `bc-envelope-pattern-rust/src/pattern/leaf/array_pattern.rs`. All
+* matching, display, and equality is delegated to dcbor-pattern.
 */
 var ArrayPattern = class ArrayPattern {
 	_pattern;
@@ -1266,93 +1257,54 @@ var ArrayPattern = class ArrayPattern {
 	* Creates a new ArrayPattern that matches any array.
 	*/
 	static any() {
-		return new ArrayPattern({ type: "Any" });
+		return new ArrayPattern((0, _bcts_dcbor_pattern.arrayPatternAny)());
 	}
 	/**
 	* Creates a new ArrayPattern that matches arrays with a specific length.
 	*/
 	static count(count) {
-		return new ArrayPattern({
-			type: "Interval",
-			interval: _bcts_dcbor_pattern.Interval.exactly(count)
-		});
+		return new ArrayPattern((0, _bcts_dcbor_pattern.arrayPatternWithLength)(count));
 	}
 	/**
 	* Creates a new ArrayPattern that matches arrays within a length range.
 	*/
 	static interval(min, max) {
-		return new ArrayPattern({
-			type: "Interval",
-			interval: max !== void 0 ? _bcts_dcbor_pattern.Interval.from(min, max) : _bcts_dcbor_pattern.Interval.atLeast(min)
-		});
+		return new ArrayPattern((0, _bcts_dcbor_pattern.arrayPatternWithLengthRange)(min, max));
 	}
 	/**
-	* Creates a new ArrayPattern from a dcbor-pattern.
+	* Creates a new ArrayPattern from a length Interval.
 	*/
-	static fromDcborPattern(dcborPattern) {
-		return new ArrayPattern({
-			type: "DCBORPattern",
-			pattern: dcborPattern
-		});
+	static fromInterval(interval) {
+		return new ArrayPattern((0, _bcts_dcbor_pattern.arrayPatternWithLengthInterval)(interval));
 	}
 	/**
-	* Creates a new ArrayPattern with envelope patterns for element matching.
+	* Creates a new ArrayPattern from a top-level dcbor-pattern.
+	*
+	* Mirrors Rust `ArrayPattern::from_dcbor_pattern`, which constructs an
+	* `ArrayPattern::Elements`-style dcbor array pattern.
 	*/
-	static withPatterns(patterns) {
-		return new ArrayPattern({
-			type: "WithPatterns",
-			patterns
-		});
+	static fromDcborPattern(pattern) {
+		return new ArrayPattern((0, _bcts_dcbor_pattern.arrayPatternWithElements)(pattern));
 	}
 	/**
-	* Gets the pattern type.
+	* Creates a new ArrayPattern from an existing dcbor-pattern ArrayPattern.
+	*
+	* Mirrors Rust `ArrayPattern::from_dcbor_array_pattern`.
 	*/
-	get pattern() {
+	static fromDcborArrayPattern(arrayPattern) {
+		return new ArrayPattern(arrayPattern);
+	}
+	/**
+	* Returns the underlying dcbor-pattern ArrayPattern.
+	*/
+	inner() {
 		return this._pattern;
 	}
 	pathsWithCaptures(haystack) {
 		const cbor = haystack.subject().asLeaf();
 		if (cbor === void 0) return [[], /* @__PURE__ */ new Map()];
-		const array = (0, _bcts_dcbor.asCborArray)(cbor);
-		if (array === void 0) return [[], /* @__PURE__ */ new Map()];
-		switch (this._pattern.type) {
-			case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
-			case "Interval": {
-				const length = array.length;
-				if (this._pattern.interval.contains(length)) return [[[haystack]], /* @__PURE__ */ new Map()];
-				return [[], /* @__PURE__ */ new Map()];
-			}
-			case "DCBORPattern": {
-				const { paths: dcborPaths, captures: dcborCaptures } = (0, _bcts_dcbor_pattern.patternPathsWithCaptures)(this._pattern.pattern, cbor);
-				if (dcborPaths.length > 0) {
-					const envelopePaths = dcborPaths.map((dcborPath) => {
-						const envPath = [haystack];
-						for (let i = 1; i < dcborPath.length; i++) {
-							const elem = dcborPath[i];
-							if (elem !== void 0) envPath.push(_bcts_envelope.Envelope.newLeaf(elem));
-						}
-						return envPath;
-					});
-					const envelopeCaptures = /* @__PURE__ */ new Map();
-					for (const [name, capturePaths] of dcborCaptures) {
-						const envCapturePaths = capturePaths.map((dcborPath) => {
-							const envPath = [haystack];
-							for (let i = 1; i < dcborPath.length; i++) {
-								const elem = dcborPath[i];
-								if (elem !== void 0) envPath.push(_bcts_envelope.Envelope.newLeaf(elem));
-							}
-							return envPath;
-						});
-						envelopeCaptures.set(name, envCapturePaths);
-					}
-					return [envelopePaths, envelopeCaptures];
-				}
-				return [[], /* @__PURE__ */ new Map()];
-			}
-			case "WithPatterns":
-				if (array.length === this._pattern.patterns.length) return [[[haystack]], /* @__PURE__ */ new Map()];
-				return [[], /* @__PURE__ */ new Map()];
-		}
+		if ((0, _bcts_dcbor_pattern.arrayPatternMatches)(this._pattern, cbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
+		return [[], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -1368,54 +1320,31 @@ var ArrayPattern = class ArrayPattern {
 		return false;
 	}
 	toString() {
-		switch (this._pattern.type) {
-			case "Any": return "[*]";
-			case "Interval": return `[{${this._pattern.interval.toString()}}]`;
-			case "DCBORPattern": return (0, _bcts_dcbor_pattern.patternDisplay)(this._pattern.pattern);
-			case "WithPatterns": return `[${this._pattern.patterns.map(String).join(", ")}]`;
-		}
+		return (0, _bcts_dcbor_pattern.arrayPatternDisplay)(this._pattern, _bcts_dcbor_pattern.patternDisplay);
 	}
 	/**
-	* Equality comparison.
+	* Equality comparison. Delegates to dcbor-pattern's structural equality
+	* with a display-string fallback for pattern-equality (mirrors Rust's
+	* `Hash` impl that hashes the display, since dcbor `ArrayPattern`
+	* itself does not derive `Hash`).
 	*/
 	equals(other) {
-		if (this._pattern.type !== other._pattern.type) return false;
-		switch (this._pattern.type) {
-			case "Any": return true;
-			case "Interval": return this._pattern.interval.equals(other._pattern.interval);
-			case "DCBORPattern": return (0, _bcts_dcbor_pattern.patternDisplay)(this._pattern.pattern) === (0, _bcts_dcbor_pattern.patternDisplay)(other._pattern.pattern);
-			case "WithPatterns": {
-				const otherPatterns = other._pattern.patterns;
-				if (this._pattern.patterns.length !== otherPatterns.length) return false;
-				for (let i = 0; i < this._pattern.patterns.length; i++) if (this._pattern.patterns[i] !== otherPatterns[i]) return false;
-				return true;
-			}
-		}
+		return (0, _bcts_dcbor_pattern.arrayPatternEquals)(this._pattern, other._pattern, (a, b) => (0, _bcts_dcbor_pattern.patternDisplay)(a) === (0, _bcts_dcbor_pattern.patternDisplay)(b));
 	}
 	/**
-	* Hash code for use in Maps/Sets.
+	* Hash code for use in Maps/Sets. Mirrors Rust's
+	* "hash the string representation" approach.
 	*/
 	hashCode() {
-		switch (this._pattern.type) {
-			case "Any": return 0;
-			case "Interval": return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
-			case "DCBORPattern": return simpleStringHash$3((0, _bcts_dcbor_pattern.patternDisplay)(this._pattern.pattern));
-			case "WithPatterns": return this._pattern.patterns.length;
+		let hash = 0;
+		const str = this.toString();
+		for (let i = 0; i < str.length; i++) {
+			hash = (hash << 5) - hash + str.charCodeAt(i);
+			hash = hash & hash;
 		}
+		return hash;
 	}
 };
-/**
-* Simple string hash function for hashCode implementations.
-*/
-function simpleStringHash$3(str) {
-	let hash = 0;
-	for (let i = 0; i < str.length; i++) {
-		const char = str.charCodeAt(i);
-		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
-	}
-	return hash;
-}
 //#endregion
 //#region src/pattern/leaf/map-pattern.ts
 let createLeafMapPattern;
@@ -1448,6 +1377,19 @@ var MapPattern = class MapPattern {
 		});
 	}
 	/**
+	* Creates a new MapPattern from a length Interval.
+	*
+	* Mirrors Rust `MapPattern::from_interval`. Used by the
+	* dcbor-pattern → envelope-pattern bridge to preserve `{{n,m}}`
+	* length info.
+	*/
+	static fromInterval(interval) {
+		return new MapPattern({
+			type: "Interval",
+			interval
+		});
+	}
+	/**
 	* Gets the pattern type.
 	*/
 	get pattern() {
@@ -1482,8 +1424,8 @@ var MapPattern = class MapPattern {
 	}
 	toString() {
 		switch (this._pattern.type) {
-			case "Any": return "{*}";
-			case "Interval": return `{{${this._pattern.interval.toString()}}}`;
+			case "Any": return "map";
+			case "Interval": return `{${this._pattern.interval.toString()}}`;
 		}
 	}
 	/**
@@ -1736,7 +1678,7 @@ var TaggedPattern = class TaggedPattern {
 		return false;
 	}
 	toString() {
-		return (0, _bcts_dcbor_pattern.taggedPatternDisplay)(this._inner, _bcts_dcbor_pattern.patternDisplay);
+		return (0, _bcts_dcbor_pattern.taggedPatternDisplay)(this._inner, _bcts_dcbor_pattern.patternDisplay).replace(",  ", ", ");
 	}
 	/**
 	* Equality comparison.
@@ -1862,10 +1804,18 @@ var CBORPattern = class CBORPattern {
 	}
 	/**
 	* Convert a single dcbor path to an envelope path.
+	*
+	* Uses canonical CBOR-byte equality (`cborEquals`) for the "skip the
+	* dcbor root if it duplicates our base envelope" check, mirroring
+	* Rust's `dcbor_path.first().map(|first| first == &base_cbor)`. The
+	* earlier port compared diagnostic strings, which collapses values
+	* that share a textual representation but differ structurally
+	* (e.g. NaN payloads).
 	*/
 	_convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor) {
 		const envelopePath = [baseEnvelope];
-		const elementsToAdd = dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === baseCbor.toDiagnostic() ? dcborPath.slice(1) : dcborPath;
+		const first = dcborPath[0];
+		const elementsToAdd = first !== void 0 && (0, _bcts_dcbor.cborEquals)(first, baseCbor) ? dcborPath.slice(1) : dcborPath;
 		for (const cborElement of elementsToAdd) envelopePath.push(_bcts_envelope.Envelope.newLeaf(cborElement));
 		return envelopePath;
 	}
@@ -1892,7 +1842,7 @@ var CBORPattern = class CBORPattern {
 			switch (this._pattern.type) {
 				case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 				case "Value":
-					if (knownValueCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
+					if ((0, _bcts_dcbor.cborEquals)(knownValueCbor, this._pattern.cbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 					return [[], /* @__PURE__ */ new Map()];
 				case "Pattern": {
 					const { paths: dcborPaths, captures: dcborCaptures } = (0, _bcts_dcbor_pattern.patternPathsWithCaptures)(this._pattern.pattern, knownValueCbor);
@@ -1916,7 +1866,7 @@ var CBORPattern = class CBORPattern {
 		switch (this._pattern.type) {
 			case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
 			case "Value":
-				if (leafCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) return [[[haystack]], /* @__PURE__ */ new Map()];
+				if ((0, _bcts_dcbor.cborEquals)(leafCbor, this._pattern.cbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 				return [[], /* @__PURE__ */ new Map()];
 			case "Pattern": {
 				const { paths: dcborPaths, captures: dcborCaptures } = (0, _bcts_dcbor_pattern.patternPathsWithCaptures)(this._pattern.pattern, leafCbor);
@@ -1924,7 +1874,8 @@ var CBORPattern = class CBORPattern {
 					const basePath = [haystack];
 					return [dcborPaths.map((dcborPath) => {
 						const extendedPath = [...basePath];
-						const elementsToAdd = dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === leafCbor.toDiagnostic() ? dcborPath.slice(1) : dcborPath;
+						const first = dcborPath[0];
+						const elementsToAdd = first !== void 0 && (0, _bcts_dcbor.cborEquals)(first, leafCbor) ? dcborPath.slice(1) : dcborPath;
 						for (const cborElement of elementsToAdd) extendedPath.push(_bcts_envelope.Envelope.newLeaf(cborElement));
 						return extendedPath;
 					}), this._convertDcborCapturesToEnvelopeCaptures(dcborCaptures, haystack, leafCbor)];
@@ -1959,13 +1910,16 @@ var CBORPattern = class CBORPattern {
 		}
 	}
 	/**
-	* Equality comparison.
+	* Equality comparison. `Value` variants compare by canonical CBOR
+	* byte sequence (mirrors Rust `==` on `CBOR`); `Pattern` variants fall
+	* back to display-string compare since `DCBORPattern` doesn't expose
+	* structural equality outside the crate.
 	*/
 	equals(other) {
 		if (this._pattern.type !== other._pattern.type) return false;
 		switch (this._pattern.type) {
 			case "Any": return true;
-			case "Value": return this._pattern.cbor.toDiagnostic() === other._pattern.cbor.toDiagnostic();
+			case "Value": return (0, _bcts_dcbor.cborEquals)(this._pattern.cbor, other._pattern.cbor);
 			case "Pattern": return (0, _bcts_dcbor_pattern.patternDisplay)(this._pattern.pattern) === (0, _bcts_dcbor_pattern.patternDisplay)(other._pattern.pattern);
 		}
 	}
@@ -1975,7 +1929,12 @@ var CBORPattern = class CBORPattern {
 	hashCode() {
 		switch (this._pattern.type) {
 			case "Any": return 0;
-			case "Value": return simpleStringHash(this._pattern.cbor.toDiagnostic());
+			case "Value": {
+				const bytes = (0, _bcts_dcbor.cborData)(this._pattern.cbor);
+				let hash = 0;
+				for (const byte of bytes) hash = hash * 31 + byte | 0;
+				return hash;
+			}
 			case "Pattern": return simpleStringHash((0, _bcts_dcbor_pattern.patternDisplay)(this._pattern.pattern));
 		}
 	}
@@ -2244,7 +2203,13 @@ var LeafStructurePattern = class LeafStructurePattern {
 		return 0;
 	}
 };
+let dispatchPatternCompile$1;
+let dispatchPatternToString$3;
 function registerSubjectPatternFactory(factory) {}
+function registerSubjectPatternDispatch(dispatch) {
+	dispatchPatternCompile$1 = dispatch.compile;
+	dispatchPatternToString$3 = dispatch.toString;
+}
 /**
 * Pattern for matching subjects in envelopes.
 *
@@ -2308,9 +2273,10 @@ var SubjectPattern = class SubjectPattern {
 				code.push({ type: "NavigateSubject" });
 				break;
 			case "Pattern":
+				if (dispatchPatternCompile$1 === void 0) throw new Error("SubjectPattern.compile requires the top-level Pattern compile dispatch; not registered");
 				code.push({ type: "NavigateSubject" });
 				code.push({ type: "ExtendTraversal" });
-				this._pattern.pattern.compile(code, literals, captures);
+				dispatchPatternCompile$1(this._pattern.pattern, code, literals, captures);
 				code.push({ type: "CombineTraversal" });
 				break;
 		}
@@ -2321,7 +2287,10 @@ var SubjectPattern = class SubjectPattern {
 	toString() {
 		switch (this._pattern.type) {
 			case "Any": return "subj";
-			case "Pattern": return `subj(${this._pattern.pattern.toString()})`;
+			case "Pattern": {
+				const fmt = dispatchPatternToString$3;
+				return `subj(${fmt !== void 0 ? fmt(this._pattern.pattern) : "?"})`;
+			}
 		}
 	}
 	/**
@@ -2418,7 +2387,7 @@ var PredicatePattern = class PredicatePattern {
 	toString() {
 		switch (this._pattern.type) {
 			case "Any": return "pred";
-			case "Pattern": return `pred(${this._pattern.pattern.toString()})`;
+			case "Pattern": return `pred(${dispatchPatternToString(this._pattern.pattern)})`;
 		}
 	}
 	/**
@@ -2515,7 +2484,7 @@ var ObjectPattern = class ObjectPattern {
 	toString() {
 		switch (this._pattern.type) {
 			case "Any": return "obj";
-			case "Pattern": return `obj(${this._pattern.pattern.toString()})`;
+			case "Pattern": return `obj(${dispatchPatternToString(this._pattern.pattern)})`;
 		}
 	}
 	/**
@@ -2536,9 +2505,13 @@ var ObjectPattern = class ObjectPattern {
 //#endregion
 //#region src/pattern/structure/assertions-pattern.ts
 let createStructureAssertionsPattern;
+let dispatchPatternToString$2;
 function registerAssertionsPatternFactory(factory) {
 	createStructureAssertionsPattern = factory;
 }
+function registerAssertionsPatternToStringDispatch(fn) {
+	dispatchPatternToString$2 = fn;
+}
 /**
 * Pattern for matching assertions in envelopes.
 *
@@ -2576,17 +2549,6 @@ var AssertionsPattern = class AssertionsPattern {
 		});
 	}
 	/**
-	* Creates a new AssertionsPattern that matches assertions with both
-	* predicate and object patterns.
-	*/
-	static withBoth(predicatePattern, objectPattern) {
-		return new AssertionsPattern({
-			type: "WithBoth",
-			predicatePattern,
-			objectPattern
-		});
-	}
-	/**
 	* Gets the pattern type.
 	*/
 	get patternType() {
@@ -2597,14 +2559,12 @@ var AssertionsPattern = class AssertionsPattern {
 	*/
 	predicatePattern() {
 		if (this._pattern.type === "WithPredicate") return this._pattern.pattern;
-		if (this._pattern.type === "WithBoth") return this._pattern.predicatePattern;
 	}
 	/**
 	* Gets the object pattern if this has one, undefined otherwise.
 	*/
 	objectPattern() {
 		if (this._pattern.type === "WithObject") return this._pattern.pattern;
-		if (this._pattern.type === "WithBoth") return this._pattern.objectPattern;
 	}
 	pathsWithCaptures(haystack) {
 		const paths = [];
@@ -2626,14 +2586,6 @@ var AssertionsPattern = class AssertionsPattern {
 				}
 				break;
 			}
-			case "WithBoth": {
-				const predicate = assertion.asPredicate?.();
-				const object = assertion.asObject?.();
-				if (predicate !== void 0 && object !== void 0) {
-					if (matchPattern(this._pattern.predicatePattern, predicate) && matchPattern(this._pattern.objectPattern, object)) paths.push([assertion]);
-				}
-				break;
-			}
 		}
 		return [paths, /* @__PURE__ */ new Map()];
 	}
@@ -2656,11 +2608,11 @@ var AssertionsPattern = class AssertionsPattern {
 		return false;
 	}
 	toString() {
+		const fmt = dispatchPatternToString$2;
 		switch (this._pattern.type) {
 			case "Any": return "assert";
-			case "WithPredicate": return `assertpred(${this._pattern.pattern.toString()})`;
-			case "WithObject": return `assertobj(${this._pattern.pattern.toString()})`;
-			case "WithBoth": return `assert(${this._pattern.predicatePattern.toString()}, ${this._pattern.objectPattern.toString()})`;
+			case "WithPredicate": return `assertpred(${fmt !== void 0 ? fmt(this._pattern.pattern) : "?"})`;
+			case "WithObject": return `assertobj(${fmt !== void 0 ? fmt(this._pattern.pattern) : "?"})`;
 		}
 	}
 	/**
@@ -2672,10 +2624,6 @@ var AssertionsPattern = class AssertionsPattern {
 			case "Any": return true;
 			case "WithPredicate":
 			case "WithObject": return this._pattern.pattern === other._pattern.pattern;
-			case "WithBoth": {
-				const otherBoth = other._pattern;
-				return this._pattern.predicatePattern === otherBoth.predicatePattern && this._pattern.objectPattern === otherBoth.objectPattern;
-			}
 		}
 	}
 	/**
@@ -2686,7 +2634,6 @@ var AssertionsPattern = class AssertionsPattern {
 			case "Any": return 0;
 			case "WithPredicate": return 1;
 			case "WithObject": return 2;
-			case "WithBoth": return 3;
 		}
 	}
 };
@@ -2715,12 +2662,6 @@ var DigestPattern = class DigestPattern {
 		this._pattern = pattern;
 	}
 	/**
-	* Creates a new DigestPattern that matches any digest.
-	*/
-	static any() {
-		return new DigestPattern({ type: "Any" });
-	}
-	/**
 	* Creates a new DigestPattern that matches the exact digest.
 	*/
 	static digest(digest) {
@@ -2758,9 +2699,6 @@ var DigestPattern = class DigestPattern {
 		const digestData = digest.data();
 		let isHit = false;
 		switch (this._pattern.type) {
-			case "Any":
-				isHit = true;
-				break;
 			case "Digest":
 				isHit = digest.equals(this._pattern.digest);
 				break;
@@ -2798,7 +2736,6 @@ var DigestPattern = class DigestPattern {
 	}
 	toString() {
 		switch (this._pattern.type) {
-			case "Any": return "digest";
 			case "Digest": return `digest(${this._pattern.digest.hex()})`;
 			case "Prefix": return `digest(${(0, _bcts_dcbor.bytesToHex)(this._pattern.prefix)})`;
 			case "BinaryRegex": return `digest(/${this._pattern.regex.source}/)`;
@@ -2806,17 +2743,26 @@ var DigestPattern = class DigestPattern {
 	}
 	/**
 	* Equality comparison.
+	*
+	* `Prefix` comparison is case-insensitive on the *hex representation* to
+	* mirror Rust's `eq_ignore_ascii_case` (which compares the underlying
+	* `Vec<u8>` of hex bytes byte-for-byte modulo ASCII case). For raw byte
+	* prefixes that happen to be ASCII, this is an ordinary byte compare.
 	*/
 	equals(other) {
 		if (this._pattern.type !== other._pattern.type) return false;
 		switch (this._pattern.type) {
-			case "Any": return true;
 			case "Digest": return this._pattern.digest.equals(other._pattern.digest);
 			case "Prefix": {
 				const thisPrefix = this._pattern.prefix;
 				const otherPrefix = other._pattern.prefix;
 				if (thisPrefix.length !== otherPrefix.length) return false;
-				for (let i = 0; i < thisPrefix.length; i++) if (thisPrefix[i] !== otherPrefix[i]) return false;
+				for (let i = 0; i < thisPrefix.length; i++) {
+					const a = thisPrefix[i];
+					const b = otherPrefix[i];
+					if (a === b) continue;
+					if ((a >= 65 && a <= 90 ? a + 32 : a) !== (b >= 65 && b <= 90 ? b + 32 : b)) return false;
+				}
 				return true;
 			}
 			case "BinaryRegex": return this._pattern.regex.source === other._pattern.regex.source;
@@ -2827,7 +2773,6 @@ var DigestPattern = class DigestPattern {
 	*/
 	hashCode() {
 		switch (this._pattern.type) {
-			case "Any": return 0;
 			case "Digest": {
 				const data = this._pattern.digest.data().slice(0, 8);
 				let hash = 0;
@@ -2836,7 +2781,10 @@ var DigestPattern = class DigestPattern {
 			}
 			case "Prefix": {
 				let hash = 0;
-				for (const byte of this._pattern.prefix) hash = hash * 31 + byte | 0;
+				for (const byte of this._pattern.prefix) {
+					const folded = byte >= 65 && byte <= 90 ? byte + 32 : byte;
+					hash = hash * 31 + folded | 0;
+				}
 				return hash;
 			}
 			case "BinaryRegex": {
@@ -2888,28 +2836,19 @@ var NodePattern = class NodePattern {
 		});
 	}
 	/**
-	* Creates a new NodePattern with a subject pattern constraint.
-	*/
-	static withSubject(subjectPattern) {
-		return new NodePattern({
-			type: "WithSubject",
-			subjectPattern
-		});
-	}
-	/**
 	* Gets the pattern type.
 	*/
 	get patternType() {
 		return this._pattern;
 	}
 	/**
-	* Gets the subject pattern if this is a WithSubject type, undefined otherwise.
+	* Returns the subject pattern, if any. Rust's `NodePattern` does not carry
+	* subject patterns, so this always returns `undefined`.
 	*/
-	subjectPattern() {
-		return this._pattern.type === "WithSubject" ? this._pattern.subjectPattern : void 0;
-	}
+	subjectPattern() {}
 	/**
-	* Gets the assertion patterns (empty array if none).
+	* Returns the assertion patterns. Rust's `NodePattern` does not carry
+	* assertion sub-patterns, so this always returns an empty array.
 	*/
 	assertionPatterns() {
 		return [];
@@ -2924,9 +2863,6 @@ var NodePattern = class NodePattern {
 			case "AssertionsInterval":
 				isHit = this._pattern.interval.contains(haystack.assertions().length);
 				break;
-			case "WithSubject":
-				isHit = true;
-				break;
 		}
 		return [isHit ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
@@ -2947,7 +2883,6 @@ var NodePattern = class NodePattern {
 		switch (this._pattern.type) {
 			case "Any": return "node";
 			case "AssertionsInterval": return `node(${this._pattern.interval.toString()})`;
-			case "WithSubject": return `node(${this._pattern.subjectPattern.toString()})`;
 		}
 	}
 	/**
@@ -2958,7 +2893,6 @@ var NodePattern = class NodePattern {
 		switch (this._pattern.type) {
 			case "Any": return true;
 			case "AssertionsInterval": return this._pattern.interval.equals(other._pattern.interval);
-			case "WithSubject": return this._pattern.subjectPattern === other._pattern.subjectPattern;
 		}
 	}
 	/**
@@ -2968,7 +2902,6 @@ var NodePattern = class NodePattern {
 		switch (this._pattern.type) {
 			case "Any": return 0;
 			case "AssertionsInterval": return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
-			case "WithSubject": return 1;
 		}
 	}
 };
@@ -3078,12 +3011,16 @@ var ObscuredPattern = class ObscuredPattern {
 //#endregion
 //#region src/pattern/structure/wrapped-pattern.ts
 let createStructureWrappedPattern;
+let createAnyPattern;
 let dispatchPatternPathsWithCaptures;
 let dispatchPatternCompile;
 let dispatchPatternToString$1;
 function registerWrappedPatternFactory(factory) {
 	createStructureWrappedPattern = factory;
 }
+function registerWrappedPatternAny(factory) {
+	createAnyPattern = factory;
+}
 function registerWrappedPatternDispatch(dispatch) {
 	dispatchPatternPathsWithCaptures = dispatch.pathsWithCaptures;
 	dispatchPatternCompile = dispatch.compile;
@@ -3117,10 +3054,15 @@ var WrappedPattern = class WrappedPattern {
 	}
 	/**
 	* Creates a new WrappedPattern that matches any wrapped envelope and descends into it.
-	* Note: This requires Pattern.any() to be available, so it's set up during registration.
+	*
+	* Mirrors Rust `WrappedPattern::unwrap()` which delegates to
+	* `Self::unwrap_matching(Pattern::any())`. The `any` factory is wired in
+	* during module-load registration to break the circular import on the
+	* top-level `Pattern` type.
 	*/
 	static unwrap() {
-		return new WrappedPattern({ type: "Any" });
+		if (createAnyPattern === void 0) throw new Error("WrappedPattern.unwrap() requires Pattern.any factory; not registered");
+		return WrappedPattern.unwrapMatching(createAnyPattern());
 	}
 	/**
 	* Gets the pattern type.
@@ -3196,9 +3138,9 @@ var WrappedPattern = class WrappedPattern {
 		switch (this._pattern.type) {
 			case "Any": return "wrapped";
 			case "Unwrap": {
-				const patternStr = dispatchPatternToString$1 !== void 0 ? dispatchPatternToString$1(this._pattern.pattern) : "*";
-				if (patternStr === "*") return "unwrap";
-				return `unwrap(${patternStr})`;
+				const inner = this._pattern.pattern;
+				if (inner.type === "Meta" && inner.pattern.type === "Any") return "unwrap";
+				return `unwrap(${dispatchPatternToString$1 !== void 0 ? dispatchPatternToString$1(inner) : "?"})`;
 			}
 		}
 	}
@@ -3422,10 +3364,7 @@ function axisChildren(axis, env) {
 		case "Wrapped":
 			if (envCase.type === "node") {
 				const subject = envCase.subject;
-				if (subject.isWrapped()) {
-					const unwrapped = subject.unwrap();
-					if (unwrapped !== void 0) return [[unwrapped, "Content"]];
-				}
+				if (subject.isWrapped()) return [[subject.tryUnwrap(), "Content"]];
 			} else if (envCase.type === "wrapped") return [[envCase.envelope, "Content"]];
 			return [];
 	}
@@ -4423,30 +4362,20 @@ var SearchPattern = class SearchPattern {
 		return [uniquePaths, /* @__PURE__ */ new Map()];
 	}
 	/**
-	* Walk the envelope tree recursively.
+	* Walk the envelope tree using the canonical `Envelope.walk` traversal.
+	*
+	* Mirrors Rust `bc_envelope::Envelope::walk(false, vec![], visitor)`
+	* which is what `SearchPattern::paths_with_captures` uses. The earlier
+	* port hand-rolled a recursion that double-recursed assertions and
+	* stepped through wrapped subjects manually, producing a different
+	* path order (and extra duplicates that the digest-set deduplication
+	* would partially mask).
 	*/
 	_walkEnvelope(envelope, pathToCurrent, visitor) {
-		visitor(envelope, pathToCurrent);
-		const subject = envelope.subject();
-		const newPath = [...pathToCurrent, envelope];
-		if (!subject.digest().equals(envelope.digest())) this._walkEnvelope(subject, newPath, visitor);
-		for (const assertion of envelope.assertions()) {
-			this._walkEnvelope(assertion, newPath, visitor);
-			const predicate = assertion.asPredicate?.();
-			if (predicate !== void 0) {
-				const assertionPath = [...newPath, assertion];
-				this._walkEnvelope(predicate, assertionPath, visitor);
-			}
-			const object = assertion.asObject?.();
-			if (object !== void 0) {
-				const assertionPath = [...newPath, assertion];
-				this._walkEnvelope(object, assertionPath, visitor);
-			}
-		}
-		if (subject.isWrapped()) {
-			const unwrapped = subject.tryUnwrap?.();
-			if (unwrapped !== void 0) this._walkEnvelope(unwrapped, newPath, visitor);
-		}
+		envelope.walk(false, pathToCurrent, (current, _level, _edge, state) => {
+			visitor(current, state);
+			return [[...state, current], false];
+		});
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -4575,7 +4504,7 @@ var TraversePattern = class TraversePattern {
 		return _patternIsComplex(this._first) || this._rest !== void 0;
 	}
 	toString() {
-		return this.patterns().map((p) => p.toString()).join(" -> ");
+		return this.patterns().map((p) => dispatchPatternToString(p)).join(" -> ");
 	}
 	/**
 	* Equality comparison.
@@ -4924,17 +4853,44 @@ function convertValuePatternToEnvelopePattern(valuePattern) {
 */
 function convertStructurePatternToEnvelopePattern(structurePattern) {
 	switch (structurePattern.type) {
-		case "Array": return ok({
-			type: "Leaf",
-			pattern: leafArray(ArrayPattern.fromDcborPattern({
-				kind: "Structure",
-				pattern: structurePattern
-			}))
-		});
-		case "Map": return ok({
-			type: "Leaf",
-			pattern: leafMap(MapPattern.any())
-		});
+		case "Array": {
+			const inner = structurePattern.pattern;
+			let arrayPattern;
+			switch (inner.variant) {
+				case "Any":
+					arrayPattern = ArrayPattern.any();
+					break;
+				case "Length":
+					arrayPattern = ArrayPattern.fromInterval(inner.length);
+					break;
+				case "Elements":
+					arrayPattern = ArrayPattern.fromDcborArrayPattern(inner);
+					break;
+			}
+			return ok({
+				type: "Leaf",
+				pattern: leafArray(arrayPattern)
+			});
+		}
+		case "Map": {
+			const inner = structurePattern.pattern;
+			let mapPattern;
+			switch (inner.variant) {
+				case "Any":
+					mapPattern = MapPattern.any();
+					break;
+				case "Length":
+					mapPattern = MapPattern.fromInterval(inner.length);
+					break;
+				case "Constraints":
+					mapPattern = MapPattern.any();
+					break;
+			}
+			return ok({
+				type: "Leaf",
+				pattern: leafMap(mapPattern)
+			});
+		}
 		case "Tagged": return ok({
 			type: "Leaf",
 			pattern: leafTag(TaggedPattern.fromDcborPattern(structurePattern.pattern))
@@ -4992,6 +4948,169 @@ function convertMetaPatternToEnvelopePattern(metaPattern, originalPattern) {
 	}
 }
 //#endregion
+//#region src/parse/utils.ts
+let createCborPattern;
+let createCborPatternFromDcbor;
+let createAnyArray;
+let createArrayWithCount;
+let createArrayWithRange;
+let createArrayFromDcborPattern;
+/**
+* Register pattern factory functions.
+* This is called by the pattern module to avoid circular dependencies.
+*/
+function registerPatternFactories(factories) {
+	createCborPattern = factories.cborPattern;
+	createCborPatternFromDcbor = factories.cborPatternFromDcbor;
+	createAnyArray = factories.anyArray;
+	createArrayWithCount = factories.arrayWithCount;
+	createArrayWithRange = factories.arrayWithRange;
+	createArrayFromDcborPattern = factories.arrayFromDcborPattern;
+}
+/**
+* Skips whitespace in the source string.
+*
+* @param src - The source string
+* @param pos - The current position (modified in place)
+*/
+function skipWs$1(src, pos) {
+	while (pos.value < src.length) {
+		const ch = src[pos.value];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f") pos.value++;
+		else break;
+	}
+}
+/**
+* Parses a CBOR value or dcbor-pattern expression.
+*
+* @param src - The source string
+* @returns The parsed pattern and consumed character count, or an error
+*/
+function parseCborInner(src) {
+	if (createCborPattern === void 0 || createCborPatternFromDcbor === void 0) return err(unknown());
+	const pos = { value: 0 };
+	skipWs$1(src, pos);
+	if (src[pos.value] === "/") {
+		pos.value++;
+		const start = pos.value;
+		let escape = false;
+		while (pos.value < src.length) {
+			const b = src[pos.value];
+			pos.value++;
+			if (escape) {
+				escape = false;
+				continue;
+			}
+			if (b === "\\") {
+				escape = true;
+				continue;
+			}
+			if (b === "/") {
+				const parseResult = (0, _bcts_dcbor_pattern.parse)(src.slice(start, pos.value - 1));
+				if (!parseResult.ok) return err(invalidPattern({
+					start,
+					end: pos.value - 1
+				}));
+				skipWs$1(src, pos);
+				return ok([createCborPatternFromDcbor(parseResult.value), pos.value]);
+			}
+		}
+		return err(unterminatedRegex({
+			start: start - 1,
+			end: pos.value
+		}));
+	}
+	if (src.slice(pos.value, pos.value + 3) === "ur:") {
+		const parseResult = (0, _bcts_dcbor_parse.parseDcborItemPartial)(src.slice(pos.value));
+		if (!parseResult.ok) return err(unknown());
+		const [cborValue, consumed] = parseResult.value;
+		return ok([createCborPattern(cborValue), pos.value + consumed]);
+	}
+	const parseResult = (0, _bcts_dcbor_parse.parseDcborItemPartial)(src.slice(pos.value));
+	if (!parseResult.ok) return err(unknown());
+	const [cborValue, consumed] = parseResult.value;
+	return ok([createCborPattern(cborValue), pos.value + consumed]);
+}
+/**
+* Parses an array pattern inner content.
+*
+* @param src - The source string (content between [ and ])
+* @returns The parsed pattern and consumed character count, or an error
+*/
+function parseArrayInner(src) {
+	if (createAnyArray === void 0 || createArrayWithCount === void 0 || createArrayWithRange === void 0 || createArrayFromDcborPattern === void 0) return err(unknown());
+	const pos = { value: 0 };
+	skipWs$1(src, pos);
+	if (src[pos.value] === "*") {
+		pos.value++;
+		skipWs$1(src, pos);
+		return ok([createAnyArray(), pos.value]);
+	}
+	if (src[pos.value] === "{") {
+		pos.value++;
+		skipWs$1(src, pos);
+		const startPos = pos.value;
+		while (pos.value < src.length && src[pos.value] !== void 0 && /\d/.test(src[pos.value])) pos.value++;
+		if (startPos === pos.value) return err(invalidRange({
+			start: pos.value,
+			end: pos.value
+		}));
+		const firstNum = parseInt(src.slice(startPos, pos.value), 10);
+		if (Number.isNaN(firstNum)) return err(invalidNumberFormat({
+			start: startPos,
+			end: pos.value
+		}));
+		skipWs$1(src, pos);
+		if (pos.value >= src.length) return err(unexpectedEndOfInput());
+		const ch = src[pos.value];
+		if (ch === "}") {
+			pos.value++;
+			skipWs$1(src, pos);
+			return ok([createArrayWithCount(firstNum), pos.value]);
+		}
+		if (ch === ",") {
+			pos.value++;
+			skipWs$1(src, pos);
+			if (pos.value >= src.length) return err(unexpectedEndOfInput());
+			const nextCh = src[pos.value];
+			if (nextCh === "}") {
+				pos.value++;
+				skipWs$1(src, pos);
+				return ok([createArrayWithRange(firstNum, void 0), pos.value]);
+			}
+			if (nextCh !== void 0 && /\d/.test(nextCh)) {
+				const secondStart = pos.value;
+				while (pos.value < src.length && src[pos.value] !== void 0 && /\d/.test(src[pos.value])) pos.value++;
+				const secondNum = parseInt(src.slice(secondStart, pos.value), 10);
+				if (Number.isNaN(secondNum)) return err(invalidNumberFormat({
+					start: secondStart,
+					end: pos.value
+				}));
+				skipWs$1(src, pos);
+				if (pos.value >= src.length || src[pos.value] !== "}") return err(unexpectedEndOfInput());
+				pos.value++;
+				skipWs$1(src, pos);
+				return ok([createArrayWithRange(firstNum, secondNum), pos.value]);
+			}
+			return err(invalidRange({
+				start: pos.value,
+				end: pos.value
+			}));
+		}
+		return err(invalidRange({
+			start: pos.value,
+			end: pos.value
+		}));
+	}
+	const parseResult = (0, _bcts_dcbor_pattern.parse)(`[${src.slice(pos.value)}]`);
+	if (!parseResult.ok) return err(invalidPattern({
+		start: pos.value,
+		end: src.length
+	}));
+	const consumed = src.length - pos.value;
+	return ok([createArrayFromDcborPattern(parseResult.value), consumed]);
+}
+//#endregion
 //#region src/pattern/index.ts
 /**
 * Creates a Leaf pattern.
@@ -5506,6 +5625,12 @@ function registerAllFactories() {
 		compile: patternCompile,
 		toString: patternToString
 	});
+	registerWrappedPatternAny(any);
+	registerAssertionsPatternToStringDispatch(patternToString);
+	registerSubjectPatternDispatch({
+		compile: patternCompile,
+		toString: patternToString
+	});
 	registerAnyPatternFactory((p) => patternMeta(metaAny(p)));
 	registerAndPatternFactory((p) => patternMeta(metaAnd(p)));
 	registerOrPatternFactory((p) => patternMeta(metaOr(p)));
@@ -5517,6 +5642,14 @@ function registerAllFactories() {
 }
 registerAllFactories();
 registerVMPatternFunctions(patternPathsWithCaptures, patternMatches, patternPaths);
+registerPatternFactories({
+	cborPattern: (value) => cborValue(value),
+	cborPatternFromDcbor: (pattern) => cborPattern(pattern),
+	anyArray,
+	arrayWithCount: (count) => patternLeaf(leafArray(ArrayPattern.count(count))),
+	arrayWithRange: (min, max) => patternLeaf(leafArray(ArrayPattern.interval(min, max))),
+	arrayFromDcborPattern: (pattern) => patternLeaf(leafArray(ArrayPattern.fromDcborPattern(pattern)))
+});
 registerPatternMatchFn(patternMatches);
 registerPatternDispatchFns({
 	pathsWithCaptures: patternPathsWithCaptures,
@@ -6270,305 +6403,198 @@ var Lexer = class {
 	}
 };
 //#endregion
-//#region src/parse/index.ts
+//#region src/parse/leaf/array-parser.ts
 /**
 * Copyright © 2023-2026 Blockchain Commons, LLC
 * Copyright © 2025-2026 Parity Technologies
 *
+* Array parser — port of `bc-envelope-pattern-rust`
+* `parse/leaf/array_parser.rs`.
 *
-* @bcts/envelope-pattern - Parser entry point
+* Mirrors Rust's flow exactly: after the `[` token has been consumed,
+* delegate to `utils::parseArrayInner` (which handles `*`, `{n}`, `{n,m}`,
+* `{n,}` directly and otherwise wraps the body in `[...]` and re-parses
+* via dcbor-pattern), then expect a closing `]`.
+*
+* @module envelope-pattern/parse/leaf/array-parser
+*/
+function parseArray(lexer) {
+	const inner = parseArrayInner(lexer.remainder());
+	if (!inner.ok) return inner;
+	const [pattern, consumed] = inner.value;
+	lexer.bump(consumed);
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseBracket(lexer.span()));
+	if (close.token.type !== "BracketClose") return err(unexpectedToken(close.token, close.span));
+	return ok(pattern);
+}
+//#endregion
+//#region src/parse/leaf/cbor-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
 *
-* This is a 1:1 TypeScript port of bc-envelope-pattern-rust parse/mod.rs
-* Recursive descent parser for Gordian Envelope pattern syntax.
+* CBOR pattern parser — port of `bc-envelope-pattern-rust`
+* `parse/leaf/cbor_parser.rs`.
 *
-* @module envelope-pattern/parse
+* Mirrors Rust's flow: lookahead for `(`. If absent, return `any_cbor()`.
+* Otherwise consume the `(`, delegate to `parseCborInner` (handles
+* `/regex/`, `ur:…`, and CBOR diagnostic notation), and expect a closing
+* `)`.
+*
+* @module envelope-pattern/parse/leaf/cbor-parser
 */
+function parseCbor(lexer) {
+	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyCbor());
+	lexer.next();
+	const innerResult = parseCborInner(lexer.remainder());
+	if (!innerResult.ok) return innerResult;
+	const [pattern, consumed] = innerResult.value;
+	lexer.bump(consumed);
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(pattern);
+}
+//#endregion
+//#region src/parse/leaf/date-parser.ts
 /**
-* Parse a pattern expression string into a Pattern.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Date content parser — port of `bc-envelope-pattern-rust`
+* `parse/leaf/date_parser.rs`.
+*
+* Mirrors Rust's `Date::from_string`, which accepts a strict ISO-8601
+* subset, by deferring to dcbor's `CborDate.fromString`. Falls back to JS
+* `Date.parse` only as a defensive shim — that branch is unreachable for
+* conformant inputs.
+*
+* @module envelope-pattern/parse/leaf/date-parser
 */
-function parse(input) {
-	const lexer = new Lexer(input);
-	const result = parseOr(lexer);
-	if (!result.ok) {
-		const dcborResult = (0, _bcts_dcbor_pattern.parse)(input);
-		if (dcborResult.ok) return convertDcborPatternToEnvelopePattern$1(dcborResult.value);
-		return result;
+/**
+* Parse a date pattern of one of the forms accepted by Rust:
+*
+* - `/regex/` (regex match against ISO-8601 string)
+* - `start...end` (inclusive range)
+* - `start...` (earliest)
+* - `...end` (latest)
+* - `iso-8601` (exact)
+*
+* Mirrors `parse_date_content` in Rust; uses `CborDate.fromString` so the
+* accepted formats match Rust's `bc_envelope::prelude::Date::from_string`
+* exactly rather than the looser JS `Date.parse`.
+*/
+function parseDateContent(content, span) {
+	if (content.startsWith("/") && content.endsWith("/") && content.length >= 2) {
+		const regexStr = content.slice(1, -1);
+		try {
+			return ok(dateRegex(new RegExp(regexStr)));
+		} catch {
+			return err(invalidRegex(span));
+		}
+	}
+	const ellipsisIdx = content.indexOf("...");
+	if (ellipsisIdx !== -1) {
+		const left = content.slice(0, ellipsisIdx);
+		const right = content.slice(ellipsisIdx + 3);
+		if (left.length === 0 && right.length > 0) {
+			const parsed = parseIsoDateStrict(right);
+			if (parsed === void 0) return err(invalidDateFormat(span));
+			return ok(dateLatest(parsed));
+		}
+		if (left.length > 0 && right.length === 0) {
+			const parsed = parseIsoDateStrict(left);
+			if (parsed === void 0) return err(invalidDateFormat(span));
+			return ok(dateEarliest(parsed));
+		}
+		if (left.length > 0 && right.length > 0) {
+			const start = parseIsoDateStrict(left);
+			const end = parseIsoDateStrict(right);
+			if (start === void 0 || end === void 0) return err(invalidDateFormat(span));
+			return ok(dateRange(start, end));
+		}
+		return err(invalidDateFormat(span));
+	}
+	const parsed = parseIsoDateStrict(content);
+	if (parsed === void 0) return err(invalidDateFormat(span));
+	return ok(date(parsed));
+}
+function parseIsoDateStrict(value) {
+	try {
+		return _bcts_dcbor.CborDate.fromString(value);
+	} catch {
+		return;
 	}
-	const next = lexer.next();
-	if (next !== void 0) return err(extraData(next.span));
-	return result;
 }
+//#endregion
+//#region src/parse/leaf/known-value-parser.ts
 /**
-* Parse a pattern, allowing extra data after the pattern.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Helpers for parsing the body of a `'…'` (single-quoted) known-value
+* literal. Mirrors the inline body of Rust's `Token::SingleQuotedPattern`
+* branch in `parse_primary`:
+*
+* - If the contents are a valid `u64`, build `Pattern::known_value(...)`.
+* - Otherwise, build `Pattern::known_value_named(...)`.
+*
+* The earlier port duck-typed a fake `KnownValue`; this version uses the
+* real `KnownValue` constructor so all subsequent KnownValue methods work
+* (e.g., `taggedCbor()`, `name()`, etc.).
+*
+* @module envelope-pattern/parse/leaf/known-value-parser
 */
-function parsePartial(input) {
-	const lexer = new Lexer(input);
-	const result = parseOr(lexer);
-	if (!result.ok) return result;
-	return ok([result.value, lexer.position]);
-}
 /**
-* Convert a dcbor-pattern Pattern to an envelope-pattern Pattern.
+* Maximum value of a Rust `u64`. Used to reject literals that would
+* silently wrap or lose precision when constructing a `KnownValue`.
 */
-function convertDcborPatternToEnvelopePattern$1(_dcborPattern) {
-	return ok(any());
-}
+const U64_MAX = 18446744073709551615n;
 /**
-* Parse an Or expression: expr (| expr)*
+* Parse the inner contents of a `'…'` known-value pattern token.
+*
+* Mirrors the Rust dispatch
+* ```ignore
+* if let Ok(value) = content.parse::<u64>() {
+*     Pattern::known_value(KnownValue::new(value))
+* } else {
+*     Pattern::known_value_named(content)
+* }
+* ```
+* but uses BigInt parsing to preserve full `u64` range — the previous
+* `parseInt(...)` path silently truncated above `2^53-1`.
 */
-function parseOr(lexer) {
-	const patterns = [];
-	const first = parseTraverse(lexer);
-	if (!first.ok) return first;
-	patterns.push(first.value);
-	while (true) {
-		if (lexer.peekToken()?.token.type !== "Or") break;
-		lexer.next();
-		const nextExpr = parseTraverse(lexer);
-		if (!nextExpr.ok) return nextExpr;
-		patterns.push(nextExpr.value);
-	}
-	if (patterns.length === 1) return ok(patterns[0]);
-	return ok(or(patterns));
-}
-/**
-* Parse a Traverse expression: expr (-> expr)*
-*/
-function parseTraverse(lexer) {
-	const patterns = [];
-	const first = parseAnd(lexer);
-	if (!first.ok) return first;
-	patterns.push(first.value);
-	while (true) {
-		if (lexer.peekToken()?.token.type !== "Traverse") break;
-		lexer.next();
-		const nextExpr = parseAnd(lexer);
-		if (!nextExpr.ok) return nextExpr;
-		patterns.push(nextExpr.value);
-	}
-	if (patterns.length === 1) return ok(patterns[0]);
-	return ok(traverse(patterns));
-}
-/**
-* Parse an And expression: expr (& expr)*
-*/
-function parseAnd(lexer) {
-	const patterns = [];
-	const first = parseNot(lexer);
-	if (!first.ok) return first;
-	patterns.push(first.value);
-	while (true) {
-		if (lexer.peekToken()?.token.type !== "And") break;
-		lexer.next();
-		const nextExpr = parseNot(lexer);
-		if (!nextExpr.ok) return nextExpr;
-		patterns.push(nextExpr.value);
-	}
-	if (patterns.length === 1) return ok(patterns[0]);
-	return ok(and(patterns));
+function parseKnownValueContent(content) {
+	if (isU64Literal(content)) return ok(knownValue(new _bcts_known_values.KnownValue(BigInt(content))));
+	return ok(patternLeaf(leafKnownValue(KnownValuePattern.named(content))));
 }
-/**
-* Parse a Not expression: !? group
-*/
-function parseNot(lexer) {
-	if (lexer.peekToken()?.token.type === "Not") {
-		lexer.next();
-		const inner = parseGroup(lexer);
-		if (!inner.ok) return inner;
-		return ok(notMatching(inner.value));
+function isU64Literal(content) {
+	if (content.length === 0) return false;
+	for (let i = 0; i < content.length; i++) {
+		const c = content.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
 	}
-	return parseGroup(lexer);
-}
-/**
-* Parse a Group expression: primary quantifier?
-*/
-function parseGroup(lexer) {
-	const primary = parsePrimary(lexer);
-	if (!primary.ok) return primary;
-	const next = lexer.peekToken();
-	if (next === void 0) return primary;
-	const tokenType = next.token.type;
-	let quantifier;
-	if (tokenType === "RepeatZeroOrMore") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Greedy);
-	} else if (tokenType === "RepeatZeroOrMoreLazy") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Lazy);
-	} else if (tokenType === "RepeatZeroOrMorePossessive") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Possessive);
-	} else if (tokenType === "RepeatOneOrMore") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Greedy);
-	} else if (tokenType === "RepeatOneOrMoreLazy") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Lazy);
-	} else if (tokenType === "RepeatOneOrMorePossessive") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Possessive);
-	} else if (tokenType === "RepeatZeroOrOne") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Greedy);
-	} else if (tokenType === "RepeatZeroOrOneLazy") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Lazy);
-	} else if (tokenType === "RepeatZeroOrOnePossessive") {
-		lexer.next();
-		quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Possessive);
-	} else if (tokenType === "Range") {
-		lexer.next();
-		if (!next.token.value.ok) return err(next.token.value.error);
-		quantifier = next.token.value.value;
-	} else return primary;
-	return ok(repeat(primary.value, quantifier.min(), quantifier.max(), quantifier.reluctance()));
-}
-/**
-* Parse a primary expression (atoms and structure keywords).
-*/
-function parsePrimary(lexer) {
-	const tokenResult = lexer.next();
-	if (tokenResult === void 0) return err(unexpectedEndOfInput());
-	const { token, span } = tokenResult;
-	switch (token.type) {
-		case "Search": return parseSearch(lexer);
-		case "Node": return parseNode(lexer);
-		case "Assertion": return parseAssertion(lexer);
-		case "AssertionPred": return parseAssertionPred(lexer);
-		case "AssertionObj": return parseAssertionObj(lexer);
-		case "Digest": return parseDigest(lexer);
-		case "Obj": return parseObject(lexer);
-		case "Obscured": return ok(obscured());
-		case "Elided": return ok(elided());
-		case "Encrypted": return ok(encrypted());
-		case "Compressed": return ok(compressed());
-		case "Pred": return parsePredicate(lexer);
-		case "Subject": return parseSubject(lexer);
-		case "Wrapped": return ok(wrapped());
-		case "Unwrap": return parseUnwrap(lexer);
-		case "Leaf": return ok(leaf());
-		case "GroupName": return parseCapture(lexer, token.name);
-		case "ParenOpen": return parseParenGroup(lexer);
-		case "Cbor": return parseCbor(lexer);
-		case "RepeatZeroOrMore": return ok(any());
-		case "BoolKeyword": return ok(anyBool());
-		case "BoolTrue": return ok(bool(true));
-		case "BoolFalse": return ok(bool(false));
-		case "NumberKeyword": return ok(anyNumber());
-		case "TextKeyword": return ok(anyText());
-		case "StringLiteral":
-			if (!token.value.ok) return err(token.value.error);
-			return ok(text(token.value.value));
-		case "UnsignedInteger":
-			if (!token.value.ok) return err(token.value.error);
-			return parseNumberRangeOrComparison(lexer, token.value.value);
-		case "Integer":
-			if (!token.value.ok) return err(token.value.error);
-			return parseNumberRangeOrComparison(lexer, token.value.value);
-		case "Float":
-			if (!token.value.ok) return err(token.value.error);
-			return parseNumberRangeOrComparison(lexer, token.value.value);
-		case "GreaterThanOrEqual": return parseComparisonNumber(lexer, ">=");
-		case "LessThanOrEqual": return parseComparisonNumber(lexer, "<=");
-		case "GreaterThan": return parseComparisonNumber(lexer, ">");
-		case "LessThan": return parseComparisonNumber(lexer, "<");
-		case "NaN": return ok(patternLeaf(leafNumber(NumberPattern.nan())));
-		case "Infinity": return ok(number(Infinity));
-		case "NegativeInfinity": return ok(number(-Infinity));
-		case "Regex":
-			if (!token.value.ok) return err(token.value.error);
-			try {
-				return ok(textRegex(new RegExp(token.value.value)));
-			} catch {
-				return err(invalidRegex(span));
-			}
-		case "BracketOpen": return parseArray(lexer);
-		case "ByteString": return ok(anyByteString());
-		case "HexPattern":
-			if (!token.value.ok) return err(token.value.error);
-			return ok(byteString(token.value.value));
-		case "HexBinaryRegex":
-			if (!token.value.ok) return err(token.value.error);
-			try {
-				return ok(patternLeaf(leafByteString(ByteStringPattern.regex(new RegExp(token.value.value)))));
-			} catch {
-				return err(invalidRegex(span));
-			}
-		case "DateKeyword": return ok(anyDate());
-		case "DatePattern":
-			if (!token.value.ok) return err(token.value.error);
-			return parseDateContent(token.value.value, span);
-		case "Tagged": return parseTag(lexer);
-		case "Known": return ok(anyKnownValue());
-		case "SingleQuotedPattern":
-			if (!token.value.ok) return err(token.value.error);
-			return parseKnownValueContent(token.value.value);
-		case "SingleQuotedRegex":
-			if (!token.value.ok) return err(token.value.error);
-			try {
-				return ok(patternLeaf(leafKnownValue(KnownValuePattern.regex(new RegExp(token.value.value)))));
-			} catch {
-				return err(invalidRegex(span));
-			}
-		case "Null": return ok(nullPattern());
-		case "And":
-		case "Or":
-		case "Not":
-		case "Traverse":
-		case "RepeatZeroOrMoreLazy":
-		case "RepeatZeroOrMorePossessive":
-		case "RepeatOneOrMore":
-		case "RepeatOneOrMoreLazy":
-		case "RepeatOneOrMorePossessive":
-		case "RepeatZeroOrOne":
-		case "RepeatZeroOrOneLazy":
-		case "RepeatZeroOrOnePossessive":
-		case "ParenClose":
-		case "BracketClose":
-		case "Comma":
-		case "Ellipsis":
-		case "Range":
-		case "Identifier": return err(unexpectedToken(token, span));
+	try {
+		const value = BigInt(content);
+		return value >= 0n && value <= U64_MAX;
+	} catch {
+		return false;
 	}
 }
+//#endregion
+//#region src/parse/leaf/number-parser.ts
 /**
-* Parse a parenthesized group expression.
-*/
-function parseParenGroup(lexer) {
-	const inner = parseOr(lexer);
-	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(group(inner.value));
-}
-/**
-* Parse a capture group: @name pattern
-*/
-function parseCapture(lexer, name) {
-	const inner = parseGroup(lexer);
-	if (!inner.ok) return inner;
-	return ok(capture(name, inner.value));
-}
-/**
-* Parse a search pattern: search(pattern)
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Number parsers — port of `bc-envelope-pattern-rust` `parse/leaf/number_parser.rs`.
+*
+* @module envelope-pattern/parse/leaf/number-parser
 */
-function parseSearch(lexer) {
-	if (lexer.next()?.token.type !== "ParenOpen") return err({
-		type: "ExpectedOpenParen",
-		span: lexer.span()
-	});
-	const inner = parseOr(lexer);
-	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(search(inner.value));
-}
 /**
-* Parse number with possible range or comparison.
+* Parses an optional `...end` suffix following an already-consumed number,
+* mirroring Rust `parse_number_range_or_comparison`.
 */
 function parseNumberRangeOrComparison(lexer, firstValue) {
 	const next = lexer.peekToken();
@@ -6578,10 +6604,7 @@ function parseNumberRangeOrComparison(lexer, firstValue) {
 		const endToken = lexer.next();
 		if (endToken === void 0) return err(unexpectedEndOfInput());
 		let endValue;
-		if (endToken.token.type === "UnsignedInteger" || endToken.token.type === "Integer") {
-			if (!endToken.token.value.ok) return err(endToken.token.value.error);
-			endValue = endToken.token.value.value;
-		} else if (endToken.token.type === "Float") {
+		if (endToken.token.type === "UnsignedInteger" || endToken.token.type === "Integer" || endToken.token.type === "Float") {
 			if (!endToken.token.value.ok) return err(endToken.token.value.error);
 			endValue = endToken.token.value.value;
 		} else return err(unexpectedToken(endToken.token, endToken.span));
@@ -6590,16 +6613,14 @@ function parseNumberRangeOrComparison(lexer, firstValue) {
 	return ok(number(firstValue));
 }
 /**
-* Parse comparison number: >=n, <=n, >n, <n
+* Parses a number following a comparison operator, mirroring Rust
+* `parse_comparison_number`.
 */
 function parseComparisonNumber(lexer, op) {
 	const numToken = lexer.next();
 	if (numToken === void 0) return err(unexpectedEndOfInput());
 	let value;
-	if (numToken.token.type === "UnsignedInteger" || numToken.token.type === "Integer") {
-		if (!numToken.token.value.ok) return err(numToken.token.value.error);
-		value = numToken.token.value.value;
-	} else if (numToken.token.type === "Float") {
+	if (numToken.token.type === "UnsignedInteger" || numToken.token.type === "Integer" || numToken.token.type === "Float") {
 		if (!numToken.token.value.ok) return err(numToken.token.value.error);
 		value = numToken.token.value.value;
 	} else return err(unexpectedToken(numToken.token, numToken.span));
@@ -6608,300 +6629,812 @@ function parseComparisonNumber(lexer, op) {
 		case "<=": return ok(patternLeaf(leafNumber(NumberPattern.lessThanOrEqual(value))));
 		case ">": return ok(numberGreaterThan(value));
 		case "<": return ok(numberLessThan(value));
-		default: return ok(number(value));
 	}
 }
+//#endregion
+//#region src/parse/leaf/tag-parser.ts
 /**
-* Parse an array pattern.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Tag parser — port of `bc-envelope-pattern-rust`
+* `parse/leaf/tag_parser.rs`.
+*
+* Mirrors the Rust dispatch exactly: lookahead for `(`; if absent, return
+* the bare `any_tag()`. Otherwise build a synthetic dcbor-pattern
+* expression `tagged(<inner>)`, parse it via `@bcts/dcbor-pattern`, and
+* extract the resulting `TaggedPattern` to wrap as an envelope-pattern
+* leaf. This keeps the **full** tag selector (number, name, regex)
+* intact — the previous port discarded the tag value entirely.
+*
+* @module envelope-pattern/parse/leaf/tag-parser
 */
-function parseArray(lexer) {
-	const first = lexer.peekToken();
-	if (first === void 0) return err(unexpectedEndOfInput());
-	if (first.token.type === "BracketClose") {
-		lexer.next();
-		return ok(patternLeaf(leafArray(ArrayPattern.count(0))));
-	}
-	if (first.token.type === "RepeatZeroOrMore") {
-		lexer.next();
-		if (lexer.next()?.token.type !== "BracketClose") return err({
-			type: "ExpectedCloseBracket",
-			span: lexer.span()
-		});
-		return ok(anyArray());
-	}
-	const patterns = [];
-	while (true) {
-		const next = lexer.peekToken();
-		if (next === void 0) return err(unexpectedEndOfInput());
-		if (next.token.type === "BracketClose") {
-			lexer.next();
-			break;
-		}
-		const pattern = parseOr(lexer);
-		if (!pattern.ok) return pattern;
-		patterns.push(pattern.value);
-		const afterPattern = lexer.peekToken();
-		if (afterPattern === void 0) return err(unexpectedEndOfInput());
-		if (afterPattern.token.type === "Comma") lexer.next();
-		else if (afterPattern.token.type !== "BracketClose") return err(unexpectedToken(afterPattern.token, afterPattern.span));
-	}
-	if (patterns.length === 0) return ok(patternLeaf(leafArray(ArrayPattern.count(0))));
-	return ok(patternLeaf(leafArray(ArrayPattern.withPatterns(patterns))));
-}
 /**
-* Parse a tag pattern.
+* Parse `tagged` and `tagged(...)` patterns.
 */
 function parseTag(lexer) {
-	if (lexer.next()?.token.type !== "ParenOpen") return ok(anyTag());
-	const tagToken = lexer.next();
-	if (tagToken === void 0) return err(unexpectedEndOfInput());
-	if (tagToken.token.type !== "UnsignedInteger") return err(unexpectedToken(tagToken.token, tagToken.span));
-	if (!tagToken.token.value.ok) return err(tagToken.token.value.error);
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(anyTag());
-}
-/**
-* Parse date content from date'...' pattern.
-*/
-function parseDateContent(content, span) {
-	if (content.startsWith("/") && content.endsWith("/")) {
-		const regexStr = content.slice(1, -1);
-		try {
-			return ok(dateRegex(new RegExp(regexStr)));
-		} catch {
-			return err(invalidRegex(span));
+	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyTag());
+	lexer.next();
+	const remainder = lexer.remainder();
+	const closeIdx = findMatchingCloseParen(remainder);
+	if (closeIdx === void 0) return err(expectedCloseParen(lexer.span()));
+	const innerContent = remainder.slice(0, closeIdx);
+	const dcborResult = (0, _bcts_dcbor_pattern.parse)(`tagged(${innerContent})`);
+	if (dcborResult.ok) {
+		const dcborPattern = dcborResult.value;
+		if (dcborPattern.kind === "Structure" && dcborPattern.pattern.type === "Tagged") {
+			lexer.bump(closeIdx);
+			const close = lexer.next();
+			if (close === void 0) return err(expectedCloseParen(lexer.span()));
+			if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+			return ok(patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborPattern.pattern.pattern))));
 		}
 	}
-	const rangeIdx = content.indexOf("...");
-	if (rangeIdx !== -1) {
-		const left = content.slice(0, rangeIdx).trim();
-		const right = content.slice(rangeIdx + 3).trim();
-		if (left.length === 0 && right.length > 0) {
-			const parsed = Date.parse(right);
-			if (isNaN(parsed)) return err({
-				type: "InvalidDateFormat",
-				span
-			});
-			return ok(dateLatest(_bcts_dcbor.CborDate.fromDatetime(new Date(parsed))));
-		}
-		if (left.length > 0 && right.length === 0) {
-			const parsed = Date.parse(left);
-			if (isNaN(parsed)) return err({
-				type: "InvalidDateFormat",
-				span
-			});
-			return ok(dateEarliest(_bcts_dcbor.CborDate.fromDatetime(new Date(parsed))));
+	const fallback = parseTagInner(innerContent);
+	if (!fallback.ok) return fallback;
+	lexer.bump(closeIdx);
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(fallback.value);
+}
+/**
+* Locate the index of the closing `)` matching the `(` that has already
+* been consumed by `parseTag`. Mirrors Rust `find_matching_paren`.
+*/
+function findMatchingCloseParen(src) {
+	let depth = 0;
+	for (let i = 0; i < src.length; i++) {
+		const ch = src.charCodeAt(i);
+		if (ch === 40) depth += 1;
+		else if (ch === 41) {
+			if (depth === 0) return i;
+			depth -= 1;
 		}
-		if (left.length > 0 && right.length > 0) {
-			const parsedStart = Date.parse(left);
-			const parsedEnd = Date.parse(right);
-			if (isNaN(parsedStart) || isNaN(parsedEnd)) return err({
-				type: "InvalidDateFormat",
-				span
-			});
-			return ok(dateRange(_bcts_dcbor.CborDate.fromDatetime(new Date(parsedStart)), _bcts_dcbor.CborDate.fromDatetime(new Date(parsedEnd))));
-		}
-		return err({
-			type: "InvalidDateFormat",
-			span
-		});
 	}
-	const parsed = Date.parse(content);
-	if (isNaN(parsed)) return err({
-		type: "InvalidDateFormat",
-		span
-	});
-	return ok(date(_bcts_dcbor.CborDate.fromDatetime(new Date(parsed))));
 }
 /**
-* Parse known value content from '...' pattern.
+* Fallback for `tagged(N)` and `tagged(name)` when the full delegation
+* to dcbor-pattern fails. Mirrors Rust `parse_tag_inner`.
 */
-function parseKnownValueContent(content) {
-	const numValue = parseInt(content, 10);
-	if (!isNaN(numValue)) return ok(knownValue({ value: () => BigInt(numValue) }));
-	return ok(patternLeaf(leafKnownValue(KnownValuePattern.named(content))));
+function parseTagInner(src) {
+	const trimmed = src.trim();
+	if (trimmed.length === 0) return err(unexpectedEndOfInput());
+	if (trimmed.startsWith("/")) return err(unexpectedEndOfInput());
+	if (/^\d+$/.test(trimmed)) try {
+		const dcborResult = (0, _bcts_dcbor_pattern.parse)(`tagged(${trimmed})`);
+		if (dcborResult.ok && dcborResult.value.kind === "Structure" && dcborResult.value.pattern.type === "Tagged") return ok(patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborResult.value.pattern.pattern))));
+	} catch {}
+	const dcborResult = (0, _bcts_dcbor_pattern.parse)(`tagged(${trimmed})`);
+	if (dcborResult.ok && dcborResult.value.kind === "Structure" && dcborResult.value.pattern.type === "Tagged") return ok(patternLeaf(leafTag(TaggedPattern.fromDcborPattern(dcborResult.value.pattern.pattern))));
+	return err(unexpectedEndOfInput());
 }
+//#endregion
+//#region src/parse/structure/assertion-parser.ts
 /**
-* Parse CBOR pattern.
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
 *
-* Matches Rust parse_cbor: tries dcbor-pattern regex first (/keyword/),
-* then CBOR diagnostic notation via parseDcborItemPartial, then falls
-* back to parseOr for envelope pattern expressions.
+* Assertion parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/assertion_parser.rs`.
+*
+* Note: Rust's `parse_assertion` ignores its lexer entirely and always
+* returns `Pattern::any_assertion()`. There is intentionally **no**
+* `assert(pred, obj)` syntax — predicate/object filters are written via
+* the dedicated `assertpred(...)` / `assertobj(...)` keywords.
+*
+* @module envelope-pattern/parse/structure/assertion-parser
 */
-function parseCbor(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyCbor());
-	lexer.next();
-	if (lexer.peek() === "/") {
-		const regexTokenResult = lexer.next();
-		if (regexTokenResult?.token.type === "Regex") {
-			const regexToken = regexTokenResult.token;
-			if (!regexToken.value.ok) return err(regexToken.value.error);
-			const keyword = regexToken.value.value;
-			const dcborResult = (0, _bcts_dcbor_pattern.parse)(keyword);
-			if (!dcborResult.ok) return err(unexpectedToken(regexToken, regexTokenResult.span));
-			if (lexer.next()?.token.type !== "ParenClose") return err({
-				type: "ExpectedCloseParen",
-				span: lexer.span()
-			});
-			return ok(cborPattern(dcborResult.value));
-		}
-	}
-	const cborResult = (0, _bcts_dcbor_parse.parseDcborItemPartial)(lexer.remainder());
-	if (cborResult.ok) {
-		const [cborData, consumed] = cborResult.value;
-		lexer.bump(consumed);
-		while (lexer.peek() === " " || lexer.peek() === "	" || lexer.peek() === "\n") lexer.bump(1);
-		if (lexer.next()?.token.type !== "ParenClose") return err({
-			type: "ExpectedCloseParen",
-			span: lexer.span()
-		});
-		return ok(cborValue(cborData));
-	}
-	const inner = parseOr(lexer);
-	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return inner;
+function parseAssertion(_lexer) {
+	return ok(anyAssertion());
 }
-function parseNode(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyNode());
-	lexer.next();
-	const afterParen = lexer.peekToken();
-	if (afterParen?.token.type === "Range") {
-		lexer.next();
-		const rangeToken = afterParen.token;
-		if (!rangeToken.value.ok) return err(rangeToken.value.error);
-		const interval = rangeToken.value.value.interval();
-		if (lexer.next()?.token.type !== "ParenClose") return err({
-			type: "ExpectedCloseParen",
-			span: lexer.span()
-		});
-		return ok(patternStructure(structureNode(NodePattern.fromInterval(interval))));
-	}
+//#endregion
+//#region src/parse/structure/assertion-obj-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Assertion-object parser — port of
+* `bc-envelope-pattern-rust/src/parse/structure/assertion_obj_parser.rs`.
+*
+* Requires `assertobj(<pattern>)`. The bare `assertobj` keyword is a
+* syntax error in Rust; we now mirror that behaviour.
+*
+* @module envelope-pattern/parse/structure/assertion-obj-parser
+*/
+function parseAssertionObj(lexer) {
+	const open = lexer.next();
+	if (open === void 0) return err(unexpectedEndOfInput());
+	if (open.token.type !== "ParenOpen") return err(unexpectedToken(open.token, open.span));
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(patternStructure(structureNode(NodePattern.withSubject(inner.value))));
-}
-function parseAssertion(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyAssertion());
-	lexer.next();
-	const pred = parseOr(lexer);
-	if (!pred.ok) return pred;
-	const comma = lexer.next();
-	if (comma?.token.type !== "Comma") return err(unexpectedToken(comma?.token ?? { type: "Null" }, comma?.span ?? lexer.span()));
-	const obj = parseOr(lexer);
-	if (!obj.ok) return obj;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(patternStructure(structureAssertions(AssertionsPattern.withBoth(pred.value, obj.value))));
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(assertionWithObject(inner.value));
 }
+//#endregion
+//#region src/parse/structure/assertion-pred-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Assertion-predicate parser — port of
+* `bc-envelope-pattern-rust/src/parse/structure/assertion_pred_parser.rs`.
+*
+* Requires `assertpred(<pattern>)`. The bare `assertpred` keyword is a
+* syntax error in Rust (it errors on `UnexpectedEndOfInput` /
+* `UnexpectedToken`); we now mirror that behaviour.
+*
+* @module envelope-pattern/parse/structure/assertion-pred-parser
+*/
 function parseAssertionPred(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyAssertion());
-	lexer.next();
+	const open = lexer.next();
+	if (open === void 0) return err(unexpectedEndOfInput());
+	if (open.token.type !== "ParenOpen") return err(unexpectedToken(open.token, open.span));
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
 	return ok(assertionWithPredicate(inner.value));
 }
-function parseAssertionObj(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyAssertion());
-	lexer.next();
-	const inner = parseOr(lexer);
-	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
-	return ok(assertionWithObject(inner.value));
+//#endregion
+//#region src/parse/structure/compressed-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Compressed parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/compressed_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/compressed-parser
+*/
+function parseCompressed(_lexer) {
+	return ok(compressed());
 }
+//#endregion
+//#region src/parse/structure/digest-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Digest parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/digest_parser.rs`.
+*
+* Mirrors Rust exactly:
+*
+* - Requires `digest(...)` — bare `digest` is an `UnexpectedEndOfInput`
+*   error (the previous TS port silently returned `digest(any)`).
+* - Inside the parens, accepts either a UR string (`ur:digest/...`,
+*   parsed via `Digest.fromURString`) or a hex byte prefix.
+* - Hex prefixes must have even length and not exceed `Digest.DIGEST_SIZE`
+*   bytes; otherwise the parser surfaces `InvalidHexString`.
+*
+* @module envelope-pattern/parse/structure/digest-parser
+*/
+const DIGEST_SIZE = _bcts_envelope.Digest.DIGEST_SIZE;
 function parseDigest(lexer) {
-	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(patternStructure(structureDigest(DigestPattern.any())));
-	lexer.next();
-	const digestToken = lexer.next();
-	if (digestToken === void 0) return err(unexpectedEndOfInput());
-	if (digestToken.token.type === "HexPattern") {
-		if (!digestToken.token.value.ok) return err(digestToken.token.value.error);
-		if (lexer.next()?.token.type !== "ParenClose") return err({
-			type: "ExpectedCloseParen",
-			span: lexer.span()
-		});
-		return ok(digestPrefix(digestToken.token.value.value));
+	const open = lexer.next();
+	if (open === void 0) return err(unexpectedEndOfInput());
+	if (open.token.type !== "ParenOpen") return err(unexpectedToken(open.token, open.span));
+	const innerResult = parseDigestInner(lexer.remainder(), lexer.position);
+	if (!innerResult.ok) return innerResult;
+	const [pattern, consumed] = innerResult.value;
+	lexer.bump(consumed);
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(pattern);
+}
+function parseDigestInner(src, basePos) {
+	let pos = 0;
+	pos = skipWs(src, pos);
+	if (src.startsWith("ur:", pos)) {
+		const start = pos;
+		while (pos < src.length && src[pos] !== ")") pos += 1;
+		const ur = src.slice(start, pos).trimEnd();
+		let parsed;
+		try {
+			parsed = _bcts_envelope.Digest.fromURString(ur);
+		} catch {
+			return err(invalidUr(ur, {
+				start: basePos + start,
+				end: basePos + pos
+			}));
+		}
+		pos = skipWs(src, pos);
+		return ok([digest(parsed), pos]);
+	}
+	const start = pos;
+	while (pos < src.length && isAsciiHexDigit(src.charCodeAt(pos))) pos += 1;
+	if (pos === start) return err(invalidHexString({
+		start: basePos + pos,
+		end: basePos + pos
+	}));
+	const hexStr = src.slice(start, pos);
+	if (hexStr.length % 2 !== 0) return err(invalidHexString({
+		start: basePos + pos,
+		end: basePos + pos
+	}));
+	const bytes = decodeHex(hexStr);
+	if (bytes === void 0) return err(invalidHexString({
+		start: basePos + pos,
+		end: basePos + pos
+	}));
+	if (bytes.length > DIGEST_SIZE) return err(invalidHexString({
+		start: basePos + pos,
+		end: basePos + pos
+	}));
+	pos = skipWs(src, pos);
+	return ok([digestPrefix(bytes), pos]);
+}
+function skipWs(src, pos) {
+	while (pos < src.length) {
+		const ch = src[pos];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f") pos += 1;
+		else break;
 	}
-	if (digestToken.token.type === "Identifier") {
-		const hexStr = digestToken.token.value;
-		if (hexStr.length === 0 || hexStr.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(hexStr)) return err({
-			type: "InvalidHexString",
-			span: digestToken.span
-		});
-		const bytes = new Uint8Array(hexStr.length / 2);
-		for (let i = 0; i < hexStr.length; i += 2) bytes[i / 2] = Number.parseInt(hexStr.slice(i, i + 2), 16);
-		if (lexer.next()?.token.type !== "ParenClose") return err({
-			type: "ExpectedCloseParen",
-			span: lexer.span()
-		});
-		return ok(digestPrefix(bytes));
+	return pos;
+}
+function isAsciiHexDigit(c) {
+	return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+}
+function decodeHex(hex) {
+	if (hex.length % 2 !== 0) return void 0;
+	const out = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) {
+		const value = Number.parseInt(hex.slice(i, i + 2), 16);
+		if (Number.isNaN(value)) return void 0;
+		out[i / 2] = value;
 	}
-	return err(unexpectedToken(digestToken.token, digestToken.span));
+	return out;
+}
+//#endregion
+//#region src/parse/structure/elided-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Elided parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/elided_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/elided-parser
+*/
+function parseElided(_lexer) {
+	return ok(elided());
+}
+//#endregion
+//#region src/parse/structure/encrypted-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Encrypted parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/encrypted_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/encrypted-parser
+*/
+function parseEncrypted(_lexer) {
+	return ok(encrypted());
+}
+//#endregion
+//#region src/parse/structure/node-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Node parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/node_parser.rs`.
+*
+* Mirrors Rust:
+* - Bare `node` → `any_node()`.
+* - `node({n})` / `node({n,m})` / `node({n,})` → `node_with_assertions_range`.
+* - Anything else inside the parens (e.g. `node(text)`) is a syntax error
+*   in Rust; the previous TS port silently produced an always-matching
+*   `WithSubject` node, which we have removed.
+*
+* @module envelope-pattern/parse/structure/node-parser
+*/
+function parseNode(lexer) {
+	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyNode());
+	lexer.next();
+	const inner = lexer.next();
+	if (inner === void 0) return err(unexpectedEndOfInput());
+	if (inner.token.type !== "Range") return err(unexpectedToken(inner.token, inner.span));
+	if (!inner.token.value.ok) return err(inner.token.value.error);
+	const interval = inner.token.value.value.interval();
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(patternStructure(structureNode(NodePattern.fromInterval(interval))));
 }
+//#endregion
+//#region src/parse/structure/object-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Object parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/object_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/object-parser
+*/
 function parseObject(lexer) {
 	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyObject());
 	lexer.next();
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
 	return ok(object(inner.value));
 }
+//#endregion
+//#region src/parse/structure/obscured-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Obscured parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/obscured_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/obscured-parser
+*/
+function parseObscured(_lexer) {
+	return ok(obscured());
+}
+//#endregion
+//#region src/parse/structure/predicate-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Predicate parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/predicate_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/predicate-parser
+*/
 function parsePredicate(lexer) {
 	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anyPredicate());
 	lexer.next();
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
 	return ok(predicate(inner.value));
 }
+//#endregion
+//#region src/parse/structure/subject-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Subject parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/subject_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/subject-parser
+*/
 function parseSubject(lexer) {
 	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(anySubject());
 	lexer.next();
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
 	return ok(subject(inner.value));
 }
+//#endregion
+//#region src/parse/structure/wrapped-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Wrapped/unwrap parser — port of `bc-envelope-pattern-rust`
+* `parse/structure/wrapped_parser.rs`.
+*
+* @module envelope-pattern/parse/structure/wrapped-parser
+*/
+function parseWrapped(_lexer) {
+	return ok(wrapped());
+}
 function parseUnwrap(lexer) {
 	if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(unwrapEnvelope());
 	lexer.next();
 	const inner = parseOr(lexer);
 	if (!inner.ok) return inner;
-	if (lexer.next()?.token.type !== "ParenClose") return err({
-		type: "ExpectedCloseParen",
-		span: lexer.span()
-	});
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
 	return ok(unwrapMatching(inner.value));
 }
 //#endregion
+//#region src/parse/meta/capture-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Capture parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/capture_parser.rs`.
+*
+* The `@name(...)` form requires explicit parentheses. Mirrors Rust
+* exactly:
+* ```ignore
+* @name ( expr )
+* ```
+* The previous TS port called `parse_group` (primary + quantifier), which
+* wrapped the inner expression in a redundant `GroupPattern` and accepted
+* the bare `@name p` form that Rust rejects.
+*
+* @module envelope-pattern/parse/meta/capture-parser
+*/
+function parseCapture(lexer, name) {
+	const open = lexer.next();
+	if (open === void 0) return err(unexpectedEndOfInput());
+	if (open.token.type !== "ParenOpen") return err(unexpectedToken(open.token, open.span));
+	const inner = parseOr(lexer);
+	if (!inner.ok) return inner;
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(capture(name, inner.value));
+}
+//#endregion
+//#region src/parse/meta/group-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Group parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/group_parser.rs`.
+*
+* Called from `parse_primary` after the opening `(` has been consumed.
+*
+* Mirrors Rust exactly:
+*
+* - Parse the inner expression with `parse_or`.
+* - Expect `)`. If missing, surface `ExpectedCloseParen`.
+* - Lookahead **once** for a quantifier suffix. If present, consume it
+*   and wrap as `Pattern::repeat(inner, …)`. Otherwise return the inner
+*   expression unchanged.
+*
+* The previous TS port wrapped every parenthesised expression in a
+* dedicated `GroupPattern` and applied quantifiers to bare primaries —
+* both broke `format(parse(s)) === s` round-tripping.
+*
+* @module envelope-pattern/parse/meta/group-parser
+*/
+function parseGroup(lexer) {
+	const inner = parseOr(lexer);
+	if (!inner.ok) return inner;
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	const next = lexer.peekToken();
+	if (next === void 0) return inner;
+	let quantifier;
+	const tokenType = next.token.type;
+	if (tokenType === "RepeatZeroOrMore") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Greedy);
+	else if (tokenType === "RepeatZeroOrMoreLazy") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Lazy);
+	else if (tokenType === "RepeatZeroOrMorePossessive") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrMore(_bcts_dcbor_pattern.Reluctance.Possessive);
+	else if (tokenType === "RepeatOneOrMore") quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Greedy);
+	else if (tokenType === "RepeatOneOrMoreLazy") quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Lazy);
+	else if (tokenType === "RepeatOneOrMorePossessive") quantifier = _bcts_dcbor_pattern.Quantifier.oneOrMore(_bcts_dcbor_pattern.Reluctance.Possessive);
+	else if (tokenType === "RepeatZeroOrOne") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Greedy);
+	else if (tokenType === "RepeatZeroOrOneLazy") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Lazy);
+	else if (tokenType === "RepeatZeroOrOnePossessive") quantifier = _bcts_dcbor_pattern.Quantifier.zeroOrOne(_bcts_dcbor_pattern.Reluctance.Possessive);
+	else if (tokenType === "Range") {
+		if (!next.token.value.ok) return err(next.token.value.error);
+		quantifier = next.token.value.value;
+	} else return inner;
+	lexer.next();
+	return ok(repeat(inner.value, quantifier.min(), quantifier.max(), quantifier.reluctance()));
+}
+//#endregion
+//#region src/parse/meta/search-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Search parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/search_parser.rs`.
+*
+* @module envelope-pattern/parse/meta/search-parser
+*/
+function parseSearch(lexer) {
+	const open = lexer.next();
+	if (open === void 0) return err(unexpectedEndOfInput());
+	if (open.token.type !== "ParenOpen") return err(unexpectedToken(open.token, open.span));
+	const inner = parseOr(lexer);
+	if (!inner.ok) return inner;
+	const close = lexer.next();
+	if (close === void 0) return err(expectedCloseParen(lexer.span()));
+	if (close.token.type !== "ParenClose") return err(unexpectedToken(close.token, close.span));
+	return ok(search(inner.value));
+}
+//#endregion
+//#region src/parse/meta/primary-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Primary parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/primary_parser.rs`.
+*
+* Dispatches on the next token to the appropriate leaf/structure/meta
+* parser. When a `(` is encountered the open paren is consumed here and
+* `parse_group` handles the rest (paren'd expression + optional
+* quantifier suffix).
+*
+* @module envelope-pattern/parse/meta/primary-parser
+*/
+function parsePrimary(lexer) {
+	const tokenResult = lexer.next();
+	if (tokenResult === void 0) return err(unexpectedEndOfInput());
+	const { token, span } = tokenResult;
+	switch (token.type) {
+		case "Search": return parseSearch(lexer);
+		case "Node": return parseNode(lexer);
+		case "Assertion": return parseAssertion(lexer);
+		case "AssertionPred": return parseAssertionPred(lexer);
+		case "AssertionObj": return parseAssertionObj(lexer);
+		case "Digest": return parseDigest(lexer);
+		case "Obj": return parseObject(lexer);
+		case "Obscured": return parseObscured(lexer);
+		case "Elided": return parseElided(lexer);
+		case "Encrypted": return parseEncrypted(lexer);
+		case "Compressed": return parseCompressed(lexer);
+		case "Pred": return parsePredicate(lexer);
+		case "Subject": return parseSubject(lexer);
+		case "Wrapped": return parseWrapped(lexer);
+		case "Unwrap": return parseUnwrap(lexer);
+		case "Leaf": return ok(leaf());
+		case "GroupName": return parseCapture(lexer, token.name);
+		case "ParenOpen": return parseGroup(lexer);
+		case "Cbor": return parseCbor(lexer);
+		case "RepeatZeroOrMore": return ok(any());
+		case "BoolKeyword": return ok(anyBool());
+		case "BoolTrue": return ok(bool(true));
+		case "BoolFalse": return ok(bool(false));
+		case "NumberKeyword": return ok(anyNumber());
+		case "TextKeyword": return ok(anyText());
+		case "StringLiteral":
+			if (!token.value.ok) return err(token.value.error);
+			return ok(text(token.value.value));
+		case "UnsignedInteger":
+			if (!token.value.ok) return err(token.value.error);
+			return parseNumberRangeOrComparison(lexer, token.value.value);
+		case "Integer":
+			if (!token.value.ok) return err(token.value.error);
+			return parseNumberRangeOrComparison(lexer, token.value.value);
+		case "Float":
+			if (!token.value.ok) return err(token.value.error);
+			return parseNumberRangeOrComparison(lexer, token.value.value);
+		case "GreaterThanOrEqual": return parseComparisonNumber(lexer, ">=");
+		case "LessThanOrEqual": return parseComparisonNumber(lexer, "<=");
+		case "GreaterThan": return parseComparisonNumber(lexer, ">");
+		case "LessThan": return parseComparisonNumber(lexer, "<");
+		case "NaN": return ok(patternLeaf(leafNumber(NumberPattern.nan())));
+		case "Infinity": return ok(number(Infinity));
+		case "NegativeInfinity": return ok(number(-Infinity));
+		case "Regex":
+			if (!token.value.ok) return err(token.value.error);
+			try {
+				return ok(textRegex(new RegExp(token.value.value)));
+			} catch {
+				return err(invalidRegex(span));
+			}
+		case "BracketOpen": return parseArray(lexer);
+		case "ByteString": return ok(anyByteString());
+		case "HexPattern":
+			if (!token.value.ok) return err(token.value.error);
+			return ok(byteString(token.value.value));
+		case "HexBinaryRegex":
+			if (!token.value.ok) return err(token.value.error);
+			try {
+				return ok(patternLeaf(leafByteString(ByteStringPattern.regex(new RegExp(token.value.value)))));
+			} catch {
+				return err(invalidRegex(span));
+			}
+		case "DateKeyword": return ok(anyDate());
+		case "DatePattern":
+			if (!token.value.ok) return err(token.value.error);
+			return parseDateContent(token.value.value, span);
+		case "Tagged": return parseTag(lexer);
+		case "Known": return ok(anyKnownValue());
+		case "SingleQuotedPattern":
+			if (!token.value.ok) return err(token.value.error);
+			return parseKnownValueContent(token.value.value);
+		case "SingleQuotedRegex":
+			if (!token.value.ok) return err(token.value.error);
+			try {
+				return ok(patternLeaf(leafKnownValue(KnownValuePattern.regex(new RegExp(token.value.value)))));
+			} catch {
+				return err(invalidRegex(span));
+			}
+		case "Null": return ok(nullPattern());
+		case "Identifier": return err(unrecognizedToken(span));
+		case "And":
+		case "Or":
+		case "Not":
+		case "Traverse":
+		case "RepeatZeroOrMoreLazy":
+		case "RepeatZeroOrMorePossessive":
+		case "RepeatOneOrMore":
+		case "RepeatOneOrMoreLazy":
+		case "RepeatOneOrMorePossessive":
+		case "RepeatZeroOrOne":
+		case "RepeatZeroOrOneLazy":
+		case "RepeatZeroOrOnePossessive":
+		case "ParenClose":
+		case "BracketClose":
+		case "Comma":
+		case "Ellipsis":
+		case "Range": return err(unexpectedToken(token, span));
+	}
+}
+//#endregion
+//#region src/parse/meta/and-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* And parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/and_parser.rs`.
+*
+* Mirrors Rust: `parse_and` calls `parse_primary` (NOT `parse_not`); `!`
+* is handled at a higher precedence level by `parse_not`.
+*
+* @module envelope-pattern/parse/meta/and-parser
+*/
+function parseAnd(lexer) {
+	const patterns = [];
+	const first = parsePrimary(lexer);
+	if (!first.ok) return first;
+	patterns.push(first.value);
+	while (true) {
+		if (lexer.peekToken()?.token.type !== "And") break;
+		lexer.next();
+		const nextExpr = parsePrimary(lexer);
+		if (!nextExpr.ok) return nextExpr;
+		patterns.push(nextExpr.value);
+	}
+	if (patterns.length === 1) return ok(patterns[0]);
+	return ok(and(patterns));
+}
+//#endregion
+//#region src/parse/meta/not-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Not parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/not_parser.rs`.
+*
+* Mirrors Rust:
+* - On `!`, recurse into `parse_not` so chained negation parses as
+*   `not(not(x))` rather than `not(group(x))`.
+* - Otherwise descend into `parse_and`.
+*
+* @module envelope-pattern/parse/meta/not-parser
+*/
+function parseNot(lexer) {
+	if (lexer.peekToken()?.token.type === "Not") {
+		lexer.next();
+		const inner = parseNot(lexer);
+		if (!inner.ok) return inner;
+		return ok(notMatching(inner.value));
+	}
+	return parseAnd(lexer);
+}
+//#endregion
+//#region src/parse/meta/traverse-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Traverse parser — port of `bc-envelope-pattern-rust`
+* `parse/meta/traverse_parser.rs`.
+*
+* Note the precedence chain: `parse_or → parse_traverse → parse_not →
+* parse_and → parse_primary`. The earlier TS port had `parse_traverse`
+* call `parse_and` directly, which pushed `!` below `&` and
+* miscompiled `!a & b`.
+*
+* @module envelope-pattern/parse/meta/traverse-parser
+*/
+function parseTraverse(lexer) {
+	const patterns = [];
+	const first = parseNot(lexer);
+	if (!first.ok) return first;
+	patterns.push(first.value);
+	while (true) {
+		if (lexer.peekToken()?.token.type !== "Traverse") break;
+		lexer.next();
+		const nextExpr = parseNot(lexer);
+		if (!nextExpr.ok) return nextExpr;
+		patterns.push(nextExpr.value);
+	}
+	if (patterns.length === 1) return ok(patterns[0]);
+	return ok(traverse(patterns));
+}
+//#endregion
+//#region src/parse/meta/or-parser.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+* Or parser — port of `bc-envelope-pattern-rust` `parse/meta/or_parser.rs`.
+*
+* @module envelope-pattern/parse/meta/or-parser
+*/
+function parseOr(lexer) {
+	const patterns = [];
+	const first = parseTraverse(lexer);
+	if (!first.ok) return first;
+	patterns.push(first.value);
+	while (true) {
+		if (lexer.peekToken()?.token.type !== "Or") break;
+		lexer.next();
+		const nextExpr = parseTraverse(lexer);
+		if (!nextExpr.ok) return nextExpr;
+		patterns.push(nextExpr.value);
+	}
+	if (patterns.length === 1) return ok(patterns[0]);
+	return ok(or(patterns));
+}
+//#endregion
+//#region src/parse/index.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* @bcts/envelope-pattern - Parser entry point
+*
+* This is a 1:1 TypeScript port of bc-envelope-pattern-rust parse/mod.rs.
+*
+* Recursive-descent parser for the Gordian Envelope pattern syntax. The
+* parsing rules live under `parse/leaf/`, `parse/meta/`, and
+* `parse/structure/`, mirroring the Rust crate's module layout.
+*
+* @module envelope-pattern/parse
+*/
+/**
+* Parse a pattern expression string into a Pattern.
+*
+* Mirrors Rust `Pattern::parse`: tries envelope-pattern parsing first;
+* on failure falls back to dcbor-pattern parsing and converts the
+* result into an envelope pattern via the
+* `dcbor_integration::convert_dcbor_pattern_to_envelope_pattern` bridge.
+*/
+function parse(input) {
+	const lexer = new Lexer(input);
+	const result = parseOr(lexer);
+	if (!result.ok) {
+		const dcborResult = (0, _bcts_dcbor_pattern.parse)(input);
+		if (dcborResult.ok) return convertDcborPatternToEnvelopePattern(dcborResult.value);
+		return result;
+	}
+	const next = lexer.next();
+	if (next !== void 0) return err(extraData(next.span));
+	return result;
+}
+/**
+* Parse a pattern, allowing extra data after the pattern.
+*
+* Returns the parsed pattern and the byte offset at which parsing
+* stopped, mirroring `Pattern::parse_partial` in spirit.
+*/
+function parsePartial(input) {
+	const lexer = new Lexer(input);
+	const result = parseOr(lexer);
+	if (!result.ok) return result;
+	return ok([result.value, lexer.position]);
+}
+//#endregion
 //#region src/index.ts
 /**
 * Package version.
@@ -7094,6 +7627,7 @@ exports.registerAndPatternFactory = registerAndPatternFactory;
 exports.registerAnyPatternFactory = registerAnyPatternFactory;
 exports.registerArrayPatternFactory = registerArrayPatternFactory;
 exports.registerAssertionsPatternFactory = registerAssertionsPatternFactory;
+exports.registerAssertionsPatternToStringDispatch = registerAssertionsPatternToStringDispatch;
 exports.registerBoolPatternFactory = registerBoolPatternFactory;
 exports.registerByteStringPatternFactory = registerByteStringPatternFactory;
 exports.registerCBORPatternFactory = registerCBORPatternFactory;
@@ -7115,11 +7649,13 @@ exports.registerPatternDispatchFns = registerPatternDispatchFns;
 exports.registerPatternMatchFn = registerPatternMatchFn;
 exports.registerPredicatePatternFactory = registerPredicatePatternFactory;
 exports.registerSearchPatternFactory = registerSearchPatternFactory;
+exports.registerSubjectPatternDispatch = registerSubjectPatternDispatch;
 exports.registerSubjectPatternFactory = registerSubjectPatternFactory;
 exports.registerTaggedPatternFactory = registerTaggedPatternFactory;
 exports.registerTextPatternFactory = registerTextPatternFactory;
 exports.registerTraversePatternFactory = registerTraversePatternFactory;
 exports.registerVMPatternFunctions = registerVMPatternFunctions;
+exports.registerWrappedPatternAny = registerWrappedPatternAny;
 exports.registerWrappedPatternDispatch = registerWrappedPatternDispatch;
 exports.registerWrappedPatternFactory = registerWrappedPatternFactory;
 exports.repeat = repeat;