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

package/dist/index.iife.js

@@ -1,4 +1,4 @@
-var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_values, _bcts_envelope, _bcts_dcbor, _bcts_dcbor_parse) {
+var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_values, _bcts_dcbor, _bcts_envelope, _bcts_dcbor_parse) {
 	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 	//#region src/error.ts
 	/**
@@ -302,6 +302,14 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	/**
 	* 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
 	*/
@@ -310,25 +318,17 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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";
@@ -374,8 +374,8 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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) {
@@ -390,8 +390,8 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				}
 				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(" ");
 		}
 	}
 	/**
@@ -1233,25 +1233,16 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	};
 	//#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;
@@ -1262,93 +1253,54 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		* 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];
@@ -1364,54 +1316,31 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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;
@@ -1444,6 +1373,19 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			});
 		}
 		/**
+		* 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() {
@@ -1478,8 +1420,8 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 		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()}}`;
 			}
 		}
 		/**
@@ -1732,7 +1674,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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.
@@ -1858,10 +1800,18 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 		/**
 		* 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;
 		}
@@ -1888,7 +1838,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				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);
@@ -1912,7 +1862,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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);
@@ -1920,7 +1870,8 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 						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)];
@@ -1955,13 +1906,16 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			}
 		}
 		/**
-		* 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);
 			}
 		}
@@ -1971,7 +1925,12 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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));
 			}
 		}
@@ -2240,7 +2199,13 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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.
 	*
@@ -2304,9 +2269,10 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					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;
 			}
@@ -2317,7 +2283,10 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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) : "?"})`;
+				}
 			}
 		}
 		/**
@@ -2414,7 +2383,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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)})`;
 			}
 		}
 		/**
@@ -2511,7 +2480,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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)})`;
 			}
 		}
 		/**
@@ -2532,9 +2501,13 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	//#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.
 	*
@@ -2572,17 +2545,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			});
 		}
 		/**
-		* 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() {
@@ -2593,14 +2555,12 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		*/
 		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 = [];
@@ -2622,14 +2582,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					}
 					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()];
 		}
@@ -2652,11 +2604,11 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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) : "?"})`;
 			}
 		}
 		/**
@@ -2668,10 +2620,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				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;
-				}
 			}
 		}
 		/**
@@ -2682,7 +2630,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				case "Any": return 0;
 				case "WithPredicate": return 1;
 				case "WithObject": return 2;
-				case "WithBoth": return 3;
 			}
 		}
 	};
@@ -2711,12 +2658,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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) {
@@ -2754,9 +2695,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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;
@@ -2794,7 +2732,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 		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}/)`;
@@ -2802,17 +2739,26 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 		/**
 		* 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;
@@ -2823,7 +2769,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		*/
 		hashCode() {
 			switch (this._pattern.type) {
-				case "Any": return 0;
 				case "Digest": {
 					const data = this._pattern.digest.data().slice(0, 8);
 					let hash = 0;
@@ -2832,7 +2777,10 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				}
 				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": {
@@ -2884,28 +2832,19 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			});
 		}
 		/**
-		* 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 [];
@@ -2920,9 +2859,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				case "AssertionsInterval":
 					isHit = this._pattern.interval.contains(haystack.assertions().length);
 					break;
-				case "WithSubject":
-					isHit = true;
-					break;
 			}
 			return [isHit ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 		}
@@ -2943,7 +2879,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			switch (this._pattern.type) {
 				case "Any": return "node";
 				case "AssertionsInterval": return `node(${this._pattern.interval.toString()})`;
-				case "WithSubject": return `node(${this._pattern.subjectPattern.toString()})`;
 			}
 		}
 		/**
@@ -2954,7 +2889,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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;
 			}
 		}
 		/**
@@ -2964,7 +2898,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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;
 			}
 		}
 	};
@@ -3074,12 +3007,16 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	//#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;
@@ -3113,10 +3050,15 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 		/**
 		* 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.
@@ -3192,9 +3134,9 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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) : "?"})`;
 				}
 			}
 		}
@@ -3418,10 +3360,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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 [];
 		}
@@ -4419,30 +4358,20 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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];
@@ -4571,7 +4500,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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.
@@ -4920,17 +4849,44 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	*/
 	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))
@@ -4988,6 +4944,169 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 	}
 	//#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.
@@ -5502,6 +5621,12 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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)));
@@ -5513,6 +5638,14 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	}
 	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,
@@ -6266,305 +6399,198 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 	};
 	//#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
-	*
-	* This is a 1:1 TypeScript port of bc-envelope-pattern-rust parse/mod.rs
-	* Recursive descent parser for Gordian Envelope pattern syntax.
+	* 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
-	*/
-	/**
-	* Parse a pattern expression string into a Pattern.
+	* @module envelope-pattern/parse/leaf/array-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;
-		}
-		const next = lexer.next();
-		if (next !== void 0) return err(extraData(next.span));
-		return result;
+	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
 	/**
-	* Parse a pattern, allowing extra data after the pattern.
+	* Copyright © 2023-2026 Blockchain Commons, LLC
+	* Copyright © 2025-2026 Parity Technologies
+	*
+	* CBOR pattern parser — port of `bc-envelope-pattern-rust`
+	* `parse/leaf/cbor_parser.rs`.
+	*
+	* 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 parsePartial(input) {
-		const lexer = new Lexer(input);
-		const result = parseOr(lexer);
-		if (!result.ok) return result;
-		return ok([result.value, lexer.position]);
+	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
 	/**
-	* Convert a dcbor-pattern Pattern to an envelope-pattern 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 convertDcborPatternToEnvelopePattern$1(_dcborPattern) {
-		return ok(any());
-	}
 	/**
-	* Parse an Or expression: expr (| expr)*
+	* 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 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);
+	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));
+			}
 		}
-		if (patterns.length === 1) return ok(patterns[0]);
-		return ok(or(patterns));
+		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;
+		}
+	}
+	//#endregion
+	//#region src/parse/leaf/known-value-parser.ts
 	/**
-	* 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)*
+	* 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 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));
-	}
 	/**
-	* Parse a Not expression: !? group
+	* Maximum value of a Rust `u64`. Used to reject literals that would
+	* silently wrap or lose precision when constructing a `KnownValue`.
 	*/
-	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));
-		}
-		return parseGroup(lexer);
-	}
+	const U64_MAX = 18446744073709551615n;
 	/**
-	* Parse a Group expression: primary quantifier?
+	* 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 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()));
+	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 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));
+	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;
+		}
+		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();
@@ -6574,10 +6600,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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));
@@ -6586,16 +6609,14 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		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));
@@ -6604,300 +6625,812 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			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))));
-			}
-			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))));
+		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;
 			}
-			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
+	*
+	* 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.
 	*
-	* 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.
+	* @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.
@@ -7090,6 +7623,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	exports.registerAnyPatternFactory = registerAnyPatternFactory;
 	exports.registerArrayPatternFactory = registerArrayPatternFactory;
 	exports.registerAssertionsPatternFactory = registerAssertionsPatternFactory;
+	exports.registerAssertionsPatternToStringDispatch = registerAssertionsPatternToStringDispatch;
 	exports.registerBoolPatternFactory = registerBoolPatternFactory;
 	exports.registerByteStringPatternFactory = registerByteStringPatternFactory;
 	exports.registerCBORPatternFactory = registerCBORPatternFactory;
@@ -7111,11 +7645,13 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	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;
@@ -7155,6 +7691,6 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	exports.unwrapOr = unwrapOr;
 	exports.wrapped = wrapped;
 	return exports;
-})({}, bctsDcborPattern, bctsKnownValues, bctsEnvelope, bctsDcbor, bctsDcborParse);
+})({}, bctsDcborPattern, bctsKnownValues, bctsDcbor, bctsEnvelope, bctsDcborParse);
 
 //# sourceMappingURL=index.iife.js.map