@bcts/envelope-pattern 1.0.0-alpha.17 → 1.0.0-alpha.18

package/dist/index.iife.js

@@ -1,4 +1,4 @@
-var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_values, _bcts_envelope, _bcts_dcbor) {
+var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_values, _bcts_envelope, _bcts_dcbor, _bcts_dcbor_parse) {
 
 
 //#region src/error.ts
@@ -312,9 +312,17 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		const c = env.case();
 		let summary;
 		switch (c.type) {
-			case "node":
-				summary = `NODE ${env.summary(Number.MAX_SAFE_INTEGER)}`;
+			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}`;
 				break;
+			}
 			case "leaf":
 				summary = `LEAF ${env.summary(Number.MAX_SAFE_INTEGER)}`;
 				break;
@@ -322,7 +330,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				summary = `WRAPPED ${env.summary(Number.MAX_SAFE_INTEGER)}`;
 				break;
 			case "assertion":
-				summary = `ASSERTION ${env.summary(Number.MAX_SAFE_INTEGER)}`;
+				summary = `ASSERTION ${c.assertion.predicate().summary(Number.MAX_SAFE_INTEGER)}: ${c.assertion.object().summary(Number.MAX_SAFE_INTEGER)}`;
 				break;
 			case "elided":
 				summary = "ELIDED";
@@ -496,10 +504,15 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		});
 	}
 	/**
-	* Registry for pattern matching function to break circular dependencies.
-	* This allows meta patterns to match child patterns without importing from index.ts.
+	* Registry for pattern dispatch functions to break circular dependencies.
+	* This allows meta patterns to dispatch to child patterns without importing from index.ts.
 	*/
 	let patternMatchFn;
+	let patternPathsWithCapturesFn;
+	let patternPathsFn;
+	let patternCompileFn;
+	let patternIsComplexFn;
+	let patternToStringFn;
 	/**
 	* Registers the pattern match function.
 	* Called from index.ts after all patterns are defined.
@@ -508,6 +521,17 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		patternMatchFn = fn;
 	}
 	/**
+	* Registers all pattern dispatch functions.
+	* Called from index.ts after all patterns are defined.
+	*/
+	function registerPatternDispatchFns(fns) {
+		patternPathsWithCapturesFn = fns.pathsWithCaptures;
+		patternPathsFn = fns.paths;
+		patternCompileFn = fns.compile;
+		patternIsComplexFn = fns.isComplex;
+		patternToStringFn = fns.toString;
+	}
+	/**
 	* Match a pattern against an envelope using the registered match function.
 	* Used by meta patterns to match child patterns.
 	*/
@@ -515,6 +539,41 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		if (patternMatchFn === void 0) throw new Error("Pattern match function not registered");
 		return patternMatchFn(pattern, haystack);
 	}
+	/**
+	* Dispatch pathsWithCaptures on a Pattern.
+	*/
+	function dispatchPathsWithCaptures(pattern, haystack) {
+		if (patternPathsWithCapturesFn === void 0) throw new Error("Pattern dispatch functions not registered");
+		return patternPathsWithCapturesFn(pattern, haystack);
+	}
+	/**
+	* Dispatch paths on a Pattern.
+	*/
+	function dispatchPaths(pattern, haystack) {
+		if (patternPathsFn === void 0) throw new Error("Pattern dispatch functions not registered");
+		return patternPathsFn(pattern, haystack);
+	}
+	/**
+	* Dispatch compile on a Pattern.
+	*/
+	function dispatchCompile(pattern, code, literals, captures) {
+		if (patternCompileFn === void 0) throw new Error("Pattern dispatch functions not registered");
+		patternCompileFn(pattern, code, literals, captures);
+	}
+	/**
+	* Dispatch isComplex on a Pattern.
+	*/
+	function dispatchIsComplex(pattern) {
+		if (patternIsComplexFn === void 0) throw new Error("Pattern dispatch functions not registered");
+		return patternIsComplexFn(pattern);
+	}
+	/**
+	* Dispatch toString on a Pattern.
+	*/
+	function dispatchPatternToString(pattern) {
+		if (patternToStringFn === void 0) throw new Error("Pattern dispatch functions not registered");
+		return patternToStringFn(pattern);
+	}
 
 //#endregion
 //#region src/pattern/leaf/bool-pattern.ts
@@ -560,7 +619,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.boolPatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -633,7 +692,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.nullPatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -761,7 +820,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.numberPatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -892,7 +951,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.textPatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -997,7 +1056,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.byteStringPatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -1133,7 +1192,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.datePatternPaths)(this._inner, cbor).length > 0) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -1245,7 +1304,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._pattern;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			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()];
@@ -1389,7 +1448,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._pattern;
 		}
 		pathsWithCaptures(haystack) {
-			const cbor = haystack.asLeaf();
+			const cbor = haystack.subject().asLeaf();
 			if (cbor === void 0) return [[], /* @__PURE__ */ new Map()];
 			const map = (0, _bcts_dcbor.asCborMap)(cbor);
 			if (map === void 0) return [[], /* @__PURE__ */ new Map()];
@@ -1498,12 +1557,13 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			return this._inner;
 		}
 		pathsWithCaptures(haystack) {
-			const envCase = haystack.case();
+			const subject = haystack.subject();
+			const envCase = subject.case();
 			if (envCase.type === "knownValue") {
 				const knownValueCbor = envCase.value.taggedCbor();
 				if ((0, _bcts_dcbor_pattern.knownValuePatternMatches)(this._inner, knownValueCbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
-			const leafCbor = haystack.asLeaf();
+			const leafCbor = subject.asLeaf();
 			if (leafCbor !== void 0) {
 				if ((0, _bcts_dcbor_pattern.knownValuePatternMatches)(this._inner, leafCbor)) return [[[haystack]], /* @__PURE__ */ new Map()];
 			}
@@ -1815,7 +1875,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			} else i++;
 		}
 		pathsWithCaptures(haystack) {
-			const envCase = haystack.case();
+			const envCase = haystack.subject().case();
 			if (envCase.type === "knownValue") {
 				const knownValueCbor = envCase.value.taggedCbor();
 				switch (this._pattern.type) {
@@ -1840,7 +1900,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					}
 				}
 			}
-			const leafCbor = haystack.asLeaf();
+			const leafCbor = haystack.subject().asLeaf();
 			if (leafCbor === void 0) return [[], /* @__PURE__ */ new Map()];
 			switch (this._pattern.type) {
 				case "Any": return [[[haystack]], /* @__PURE__ */ new Map()];
@@ -2027,7 +2087,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	*/
 	function leafPatternPathsWithCaptures(pattern, haystack) {
 		switch (pattern.type) {
-			case "Cbor": return [[], /* @__PURE__ */ new Map()];
+			case "Cbor": return pattern.pattern.pathsWithCaptures(haystack);
 			case "Number": return pattern.pattern.pathsWithCaptures(haystack);
 			case "Text": return pattern.pattern.pathsWithCaptures(haystack);
 			case "ByteString": return pattern.pattern.pathsWithCaptures(haystack);
@@ -2227,7 +2287,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					paths = [[subject]];
 					break;
 				case "Pattern":
-					if (this._pattern.pattern.matches(subject)) paths = [[subject]];
+					if (matchPattern(this._pattern.pattern, subject)) paths = [[subject]];
 					else paths = [];
 					break;
 			}
@@ -2329,7 +2389,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					paths = [[predicate]];
 					break;
 				case "Pattern":
-					if (this._pattern.pattern.matches(predicate)) paths = [[predicate]];
+					if (matchPattern(this._pattern.pattern, predicate)) paths = [[predicate]];
 					else paths = [];
 					break;
 			}
@@ -2427,7 +2487,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					paths = [[object]];
 					break;
 				case "Pattern":
-					if (this._pattern.pattern.matches(object)) paths = [[object]];
+					if (matchPattern(this._pattern.pattern, object)) paths = [[object]];
 					else paths = [];
 					break;
 			}
@@ -2555,14 +2615,14 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 				case "WithPredicate": {
 					const predicate = assertion.asPredicate?.();
 					if (predicate !== void 0) {
-						if (this._pattern.pattern.matches(predicate)) paths.push([assertion]);
+						if (matchPattern(this._pattern.pattern, predicate)) paths.push([assertion]);
 					}
 					break;
 				}
 				case "WithObject": {
 					const object = assertion.asObject?.();
 					if (object !== void 0) {
-						if (this._pattern.pattern.matches(object)) paths.push([assertion]);
+						if (matchPattern(this._pattern.pattern, object)) paths.push([assertion]);
 					}
 					break;
 				}
@@ -2570,9 +2630,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					const predicate = assertion.asPredicate?.();
 					const object = assertion.asObject?.();
 					if (predicate !== void 0 && object !== void 0) {
-						const predMatcher = this._pattern.predicatePattern;
-						const objMatcher = this._pattern.objectPattern;
-						if (predMatcher.matches(predicate) && objMatcher.matches(object)) paths.push([assertion]);
+						if (matchPattern(this._pattern.predicatePattern, predicate) && matchPattern(this._pattern.objectPattern, object)) paths.push([assertion]);
 					}
 					break;
 				}
@@ -3024,9 +3082,17 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 //#endregion
 //#region src/pattern/structure/wrapped-pattern.ts
 	let createStructureWrappedPattern;
+	let dispatchPatternPathsWithCaptures;
+	let dispatchPatternCompile;
+	let dispatchPatternToString$1;
 	function registerWrappedPatternFactory(factory) {
 		createStructureWrappedPattern = factory;
 	}
+	function registerWrappedPatternDispatch(dispatch) {
+		dispatchPatternPathsWithCaptures = dispatch.pathsWithCaptures;
+		dispatchPatternCompile = dispatch.compile;
+		dispatchPatternToString$1 = dispatch.toString;
+	}
 	/**
 	* Represents patterns for matching wrapped envelopes.
 	*
@@ -3082,10 +3148,12 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					break;
 				case "Unwrap": {
 					const unwrapped = subject.tryUnwrap?.();
-					if (unwrapped !== void 0) paths = this._pattern.pattern.paths(unwrapped).map((path) => {
-						return [haystack, ...path];
-					});
-					else paths = [];
+					if (unwrapped !== void 0 && dispatchPatternPathsWithCaptures !== void 0) {
+						const [innerPaths] = dispatchPatternPathsWithCaptures(this._pattern.pattern, unwrapped);
+						paths = innerPaths.map((path) => {
+							return [haystack, ...path];
+						});
+					} else paths = [];
 					break;
 				}
 			}
@@ -3120,7 +3188,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 						type: "PushAxis",
 						axis: "Wrapped"
 					});
-					this._pattern.pattern.compile(code, literals, captures);
+					if (dispatchPatternCompile !== void 0) dispatchPatternCompile(this._pattern.pattern, code, literals, captures);
 					break;
 				}
 			}
@@ -3132,7 +3200,7 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			switch (this._pattern.type) {
 				case "Any": return "wrapped";
 				case "Unwrap": {
-					const patternStr = this._pattern.pattern.toString();
+					const patternStr = dispatchPatternToString$1 !== void 0 ? dispatchPatternToString$1(this._pattern.pattern) : "*";
 					if (patternStr === "*") return "unwrap";
 					return `unwrap(${patternStr})`;
 				}
@@ -3327,1503 +3395,1520 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	}
 
 //#endregion
-//#region src/pattern/meta/any-pattern.ts
-	let createMetaAnyPattern;
-	function registerAnyPatternFactory(factory) {
-		createMetaAnyPattern = factory;
+//#region src/pattern/vm.ts
+	let _patternPathsWithCaptures$1;
+	let _patternMatches;
+	let _patternPaths;
+	/**
+	* Register the pattern matching functions to resolve circular dependencies.
+	*/
+	function registerVMPatternFunctions(pathsWithCaptures, matches, paths) {
+		_patternPathsWithCaptures$1 = pathsWithCaptures;
+		_patternMatches = matches;
+		_patternPaths = paths;
 	}
 	/**
-	* A pattern that matches any element.
-	*
-	* Corresponds to the Rust `AnyPattern` struct in any_pattern.rs
+	* Returns (child, EdgeType) pairs reachable from env via this axis.
 	*/
-	var AnyPattern = class AnyPattern {
-		constructor() {}
-		/**
-		* Creates a new AnyPattern.
-		*/
-		static new() {
-			return new AnyPattern();
-		}
-		pathsWithCaptures(haystack) {
-			return [[[haystack]], /* @__PURE__ */ new Map()];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(_haystack) {
-			return true;
-		}
-		compile(code, literals, captures) {
-			if (createMetaAnyPattern === void 0) throw new Error("AnyPattern factory not registered");
-			compileAsAtomic(createMetaAnyPattern(this), code, literals, captures);
-		}
-		isComplex() {
-			return false;
-		}
-		toString() {
-			return "*";
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(_other) {
-			return true;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return 0;
+	function axisChildren(axis, env) {
+		const envCase = env.case();
+		switch (axis) {
+			case "Subject":
+				if (envCase.type === "node") return [[envCase.subject, "Subject"]];
+				return [];
+			case "Assertion":
+				if (envCase.type === "node") return envCase.assertions.map((a) => [a, "Assertion"]);
+				return [];
+			case "Predicate":
+				if (envCase.type === "assertion") return [[envCase.assertion.predicate(), "Predicate"]];
+				return [];
+			case "Object":
+				if (envCase.type === "assertion") return [[envCase.assertion.object(), "Object"]];
+				return [];
+			case "Wrapped":
+				if (envCase.type === "node") {
+					const subject = envCase.subject;
+					if (subject.isWrapped()) {
+						const unwrapped = subject.unwrap();
+						if (unwrapped !== void 0) return [[unwrapped, "Content"]];
+					}
+				} else if (envCase.type === "wrapped") return [[envCase.envelope, "Content"]];
+				return [];
 		}
-	};
-
-//#endregion
-//#region src/pattern/meta/and-pattern.ts
-	let createMetaAndPattern;
-	function registerAndPatternFactory(factory) {
-		createMetaAndPattern = factory;
 	}
 	/**
-	* A pattern that matches if all contained patterns match.
-	*
-	* Corresponds to the Rust `AndPattern` struct in and_pattern.rs
+	* Clone a thread for forking.
 	*/
-	var AndPattern = class AndPattern {
-		_patterns;
-		constructor(patterns) {
-			this._patterns = patterns;
-		}
-		/**
-		* Creates a new AndPattern with the given patterns.
-		*/
-		static new(patterns) {
-			return new AndPattern(patterns);
-		}
-		/**
-		* Gets the patterns.
-		*/
-		patterns() {
-			return this._patterns;
-		}
-		pathsWithCaptures(haystack) {
-			return [this._patterns.every((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
-		}
-		compile(code, literals, captures) {
-			for (const pattern of this._patterns) pattern.compile(code, literals, captures);
-		}
-		isComplex() {
-			return this._patterns.length > 1 || this._patterns.some((p) => p.isComplex());
-		}
-		toString() {
-			return this._patterns.map((p) => p.toString()).join(" & ");
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			if (this._patterns.length !== other._patterns.length) return false;
-			for (let i = 0; i < this._patterns.length; i++) if (this._patterns[i] !== other._patterns[i]) return false;
-			return true;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return this._patterns.length;
-		}
-	};
-
-//#endregion
-//#region src/pattern/meta/or-pattern.ts
-	let createMetaOrPattern;
-	function registerOrPatternFactory(factory) {
-		createMetaOrPattern = factory;
+	function cloneThread(th) {
+		return {
+			pc: th.pc,
+			env: th.env,
+			path: [...th.path],
+			savedPaths: th.savedPaths.map((p) => [...p]),
+			captures: th.captures.map((c) => c.map((p) => [...p])),
+			captureStack: th.captureStack.map((s) => [...s]),
+			seen: new Set(th.seen)
+		};
 	}
 	/**
-	* A pattern that matches if any contained pattern matches.
+	* Get a unique key for a path based on envelope digests.
+	*/
+	function pathKey(path) {
+		return path.map((e) => e.digest().hex()).join(",");
+	}
+	/**
+	* Match atomic patterns without recursion into the VM.
 	*
-	* Corresponds to the Rust `OrPattern` struct in or_pattern.rs
+	* This function handles only the patterns that are safe to use in
+	* MatchPredicate instructions - Leaf, Structure, Any patterns.
 	*/
-	var OrPattern = class OrPattern {
-		_patterns;
-		constructor(patterns) {
-			this._patterns = patterns;
-		}
-		/**
-		* Creates a new OrPattern with the given patterns.
-		*/
-		static new(patterns) {
-			return new OrPattern(patterns);
-		}
-		/**
-		* Gets the patterns.
-		*/
-		patterns() {
-			return this._patterns;
-		}
-		pathsWithCaptures(haystack) {
-			return [this._patterns.some((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
+	function atomicPathsWithCaptures(p, env) {
+		switch (p.type) {
+			case "Leaf": return leafPatternPathsWithCaptures(p.pattern, env);
+			case "Structure": return structurePatternPathsWithCaptures(p.pattern, env);
+			case "Meta":
+				if (p.pattern.type === "Any") return p.pattern.pattern.pathsWithCaptures(env);
+				if (p.pattern.type === "Search") throw new Error("SearchPattern should be compiled to Search instruction, not MatchPredicate");
+				throw new Error(`non-atomic meta pattern used in MatchPredicate: ${p.pattern.type}`);
 		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
+	}
+	/**
+	* Execute repeat pattern matching.
+	*/
+	function repeatPaths(pat, env, path, quantifier) {
+		const states = [[[env, [...path]]]];
+		const bound = quantifier.max() ?? Number.MAX_SAFE_INTEGER;
+		for (let i = 0; i < bound; i++) {
+			const next = [];
+			const lastState = states[states.length - 1];
+			for (const [e, pth] of lastState) {
+				const subPaths = _patternPaths(pat, e);
+				for (const subPath of subPaths) {
+					const last = subPath[subPath.length - 1];
+					if (last?.digest().hex() === e.digest().hex()) continue;
+					if (last !== void 0) {
+						const combined = [...pth];
+						if (subPath[0]?.digest().hex() === e.digest().hex()) combined.push(...subPath.slice(1));
+						else combined.push(...subPath);
+						next.push([last, combined]);
+					}
+				}
+			}
+			if (next.length === 0) break;
+			states.push(next);
 		}
-		compile(code, literals, captures) {
-			if (this._patterns.length === 0) return;
-			const splits = [];
-			for (let i = 0; i < this._patterns.length - 1; i++) {
-				splits.push(code.length);
-				code.push({
-					type: "Split",
-					a: 0,
-					b: 0
-				});
-			}
-			const jumps = [];
-			for (let i = 0; i < this._patterns.length; i++) {
-				const patternStart = code.length;
-				this._patterns[i].compile(code, literals, captures);
-				const jumpPastAll = code.length;
-				code.push({
-					type: "Jump",
-					address: 0
-				});
-				jumps.push(jumpPastAll);
-				if (i < this._patterns.length - 1) {
-					const nextPattern = code.length;
-					code[splits[i]] = {
-						type: "Split",
-						a: patternStart,
-						b: nextPattern
-					};
-				}
-			}
-			const pastAll = code.length;
-			for (const jumpIdx of jumps) code[jumpIdx] = {
-				type: "Jump",
-				address: pastAll
-			};
-		}
-		isComplex() {
-			return this._patterns.length > 1 || this._patterns.some((p) => p.isComplex());
-		}
-		toString() {
-			return this._patterns.map((p) => p.toString()).join(" | ");
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			if (this._patterns.length !== other._patterns.length) return false;
-			for (let i = 0; i < this._patterns.length; i++) if (this._patterns[i] !== other._patterns[i]) return false;
-			return true;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return this._patterns.length;
-		}
-	};
-
-//#endregion
-//#region src/pattern/meta/not-pattern.ts
-	let createMetaNotPattern;
-	function registerNotPatternFactory(factory) {
-		createMetaNotPattern = factory;
-	}
-	/**
-	* A pattern that negates another pattern; matches when the inner pattern does not match.
-	*
-	* Corresponds to the Rust `NotPattern` struct in not_pattern.rs
-	*/
-	var NotPattern = class NotPattern {
-		_pattern;
-		constructor(pattern) {
-			this._pattern = pattern;
-		}
-		/**
-		* Creates a new NotPattern with the given pattern.
-		*/
-		static new(pattern) {
-			return new NotPattern(pattern);
-		}
-		/**
-		* Gets the inner pattern.
-		*/
-		pattern() {
-			return this._pattern;
-		}
-		pathsWithCaptures(haystack) {
-			return [!matchPattern(this._pattern, haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
-		}
-		compile(code, literals, _captures) {
-			const idx = literals.length;
-			literals.push(this._pattern);
-			code.push({
-				type: "NotMatch",
-				patternIndex: idx
-			});
-		}
-		isComplex() {
-			return false;
-		}
-		toString() {
-			return `!${this._pattern.toString()}`;
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			return this._pattern === other._pattern;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return 1;
-		}
-	};
-
-//#endregion
-//#region src/pattern/meta/capture-pattern.ts
-	let createMetaCapturePattern;
-	function registerCapturePatternFactory(factory) {
-		createMetaCapturePattern = factory;
-	}
-	/**
-	* A pattern that captures a match with a name.
-	*
-	* Corresponds to the Rust `CapturePattern` struct in capture_pattern.rs
-	*/
-	var CapturePattern = class CapturePattern {
-		_name;
-		_pattern;
-		constructor(name, pattern) {
-			this._name = name;
-			this._pattern = pattern;
-		}
-		/**
-		* Creates a new CapturePattern with the given name and pattern.
-		*/
-		static new(name, pattern) {
-			return new CapturePattern(name, pattern);
-		}
-		/**
-		* Gets the name of the capture.
-		*/
-		name() {
-			return this._name;
-		}
-		/**
-		* Gets the inner pattern.
-		*/
-		pattern() {
-			return this._pattern;
+		const hasZeroRep = quantifier.min() === 0;
+		const zeroRepResult = hasZeroRep ? [[env, [...path]]] : [];
+		const maxPossible = states.length - 1;
+		const maxAllowed = Math.min(bound, maxPossible);
+		if (maxAllowed < quantifier.min() && quantifier.min() > 0) return [];
+		const minCount = quantifier.min() === 0 ? 1 : quantifier.min();
+		if (maxAllowed < minCount) return zeroRepResult;
+		const maxCount = maxAllowed;
+		let counts;
+		switch (quantifier.reluctance()) {
+			case _bcts_dcbor_pattern.Reluctance.Greedy:
+				counts = [];
+				for (let c = maxCount; c >= minCount; c--) counts.push(c);
+				break;
+			case _bcts_dcbor_pattern.Reluctance.Lazy:
+				counts = [];
+				for (let c = minCount; c <= maxCount; c++) counts.push(c);
+				break;
+			case _bcts_dcbor_pattern.Reluctance.Possessive:
+				counts = maxCount >= minCount ? [maxCount] : [];
+				break;
 		}
-		pathsWithCaptures(haystack) {
-			const [paths, caps] = this._pattern.pathsWithCaptures(haystack);
-			if (paths.length > 0) {
-				const existing = caps.get(this._name) ?? [];
-				caps.set(this._name, [...existing, ...paths]);
+		const out = [];
+		if (quantifier.reluctance() === _bcts_dcbor_pattern.Reluctance.Greedy) {
+			for (const c of counts) {
+				const list = states[c];
+				if (list !== void 0) out.push(...list);
+			}
+			if (hasZeroRep && out.length === 0) out.push([env, [...path]]);
+		} else {
+			if (hasZeroRep) out.push([env, [...path]]);
+			for (const c of counts) {
+				const list = states[c];
+				if (list !== void 0) out.push(...list);
 			}
-			return [paths, caps];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
-		}
-		compile(code, literals, captures) {
-			const id = captures.length;
-			captures.push(this._name);
-			code.push({
-				type: "CaptureStart",
-				captureIndex: id
-			});
-			this._pattern.compile(code, literals, captures);
-			code.push({
-				type: "CaptureEnd",
-				captureIndex: id
-			});
-		}
-		isComplex() {
-			return false;
-		}
-		toString() {
-			return `@${this._name}(${this._pattern.toString()})`;
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			return this._name === other._name && this._pattern === other._pattern;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			let hash = 0;
-			for (const char of this._name) hash = hash * 31 + char.charCodeAt(0) | 0;
-			return hash;
 		}
-	};
-
-//#endregion
-//#region src/pattern/meta/search-pattern.ts
-	let createMetaSearchPattern;
-	function registerSearchPatternFactory(factory) {
-		createMetaSearchPattern = factory;
+		return out;
 	}
 	/**
-	* A pattern that searches the entire envelope tree for matches.
-	*
-	* Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
+	* Execute a single thread until it halts.
+	* Returns true if any paths were produced.
 	*/
-	var SearchPattern = class SearchPattern {
-		_pattern;
-		constructor(pattern) {
-			this._pattern = pattern;
-		}
-		/**
-		* Creates a new SearchPattern with the given pattern.
-		*/
-		static new(pattern) {
-			return new SearchPattern(pattern);
-		}
-		/**
-		* Gets the inner pattern.
-		*/
-		pattern() {
-			return this._pattern;
-		}
-		pathsWithCaptures(haystack) {
-			const resultPaths = [];
-			const matcher = this._pattern;
-			this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
-				const newPath = [...pathToCurrent, currentEnvelope];
-				const patternPaths = matcher.paths(currentEnvelope);
-				for (const patternPath of patternPaths) {
-					const fullPath = [...newPath];
-					if (patternPath.length > 1) fullPath.push(...patternPath.slice(1));
-					else if (patternPath.length === 1) {
-						const firstEnv = patternPath[0];
-						if (firstEnv !== void 0 && !firstEnv.digest().equals(currentEnvelope.digest())) fullPath.push(...patternPath);
+	function runThread(prog, start, out) {
+		let produced = false;
+		const stack = [start];
+		while (stack.length > 0) {
+			const th = stack.pop();
+			if (th === void 0) break;
+			while (true) {
+				const instr = prog.code[th.pc];
+				switch (instr.type) {
+					case "MatchPredicate": {
+						const [paths, patternCaptures] = atomicPathsWithCaptures(prog.literals[instr.literalIndex], th.env);
+						if (paths.length === 0) break;
+						th.pc += 1;
+						const distributedCaptures = paths.map(() => /* @__PURE__ */ new Map());
+						for (const [name, capturePaths] of patternCaptures) if (capturePaths.length === paths.length) {
+							for (let pathIdx = 0; pathIdx < capturePaths.length; pathIdx++) if (pathIdx < distributedCaptures.length) {
+								const existing = distributedCaptures[pathIdx].get(name) ?? [];
+								existing.push(capturePaths[pathIdx]);
+								distributedCaptures[pathIdx].set(name, existing);
+							}
+						} else if (distributedCaptures.length > 0) {
+							const existing = distributedCaptures[0].get(name) ?? [];
+							existing.push(...capturePaths);
+							distributedCaptures[0].set(name, existing);
+						}
+						const firstPath = paths[0];
+						if (firstPath.length === 1 && firstPath[0].digest().hex() === th.env.digest().hex()) {} else {
+							th.path = [...firstPath];
+							const lastEnv = firstPath[firstPath.length - 1];
+							if (lastEnv !== void 0) th.env = lastEnv;
+						}
+						const pathCaptures = distributedCaptures[0];
+						if (pathCaptures !== void 0) for (const [name, capPaths] of pathCaptures) {
+							const captureIdx = prog.captureNames.indexOf(name);
+							if (captureIdx >= 0 && captureIdx < th.captures.length) th.captures[captureIdx].push(...capPaths);
+						}
+						for (let i = paths.length - 1; i >= 1; i--) {
+							const fork = cloneThread(th);
+							for (const captureVec of fork.captures) captureVec.length = 0;
+							const pathI = paths[i];
+							if (pathI === void 0) continue;
+							fork.path = [...pathI];
+							const lastEnv = pathI[pathI.length - 1];
+							if (lastEnv !== void 0) fork.env = lastEnv;
+							const forkCaptures = distributedCaptures[i];
+							if (forkCaptures !== void 0) for (const [name, capPaths] of forkCaptures) {
+								const captureIdx = prog.captureNames.indexOf(name);
+								if (captureIdx >= 0 && captureIdx < fork.captures.length) fork.captures[captureIdx].push(...capPaths);
+							}
+							stack.push(fork);
+						}
+						continue;
 					}
-					resultPaths.push(fullPath);
-				}
-			});
-			const seen = /* @__PURE__ */ new Set();
-			const uniquePaths = [];
-			for (const path of resultPaths) {
-				const digestPath = path.map((e) => e.digest().hex()).join(",");
-				if (!seen.has(digestPath)) {
-					seen.add(digestPath);
-					uniquePaths.push(path);
-				}
-			}
-			return [uniquePaths, /* @__PURE__ */ new Map()];
-		}
-		/**
-		* Walk the envelope tree recursively.
-		*/
-		_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);
-			}
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
-		}
-		compile(code, literals, captures) {
-			const idx = literals.length;
-			literals.push(this._pattern);
-			const innerNames = [];
-			collectCaptureNames$1(this._pattern, innerNames);
-			const captureMap = [];
-			for (const name of innerNames) {
-				let pos = captures.indexOf(name);
-				if (pos === -1) {
-					pos = captures.length;
-					captures.push(name);
-				}
-				captureMap.push([name, pos]);
-			}
-			code.push({
-				type: "Search",
-				patternIndex: idx,
-				captureMap
-			});
-		}
-		isComplex() {
-			return true;
-		}
-		toString() {
-			return `search(${this._pattern.toString()})`;
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			return this._pattern === other._pattern;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return 1;
-		}
-	};
-	/**
-	* Collect capture names from a pattern.
-	*/
-	function collectCaptureNames$1(pattern, out) {
-		const p = pattern;
-		if (p.collectCaptureNames !== void 0) p.collectCaptureNames(out);
-	}
-
-//#endregion
-//#region src/pattern/meta/traverse-pattern.ts
-	let createMetaTraversePattern;
-	function registerTraversePatternFactory(factory) {
-		createMetaTraversePattern = factory;
-	}
-	/**
-	* A pattern that matches a traversal order of patterns.
-	*
-	* Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
-	*/
-	var TraversePattern = class TraversePattern {
-		_first;
-		_rest;
-		constructor(first, rest) {
-			this._first = first;
-			this._rest = rest;
-		}
-		/**
-		* Creates a new TraversePattern with the given patterns.
-		*/
-		static new(patterns) {
-			if (patterns.length === 0) throw new Error("TraversePattern requires at least one pattern");
-			const firstPat = patterns[0];
-			const restPatterns = patterns.slice(1);
-			return new TraversePattern(firstPat, restPatterns.length === 0 ? void 0 : TraversePattern.new(restPatterns));
-		}
-		/**
-		* Gets all patterns in this traversal.
-		*/
-		patterns() {
-			const result = [this._first];
-			if (this._rest !== void 0) result.push(...this._rest.patterns());
-			return result;
-		}
-		pathsWithCaptures(haystack) {
-			const headPaths = this._first.paths(haystack);
-			if (this._rest === void 0) return [headPaths, /* @__PURE__ */ new Map()];
-			const result = [];
-			for (const path of headPaths) {
-				const lastEnv = path[path.length - 1];
-				if (lastEnv !== void 0) {
-					const tailPaths = this._rest.paths(lastEnv);
-					for (const tailPath of tailPaths) {
-						const combined = [...path, ...tailPath];
-						result.push(combined);
+					case "MatchStructure": {
+						const literal = prog.literals[instr.literalIndex];
+						if (literal.type !== "Structure") throw new Error("MatchStructure used with non-structure pattern");
+						const structurePaths = structurePatternPaths(literal.pattern, th.env);
+						if (structurePaths.length === 0) break;
+						th.pc += 1;
+						const firstStructPath = structurePaths[0];
+						if (firstStructPath !== void 0) {
+							th.path = [...firstStructPath];
+							const firstLast = firstStructPath[firstStructPath.length - 1];
+							if (firstLast !== void 0) th.env = firstLast;
+						}
+						for (let i = structurePaths.length - 1; i >= 1; i--) {
+							const structPathI = structurePaths[i];
+							if (structPathI === void 0) continue;
+							const fork = cloneThread(th);
+							fork.path = [...structPathI];
+							const lastEnv = structPathI[structPathI.length - 1];
+							if (lastEnv !== void 0) fork.env = lastEnv;
+							stack.push(fork);
+						}
+						continue;
 					}
-				}
-			}
-			return [result, /* @__PURE__ */ new Map()];
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this.paths(haystack).length > 0;
-		}
-		compile(code, literals, captures) {
-			this._first.compile(code, literals, captures);
-			if (this._rest !== void 0) {
-				code.push({ type: "ExtendTraversal" });
-				this._rest.compile(code, literals, captures);
-				code.push({ type: "CombineTraversal" });
-			}
-		}
-		isComplex() {
-			return this._first.isComplex() || this._rest !== void 0;
-		}
-		toString() {
-			return this.patterns().map((p) => p.toString()).join(" -> ");
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			const thisPatterns = this.patterns();
-			const otherPatterns = other.patterns();
-			if (thisPatterns.length !== otherPatterns.length) return false;
-			for (let i = 0; i < thisPatterns.length; i++) if (thisPatterns[i] !== otherPatterns[i]) return false;
-			return true;
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return this.patterns().length;
+					case "Split": {
+						const fork = cloneThread(th);
+						fork.pc = instr.a;
+						stack.push(fork);
+						th.pc = instr.b;
+						continue;
+					}
+					case "Jump":
+						th.pc = instr.address;
+						continue;
+					case "PushAxis": {
+						th.pc += 1;
+						const children = axisChildren(instr.axis, th.env);
+						for (const [child, _edge] of children) {
+							const fork = cloneThread(th);
+							fork.env = child;
+							fork.path.push(child);
+							stack.push(fork);
+						}
+						break;
+					}
+					case "Pop":
+						th.path.pop();
+						th.pc += 1;
+						continue;
+					case "Save":
+						out.push([[...th.path], th.captures.map((c) => c.map((p) => [...p]))]);
+						produced = true;
+						th.pc += 1;
+						continue;
+					case "Accept":
+						out.push([[...th.path], th.captures.map((c) => c.map((p) => [...p]))]);
+						produced = true;
+						break;
+					case "Search": {
+						const inner = prog.literals[instr.patternIndex];
+						if (inner === void 0) break;
+						const [foundPaths, caps] = _patternPathsWithCaptures$1(inner, th.env);
+						if (foundPaths.length > 0) {
+							produced = true;
+							for (const foundPath of foundPaths) {
+								const resultPath = [...th.path];
+								if (foundPath[0]?.digest().hex() === th.env.digest().hex()) resultPath.push(...foundPath.slice(1));
+								else resultPath.push(...foundPath);
+								const resultCaps = th.captures.map((c) => c.map((p) => [...p]));
+								for (const [name, idx] of instr.captureMap) {
+									const pths = caps.get(name);
+									if (pths !== void 0) resultCaps[idx].push(...pths);
+								}
+								const key = pathKey(resultPath);
+								if (!th.seen.has(key)) {
+									th.seen.add(key);
+									out.push([resultPath, resultCaps]);
+								}
+							}
+						}
+						const allChildren = [];
+						const envCase = th.env.case();
+						switch (envCase.type) {
+							case "node":
+								allChildren.push(envCase.subject);
+								for (const assertion of envCase.assertions) allChildren.push(assertion);
+								break;
+							case "wrapped":
+								allChildren.push(envCase.envelope);
+								break;
+							case "assertion":
+								allChildren.push(envCase.assertion.predicate());
+								allChildren.push(envCase.assertion.object());
+								break;
+							case "elided":
+							case "encrypted":
+							case "compressed":
+							case "leaf":
+							case "knownValue": break;
+						}
+						for (let i = allChildren.length - 1; i >= 0; i--) {
+							const child = allChildren[i];
+							if (child === void 0) continue;
+							const fork = cloneThread(th);
+							fork.env = child;
+							fork.path.push(child);
+							stack.push(fork);
+						}
+						break;
+					}
+					case "ExtendTraversal": {
+						const lastEnv = th.path[th.path.length - 1];
+						if (lastEnv !== void 0) {
+							th.savedPaths.push([...th.path]);
+							th.env = lastEnv;
+							th.path = [lastEnv];
+						}
+						th.pc += 1;
+						continue;
+					}
+					case "CombineTraversal": {
+						const savedPath = th.savedPaths.pop();
+						if (savedPath !== void 0) {
+							const combined = [...savedPath];
+							const savedLast = savedPath[savedPath.length - 1];
+							if (savedLast?.digest().hex() === th.path[0]?.digest().hex() && savedLast !== void 0) combined.push(...th.path.slice(1));
+							else combined.push(...th.path);
+							th.path = combined;
+						}
+						th.pc += 1;
+						continue;
+					}
+					case "NavigateSubject":
+						if (th.env.isNode()) {
+							const subject = th.env.subject();
+							th.env = subject;
+							th.path.push(subject);
+						}
+						th.pc += 1;
+						continue;
+					case "NotMatch": {
+						const pattern = prog.literals[instr.patternIndex];
+						if (_patternMatches(pattern, th.env)) break;
+						else {
+							th.pc += 1;
+							continue;
+						}
+					}
+					case "Repeat": {
+						const pat = prog.literals[instr.patternIndex];
+						const results = repeatPaths(pat, th.env, th.path, instr.quantifier);
+						if (results.length === 0) break;
+						const nextPc = th.pc + 1;
+						let success = false;
+						for (const [envAfter, pathAfter] of results) {
+							const fork = cloneThread(th);
+							fork.pc = nextPc;
+							fork.env = envAfter;
+							fork.path = pathAfter;
+							if (runThread(prog, fork, out)) {
+								produced = true;
+								success = true;
+								break;
+							}
+						}
+						if (!success) {}
+						break;
+					}
+					case "CaptureStart": {
+						const id = instr.captureIndex;
+						if (id < th.captureStack.length) th.captureStack[id].push(th.path.length - 1);
+						th.pc += 1;
+						continue;
+					}
+					case "CaptureEnd": {
+						const id = instr.captureIndex;
+						if (id < th.captureStack.length) {
+							const startIdx = th.captureStack[id].pop();
+							if (startIdx !== void 0 && id < th.captures.length) {
+								let end = th.path.length;
+								if (prog.code[th.pc + 1]?.type === "ExtendTraversal") end = Math.max(0, end - 1);
+								const cap = th.path.slice(startIdx, end);
+								th.captures[id].push(cap);
+							}
+						}
+						th.pc += 1;
+						continue;
+					}
+				}
+				break;
+			}
 		}
-	};
-
-//#endregion
-//#region src/pattern/meta/group-pattern.ts
-	let createMetaGroupPattern;
-	function registerGroupPatternFactory(factory) {
-		createMetaGroupPattern = factory;
+		return produced;
 	}
 	/**
-	* A pattern that matches with repetition.
-	*
-	* Corresponds to the Rust `GroupPattern` struct in repeat_pattern.rs
+	* Execute prog starting at root.
+	* Every time SAVE or ACCEPT executes, the current path is pushed into the result.
 	*/
-	var GroupPattern = class GroupPattern {
-		_pattern;
-		_quantifier;
-		constructor(pattern, quantifier) {
-			this._pattern = pattern;
-			this._quantifier = quantifier;
-		}
-		/**
-		* Creates a new GroupPattern with the specified sub-pattern and quantifier.
-		*/
-		static repeat(pattern, quantifier) {
-			return new GroupPattern(pattern, quantifier);
-		}
-		/**
-		* Creates a new GroupPattern with a quantifier that matches exactly once.
-		*/
-		static new(pattern) {
-			return new GroupPattern(pattern, _bcts_dcbor_pattern.Quantifier.exactly(1));
-		}
-		/**
-		* Gets the sub-pattern of this group pattern.
-		*/
-		pattern() {
-			return this._pattern;
-		}
-		/**
-		* Gets the quantifier of this group pattern.
-		*/
-		quantifier() {
-			return this._quantifier;
-		}
-		pathsWithCaptures(_haystack) {
-			throw new Error("GroupPattern does not support pathsWithCaptures directly; use compile instead");
-		}
-		paths(haystack) {
-			return this.pathsWithCaptures(haystack)[0];
-		}
-		matches(haystack) {
-			return this._pattern.matches(haystack);
-		}
-		compile(code, literals, _captures) {
-			const idx = literals.length;
-			literals.push(this._pattern);
-			code.push({
-				type: "Repeat",
-				patternIndex: idx,
-				quantifier: this._quantifier
-			});
-		}
-		isComplex() {
-			return true;
-		}
-		toString() {
-			const formattedRange = this._quantifier.toString();
-			return `(${this._pattern.toString()})${formattedRange}`;
-		}
-		/**
-		* Equality comparison.
-		*/
-		equals(other) {
-			return this._pattern === other._pattern && this._quantifier.equals(other._quantifier);
-		}
-		/**
-		* Hash code for use in Maps/Sets.
-		*/
-		hashCode() {
-			return this._quantifier.min() * 31 + (this._quantifier.max() ?? 0);
-		}
-	};
-
-//#endregion
-//#region src/pattern/meta/index.ts
-/**
-	* Creates an Any meta pattern.
-	*/
-	function metaAny(pattern) {
-		return {
-			type: "Any",
-			pattern
-		};
-	}
-	/**
-	* Creates an And meta pattern.
-	*/
-	function metaAnd(pattern) {
-		return {
-			type: "And",
-			pattern
-		};
-	}
-	/**
-	* Creates an Or meta pattern.
-	*/
-	function metaOr(pattern) {
-		return {
-			type: "Or",
-			pattern
-		};
-	}
-	/**
-	* Creates a Not meta pattern.
-	*/
-	function metaNot(pattern) {
-		return {
-			type: "Not",
-			pattern
-		};
-	}
-	/**
-	* Creates a Capture meta pattern.
-	*/
-	function metaCapture(pattern) {
-		return {
-			type: "Capture",
-			pattern
-		};
-	}
-	/**
-	* Creates a Search meta pattern.
-	*/
-	function metaSearch(pattern) {
-		return {
-			type: "Search",
-			pattern
-		};
-	}
-	/**
-	* Creates a Traverse meta pattern.
-	*/
-	function metaTraverse(pattern) {
-		return {
-			type: "Traverse",
-			pattern
-		};
-	}
-	/**
-	* Creates a Group meta pattern.
-	*/
-	function metaGroup(pattern) {
-		return {
-			type: "Group",
-			pattern
-		};
-	}
-	/**
-	* Gets paths with captures for a meta pattern.
-	*/
-	function metaPatternPathsWithCaptures(pattern, haystack) {
-		switch (pattern.type) {
-			case "Any": return pattern.pattern.pathsWithCaptures(haystack);
-			case "And": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Or": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Not": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Capture": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Search": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Traverse": return pattern.pattern.pathsWithCaptures(haystack);
-			case "Group": return pattern.pattern.pathsWithCaptures(haystack);
+	function run(prog, root) {
+		const out = [];
+		runThread(prog, {
+			pc: 0,
+			env: root,
+			path: [root],
+			savedPaths: [],
+			captures: prog.captureNames.map(() => []),
+			captureStack: prog.captureNames.map(() => []),
+			seen: /* @__PURE__ */ new Set()
+		}, out);
+		return out.map(([path, caps]) => {
+			const map = /* @__PURE__ */ new Map();
+			for (let i = 0; i < caps.length; i++) {
+				const paths = caps[i];
+				if (paths.length > 0) map.set(prog.captureNames[i], paths);
+			}
+			return [path, map];
+		});
+	}
+	/**
+	* Compile a pattern to bytecode program.
+	*/
+	function compile(pattern) {
+		const code = [];
+		const literals = [];
+		const captureNames = [];
+		collectCaptureNames$1(pattern, captureNames);
+		compilePattern(pattern, code, literals, captureNames);
+		code.push({ type: "Accept" });
+		return {
+			code,
+			literals,
+			captureNames
+		};
+	}
+	/**
+	* Collect capture names from a pattern recursively.
+	*/
+	function collectCaptureNames$1(pattern, out) {
+		switch (pattern.type) {
+			case "Leaf": break;
+			case "Structure":
+				collectStructureCaptureNames(pattern.pattern, out);
+				break;
+			case "Meta":
+				collectMetaCaptureNames(pattern.pattern, out);
+				break;
 		}
 	}
-	/**
-	* Compiles a meta pattern to bytecode.
-	*/
-	function metaPatternCompile(pattern, code, literals, captures) {
+	function collectStructureCaptureNames(pattern, out) {
 		switch (pattern.type) {
-			case "Any":
-				pattern.pattern.compile(code, literals, captures);
-				break;
-			case "And":
-				pattern.pattern.compile(code, literals, captures);
-				break;
-			case "Or":
-				pattern.pattern.compile(code, literals, captures);
+			case "Subject": {
+				const inner = pattern.pattern.innerPattern();
+				if (inner !== void 0) collectCaptureNames$1(inner, out);
 				break;
-			case "Not":
-				pattern.pattern.compile(code, literals, captures);
+			}
+			case "Predicate": {
+				const inner = pattern.pattern.innerPattern();
+				if (inner !== void 0) collectCaptureNames$1(inner, out);
 				break;
-			case "Capture":
-				pattern.pattern.compile(code, literals, captures);
+			}
+			case "Object": {
+				const inner = pattern.pattern.innerPattern();
+				if (inner !== void 0) collectCaptureNames$1(inner, out);
 				break;
-			case "Search":
-				pattern.pattern.compile(code, literals, captures);
+			}
+			case "Assertions": {
+				const predPat = pattern.pattern.predicatePattern();
+				if (predPat !== void 0) collectCaptureNames$1(predPat, out);
+				const objPat = pattern.pattern.objectPattern();
+				if (objPat !== void 0) collectCaptureNames$1(objPat, out);
 				break;
-			case "Traverse":
-				pattern.pattern.compile(code, literals, captures);
+			}
+			case "Node": {
+				const subjPat = pattern.pattern.subjectPattern();
+				if (subjPat !== void 0) collectCaptureNames$1(subjPat, out);
+				for (const assertionPat of pattern.pattern.assertionPatterns()) collectCaptureNames$1(assertionPat, out);
 				break;
-			case "Group":
-				pattern.pattern.compile(code, literals, captures);
+			}
+			case "Wrapped": {
+				const inner = pattern.pattern.innerPattern();
+				if (inner !== void 0) collectCaptureNames$1(inner, out);
 				break;
+			}
+			case "Digest":
+			case "Obscured":
+			case "Leaf": break;
 		}
 	}
-	/**
-	* Checks if a meta pattern is complex.
-	*/
-	function metaPatternIsComplex(pattern) {
-		switch (pattern.type) {
-			case "Any": return pattern.pattern.isComplex();
-			case "And": return pattern.pattern.isComplex();
-			case "Or": return pattern.pattern.isComplex();
-			case "Not": return pattern.pattern.isComplex();
-			case "Capture": return pattern.pattern.isComplex();
-			case "Search": return pattern.pattern.isComplex();
-			case "Traverse": return pattern.pattern.isComplex();
-			case "Group": return pattern.pattern.isComplex();
-		}
-	}
-	/**
-	* Converts a meta pattern to string.
-	*/
-	function metaPatternToString(pattern) {
-		switch (pattern.type) {
-			case "Any": return pattern.pattern.toString();
-			case "And": return pattern.pattern.toString();
-			case "Or": return pattern.pattern.toString();
-			case "Not": return pattern.pattern.toString();
-			case "Capture": return pattern.pattern.toString();
-			case "Search": return pattern.pattern.toString();
-			case "Traverse": return pattern.pattern.toString();
-			case "Group": return pattern.pattern.toString();
-		}
-	}
-	/**
-	* Collects capture names from a meta pattern.
-	*/
-	function metaPatternCollectCaptureNames(pattern, out) {
+	function collectMetaCaptureNames(pattern, out) {
 		switch (pattern.type) {
 			case "Any": break;
 			case "And":
-				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
+				for (const p of pattern.pattern.patterns()) collectCaptureNames$1(p, out);
 				break;
 			case "Or":
-				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
+				for (const p of pattern.pattern.patterns()) collectCaptureNames$1(p, out);
 				break;
 			case "Not":
-				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+				collectCaptureNames$1(pattern.pattern.pattern(), out);
 				break;
 			case "Capture": {
 				const name = pattern.pattern.name();
 				if (!out.includes(name)) out.push(name);
-				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+				collectCaptureNames$1(pattern.pattern.pattern(), out);
 				break;
 			}
 			case "Search":
-				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+				collectCaptureNames$1(pattern.pattern.pattern(), out);
 				break;
 			case "Traverse":
-				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
+				for (const p of pattern.pattern.patterns()) collectCaptureNames$1(p, out);
 				break;
 			case "Group":
-				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+				collectCaptureNames$1(pattern.pattern.pattern(), out);
 				break;
 		}
 	}
 	/**
-	* Helper to collect capture names from any Pattern.
-	*/
-	function collectCaptureNamesFromPattern(pattern, out) {
-		const p = pattern;
-		if (p.collectCaptureNames !== void 0) p.collectCaptureNames(out);
-	}
-
-//#endregion
-//#region src/pattern/vm.ts
-	let _patternPathsWithCaptures;
-	let _patternMatches;
-	let _patternPaths;
-	/**
-	* Register the pattern matching functions to resolve circular dependencies.
+	* Compile a pattern to bytecode.
 	*/
-	function registerVMPatternFunctions(pathsWithCaptures, matches, paths) {
-		_patternPathsWithCaptures = pathsWithCaptures;
-		_patternMatches = matches;
-		_patternPaths = paths;
+	function compilePattern(pattern, code, literals, captureNames) {
+		switch (pattern.type) {
+			case "Leaf":
+			case "Structure":
+				literals.push(pattern);
+				code.push({
+					type: "MatchPredicate",
+					literalIndex: literals.length - 1
+				});
+				break;
+			case "Meta":
+				compileMetaPattern(pattern.pattern, code, literals, captureNames);
+				break;
+		}
 	}
-	/**
-	* Returns (child, EdgeType) pairs reachable from env via this axis.
-	*/
-	function axisChildren(axis, env) {
-		const envCase = env.case();
-		switch (axis) {
-			case "Subject":
-				if (envCase.type === "node") return [[envCase.subject, "Subject"]];
-				return [];
-			case "Assertion":
-				if (envCase.type === "node") return envCase.assertions.map((a) => [a, "Assertion"]);
-				return [];
-			case "Predicate":
-				if (envCase.type === "assertion") return [[envCase.assertion.predicate(), "Predicate"]];
-				return [];
-			case "Object":
-				if (envCase.type === "assertion") return [[envCase.assertion.object(), "Object"]];
-				return [];
-			case "Wrapped":
-				if (envCase.type === "node") {
-					const subject = envCase.subject;
-					if (subject.isWrapped()) {
-						const unwrapped = subject.unwrap();
-						if (unwrapped !== void 0) return [[unwrapped, "Content"]];
+	function compileMetaPattern(pattern, code, literals, captureNames) {
+		switch (pattern.type) {
+			case "Any": {
+				const anyPattern = {
+					type: "Meta",
+					pattern
+				};
+				literals.push(anyPattern);
+				code.push({
+					type: "MatchPredicate",
+					literalIndex: literals.length - 1
+				});
+				break;
+			}
+			case "And": {
+				const patterns = pattern.pattern.patterns();
+				for (const p of patterns) compilePattern(p, code, literals, captureNames);
+				break;
+			}
+			case "Or": {
+				const patterns = pattern.pattern.patterns();
+				if (patterns.length === 0) return;
+				if (patterns.length === 1) {
+					compilePattern(patterns[0], code, literals, captureNames);
+					return;
+				}
+				const jumpAddresses = [];
+				for (let i = 0; i < patterns.length - 1; i++) {
+					const splitAddr = code.length;
+					code.push({
+						type: "Split",
+						a: 0,
+						b: 0
+					});
+					const aStart = code.length;
+					compilePattern(patterns[i], code, literals, captureNames);
+					jumpAddresses.push(code.length);
+					code.push({
+						type: "Jump",
+						address: 0
+					});
+					const bStart = code.length;
+					code[splitAddr].a = aStart;
+					code[splitAddr].b = bStart;
+				}
+				compilePattern(patterns[patterns.length - 1], code, literals, captureNames);
+				const endAddr = code.length;
+				for (const jumpAddr of jumpAddresses) code[jumpAddr].address = endAddr;
+				break;
+			}
+			case "Not": {
+				const innerPattern = pattern.pattern.pattern();
+				literals.push(innerPattern);
+				code.push({
+					type: "NotMatch",
+					patternIndex: literals.length - 1
+				});
+				break;
+			}
+			case "Capture": {
+				const name = pattern.pattern.name();
+				const captureIndex = captureNames.indexOf(name);
+				code.push({
+					type: "CaptureStart",
+					captureIndex
+				});
+				compilePattern(pattern.pattern.pattern(), code, literals, captureNames);
+				code.push({
+					type: "CaptureEnd",
+					captureIndex
+				});
+				break;
+			}
+			case "Search": {
+				const innerCaptureNames = [];
+				collectCaptureNames$1(pattern.pattern.pattern(), innerCaptureNames);
+				const captureMap = innerCaptureNames.map((name) => {
+					const idx = captureNames.indexOf(name);
+					return [name, idx >= 0 ? idx : 0];
+				});
+				literals.push(pattern.pattern.pattern());
+				code.push({
+					type: "Search",
+					patternIndex: literals.length - 1,
+					captureMap
+				});
+				break;
+			}
+			case "Traverse": {
+				const patterns = pattern.pattern.patterns();
+				if (patterns.length > 0) {
+					compilePattern(patterns[0], code, literals, captureNames);
+					for (let i = 1; i < patterns.length; i++) {
+						code.push({ type: "ExtendTraversal" });
+						compilePattern(patterns[i], code, literals, captureNames);
 					}
-				} else if (envCase.type === "wrapped") return [[envCase.envelope, "Content"]];
-				return [];
+					for (let i = 1; i < patterns.length; i++) code.push({ type: "CombineTraversal" });
+				}
+				break;
+			}
+			case "Group": {
+				const quantifier = pattern.pattern.quantifier();
+				if (quantifier !== void 0 && !(quantifier.min() === 1 && quantifier.max() === 1)) {
+					literals.push(pattern.pattern.pattern());
+					code.push({
+						type: "Repeat",
+						patternIndex: literals.length - 1,
+						quantifier
+					});
+				} else compilePattern(pattern.pattern.pattern(), code, literals, captureNames);
+				break;
+			}
 		}
 	}
-	/**
-	* Clone a thread for forking.
-	*/
-	function cloneThread(th) {
-		return {
-			pc: th.pc,
-			env: th.env,
-			path: [...th.path],
-			savedPaths: th.savedPaths.map((p) => [...p]),
-			captures: th.captures.map((c) => c.map((p) => [...p])),
-			captureStack: th.captureStack.map((s) => [...s]),
-			seen: new Set(th.seen)
-		};
-	}
-	/**
-	* Get a unique key for a path based on envelope digests.
-	*/
-	function pathKey(path) {
-		return path.map((e) => e.digest().hex()).join(",");
+
+//#endregion
+//#region src/pattern/meta/any-pattern.ts
+	let createMetaAnyPattern;
+	function registerAnyPatternFactory(factory) {
+		createMetaAnyPattern = factory;
 	}
 	/**
-	* Match atomic patterns without recursion into the VM.
+	* A pattern that matches any element.
 	*
-	* This function handles only the patterns that are safe to use in
-	* MatchPredicate instructions - Leaf, Structure, Any patterns.
+	* Corresponds to the Rust `AnyPattern` struct in any_pattern.rs
 	*/
-	function atomicPathsWithCaptures(p, env) {
-		switch (p.type) {
-			case "Leaf": return leafPatternPathsWithCaptures(p.pattern, env);
-			case "Structure": return structurePatternPathsWithCaptures(p.pattern, env);
-			case "Meta":
-				if (p.pattern.type === "Any") return p.pattern.pattern.pathsWithCaptures(env);
-				if (p.pattern.type === "Search") throw new Error("SearchPattern should be compiled to Search instruction, not MatchPredicate");
-				throw new Error(`non-atomic meta pattern used in MatchPredicate: ${p.pattern.type}`);
+	var AnyPattern = class AnyPattern {
+		constructor() {}
+		/**
+		* Creates a new AnyPattern.
+		*/
+		static new() {
+			return new AnyPattern();
+		}
+		pathsWithCaptures(haystack) {
+			return [[[haystack]], /* @__PURE__ */ new Map()];
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(_haystack) {
+			return true;
+		}
+		compile(code, literals, captures) {
+			if (createMetaAnyPattern === void 0) throw new Error("AnyPattern factory not registered");
+			compileAsAtomic(createMetaAnyPattern(this), code, literals, captures);
+		}
+		isComplex() {
+			return false;
+		}
+		toString() {
+			return "*";
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(_other) {
+			return true;
 		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return 0;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/and-pattern.ts
+	let createMetaAndPattern;
+	function registerAndPatternFactory(factory) {
+		createMetaAndPattern = factory;
 	}
 	/**
-	* Execute repeat pattern matching.
+	* A pattern that matches if all contained patterns match.
+	*
+	* Corresponds to the Rust `AndPattern` struct in and_pattern.rs
 	*/
-	function repeatPaths(pat, env, path, quantifier) {
-		const states = [[[env, [...path]]]];
-		const bound = quantifier.max() ?? Number.MAX_SAFE_INTEGER;
-		for (let i = 0; i < bound; i++) {
-			const next = [];
-			const lastState = states[states.length - 1];
-			for (const [e, pth] of lastState) {
-				const subPaths = _patternPaths(pat, e);
-				for (const subPath of subPaths) {
-					const last = subPath[subPath.length - 1];
-					if (last?.digest().hex() === e.digest().hex()) continue;
-					if (last !== void 0) {
-						const combined = [...pth];
-						if (subPath[0]?.digest().hex() === e.digest().hex()) combined.push(...subPath.slice(1));
-						else combined.push(...subPath);
-						next.push([last, combined]);
-					}
-				}
-			}
-			if (next.length === 0) break;
-			states.push(next);
-		}
-		const hasZeroRep = quantifier.min() === 0;
-		const zeroRepResult = hasZeroRep ? [[env, [...path]]] : [];
-		const maxPossible = states.length - 1;
-		const maxAllowed = Math.min(bound, maxPossible);
-		if (maxAllowed < quantifier.min() && quantifier.min() > 0) return [];
-		const minCount = quantifier.min() === 0 ? 1 : quantifier.min();
-		if (maxAllowed < minCount) return zeroRepResult;
-		const maxCount = maxAllowed;
-		let counts;
-		switch (quantifier.reluctance()) {
-			case _bcts_dcbor_pattern.Reluctance.Greedy:
-				counts = [];
-				for (let c = maxCount; c >= minCount; c--) counts.push(c);
-				break;
-			case _bcts_dcbor_pattern.Reluctance.Lazy:
-				counts = [];
-				for (let c = minCount; c <= maxCount; c++) counts.push(c);
-				break;
-			case _bcts_dcbor_pattern.Reluctance.Possessive:
-				counts = maxCount >= minCount ? [maxCount] : [];
-				break;
+	var AndPattern = class AndPattern {
+		_patterns;
+		constructor(patterns) {
+			this._patterns = patterns;
 		}
-		const out = [];
-		if (quantifier.reluctance() === _bcts_dcbor_pattern.Reluctance.Greedy) {
-			for (const c of counts) {
-				const list = states[c];
-				if (list !== void 0) out.push(...list);
+		/**
+		* Creates a new AndPattern with the given patterns.
+		*/
+		static new(patterns) {
+			return new AndPattern(patterns);
+		}
+		/**
+		* Gets the patterns.
+		*/
+		patterns() {
+			return this._patterns;
+		}
+		pathsWithCaptures(haystack) {
+			return [this._patterns.every((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, captures) {
+			for (const pattern of this._patterns) dispatchCompile(pattern, code, literals, captures);
+		}
+		isComplex() {
+			return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
+		}
+		toString() {
+			return this._patterns.map((p) => dispatchPatternToString(p)).join(" & ");
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			if (this._patterns.length !== other._patterns.length) return false;
+			for (let i = 0; i < this._patterns.length; i++) if (this._patterns[i] !== other._patterns[i]) return false;
+			return true;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return this._patterns.length;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/or-pattern.ts
+	let createMetaOrPattern;
+	function registerOrPatternFactory(factory) {
+		createMetaOrPattern = factory;
+	}
+	/**
+	* A pattern that matches if any contained pattern matches.
+	*
+	* Corresponds to the Rust `OrPattern` struct in or_pattern.rs
+	*/
+	var OrPattern = class OrPattern {
+		_patterns;
+		constructor(patterns) {
+			this._patterns = patterns;
+		}
+		/**
+		* Creates a new OrPattern with the given patterns.
+		*/
+		static new(patterns) {
+			return new OrPattern(patterns);
+		}
+		/**
+		* Gets the patterns.
+		*/
+		patterns() {
+			return this._patterns;
+		}
+		pathsWithCaptures(haystack) {
+			for (const pattern of this._patterns) {
+				const [paths, captures] = dispatchPathsWithCaptures(pattern, haystack);
+				if (paths.length > 0) return [paths, captures];
 			}
-			if (hasZeroRep && out.length === 0) out.push([env, [...path]]);
-		} else {
-			if (hasZeroRep) out.push([env, [...path]]);
-			for (const c of counts) {
-				const list = states[c];
-				if (list !== void 0) out.push(...list);
+			return [[], /* @__PURE__ */ new Map()];
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, captures) {
+			if (this._patterns.length === 0) return;
+			const splits = [];
+			for (let i = 0; i < this._patterns.length - 1; i++) {
+				splits.push(code.length);
+				code.push({
+					type: "Split",
+					a: 0,
+					b: 0
+				});
+			}
+			const jumps = [];
+			for (let i = 0; i < this._patterns.length; i++) {
+				const patternStart = code.length;
+				const pattern = this._patterns[i];
+				dispatchCompile(pattern, code, literals, captures);
+				const jumpPastAll = code.length;
+				code.push({
+					type: "Jump",
+					address: 0
+				});
+				jumps.push(jumpPastAll);
+				if (i < this._patterns.length - 1) {
+					const nextPattern = code.length;
+					code[splits[i]] = {
+						type: "Split",
+						a: patternStart,
+						b: nextPattern
+					};
+				}
 			}
+			const pastAll = code.length;
+			for (const jumpIdx of jumps) code[jumpIdx] = {
+				type: "Jump",
+				address: pastAll
+			};
 		}
-		return out;
+		isComplex() {
+			return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
+		}
+		toString() {
+			return this._patterns.map((p) => dispatchPatternToString(p)).join(" | ");
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			if (this._patterns.length !== other._patterns.length) return false;
+			for (let i = 0; i < this._patterns.length; i++) if (this._patterns[i] !== other._patterns[i]) return false;
+			return true;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return this._patterns.length;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/not-pattern.ts
+	let createMetaNotPattern;
+	function registerNotPatternFactory(factory) {
+		createMetaNotPattern = factory;
 	}
 	/**
-	* Execute a single thread until it halts.
-	* Returns true if any paths were produced.
+	* A pattern that negates another pattern; matches when the inner pattern does not match.
+	*
+	* Corresponds to the Rust `NotPattern` struct in not_pattern.rs
 	*/
-	function runThread(prog, start, out) {
-		let produced = false;
-		const stack = [start];
-		while (stack.length > 0) {
-			const th = stack.pop();
-			if (th === void 0) break;
-			while (true) {
-				const instr = prog.code[th.pc];
-				switch (instr.type) {
-					case "MatchPredicate": {
-						const [paths, patternCaptures] = atomicPathsWithCaptures(prog.literals[instr.literalIndex], th.env);
-						if (paths.length === 0) break;
-						th.pc += 1;
-						const distributedCaptures = paths.map(() => /* @__PURE__ */ new Map());
-						for (const [name, capturePaths] of patternCaptures) if (capturePaths.length === paths.length) {
-							for (let pathIdx = 0; pathIdx < capturePaths.length; pathIdx++) if (pathIdx < distributedCaptures.length) {
-								const existing = distributedCaptures[pathIdx].get(name) ?? [];
-								existing.push(capturePaths[pathIdx]);
-								distributedCaptures[pathIdx].set(name, existing);
-							}
-						} else if (distributedCaptures.length > 0) {
-							const existing = distributedCaptures[0].get(name) ?? [];
-							existing.push(...capturePaths);
-							distributedCaptures[0].set(name, existing);
-						}
-						const firstPath = paths[0];
-						if (firstPath.length === 1 && firstPath[0].digest().hex() === th.env.digest().hex()) {} else {
-							th.path = [...firstPath];
-							const lastEnv = firstPath[firstPath.length - 1];
-							if (lastEnv !== void 0) th.env = lastEnv;
-						}
-						const pathCaptures = distributedCaptures[0];
-						if (pathCaptures !== void 0) for (const [name, capPaths] of pathCaptures) {
-							const captureIdx = prog.captureNames.indexOf(name);
-							if (captureIdx >= 0 && captureIdx < th.captures.length) th.captures[captureIdx].push(...capPaths);
-						}
-						for (let i = paths.length - 1; i >= 1; i--) {
-							const fork = cloneThread(th);
-							for (const captureVec of fork.captures) captureVec.length = 0;
-							const pathI = paths[i];
-							if (pathI === void 0) continue;
-							fork.path = [...pathI];
-							const lastEnv = pathI[pathI.length - 1];
-							if (lastEnv !== void 0) fork.env = lastEnv;
-							const forkCaptures = distributedCaptures[i];
-							if (forkCaptures !== void 0) for (const [name, capPaths] of forkCaptures) {
-								const captureIdx = prog.captureNames.indexOf(name);
-								if (captureIdx >= 0 && captureIdx < fork.captures.length) fork.captures[captureIdx].push(...capPaths);
-							}
-							stack.push(fork);
-						}
-						continue;
-					}
-					case "MatchStructure": {
-						const literal = prog.literals[instr.literalIndex];
-						if (literal.type !== "Structure") throw new Error("MatchStructure used with non-structure pattern");
-						const structurePaths = structurePatternPaths(literal.pattern, th.env);
-						if (structurePaths.length === 0) break;
-						th.pc += 1;
-						const firstStructPath = structurePaths[0];
-						if (firstStructPath !== void 0) {
-							th.path = [...firstStructPath];
-							const firstLast = firstStructPath[firstStructPath.length - 1];
-							if (firstLast !== void 0) th.env = firstLast;
-						}
-						for (let i = structurePaths.length - 1; i >= 1; i--) {
-							const structPathI = structurePaths[i];
-							if (structPathI === void 0) continue;
-							const fork = cloneThread(th);
-							fork.path = [...structPathI];
-							const lastEnv = structPathI[structPathI.length - 1];
-							if (lastEnv !== void 0) fork.env = lastEnv;
-							stack.push(fork);
-						}
-						continue;
-					}
-					case "Split": {
-						const fork = cloneThread(th);
-						fork.pc = instr.a;
-						stack.push(fork);
-						th.pc = instr.b;
-						continue;
-					}
-					case "Jump":
-						th.pc = instr.address;
-						continue;
-					case "PushAxis": {
-						th.pc += 1;
-						const children = axisChildren(instr.axis, th.env);
-						for (const [child, _edge] of children) {
-							const fork = cloneThread(th);
-							fork.env = child;
-							fork.path.push(child);
-							stack.push(fork);
-						}
-						break;
-					}
-					case "Pop":
-						th.path.pop();
-						th.pc += 1;
-						continue;
-					case "Save":
-						out.push([[...th.path], th.captures.map((c) => c.map((p) => [...p]))]);
-						produced = true;
-						th.pc += 1;
-						continue;
-					case "Accept":
-						out.push([[...th.path], th.captures.map((c) => c.map((p) => [...p]))]);
-						produced = true;
-						break;
-					case "Search": {
-						const inner = prog.literals[instr.patternIndex];
-						if (inner === void 0) break;
-						const [foundPaths, caps] = _patternPathsWithCaptures(inner, th.env);
-						if (foundPaths.length > 0) {
-							produced = true;
-							for (const foundPath of foundPaths) {
-								const resultPath = [...th.path];
-								if (foundPath[0]?.digest().hex() === th.env.digest().hex()) resultPath.push(...foundPath.slice(1));
-								else resultPath.push(...foundPath);
-								const resultCaps = th.captures.map((c) => c.map((p) => [...p]));
-								for (const [name, idx] of instr.captureMap) {
-									const pths = caps.get(name);
-									if (pths !== void 0) resultCaps[idx].push(...pths);
-								}
-								const key = pathKey(resultPath);
-								if (!th.seen.has(key)) {
-									th.seen.add(key);
-									out.push([resultPath, resultCaps]);
-								}
-							}
-						}
-						const allChildren = [];
-						const envCase = th.env.case();
-						switch (envCase.type) {
-							case "node":
-								allChildren.push(envCase.subject);
-								for (const assertion of envCase.assertions) allChildren.push(assertion);
-								break;
-							case "wrapped":
-								allChildren.push(envCase.envelope);
-								break;
-							case "assertion":
-								allChildren.push(envCase.assertion.predicate());
-								allChildren.push(envCase.assertion.object());
-								break;
-							case "elided":
-							case "encrypted":
-							case "compressed":
-							case "leaf":
-							case "knownValue": break;
-						}
-						for (let i = allChildren.length - 1; i >= 0; i--) {
-							const child = allChildren[i];
-							if (child === void 0) continue;
-							const fork = cloneThread(th);
-							fork.env = child;
-							fork.path.push(child);
-							stack.push(fork);
-						}
-						break;
-					}
-					case "ExtendTraversal": {
-						const lastEnv = th.path[th.path.length - 1];
-						if (lastEnv !== void 0) {
-							th.savedPaths.push([...th.path]);
-							th.env = lastEnv;
-							th.path = [lastEnv];
-						}
-						th.pc += 1;
-						continue;
-					}
-					case "CombineTraversal": {
-						const savedPath = th.savedPaths.pop();
-						if (savedPath !== void 0) {
-							const combined = [...savedPath];
-							const savedLast = savedPath[savedPath.length - 1];
-							if (savedLast?.digest().hex() === th.path[0]?.digest().hex() && savedLast !== void 0) combined.push(...th.path.slice(1));
-							else combined.push(...th.path);
-							th.path = combined;
-						}
-						th.pc += 1;
-						continue;
-					}
-					case "NavigateSubject":
-						if (th.env.isNode()) {
-							const subject = th.env.subject();
-							th.env = subject;
-							th.path.push(subject);
-						}
-						th.pc += 1;
-						continue;
-					case "NotMatch": {
-						const pattern = prog.literals[instr.patternIndex];
-						if (_patternMatches(pattern, th.env)) break;
-						else {
-							th.pc += 1;
-							continue;
-						}
-					}
-					case "Repeat": {
-						const pat = prog.literals[instr.patternIndex];
-						const results = repeatPaths(pat, th.env, th.path, instr.quantifier);
-						if (results.length === 0) break;
-						const nextPc = th.pc + 1;
-						let success = false;
-						for (const [envAfter, pathAfter] of results) {
-							const fork = cloneThread(th);
-							fork.pc = nextPc;
-							fork.env = envAfter;
-							fork.path = pathAfter;
-							if (runThread(prog, fork, out)) {
-								produced = true;
-								success = true;
-								break;
-							}
-						}
-						if (!success) {}
-						break;
-					}
-					case "CaptureStart": {
-						const id = instr.captureIndex;
-						if (id < th.captureStack.length) th.captureStack[id].push(th.path.length - 1);
-						th.pc += 1;
-						continue;
+	var NotPattern = class NotPattern {
+		_pattern;
+		constructor(pattern) {
+			this._pattern = pattern;
+		}
+		/**
+		* Creates a new NotPattern with the given pattern.
+		*/
+		static new(pattern) {
+			return new NotPattern(pattern);
+		}
+		/**
+		* Gets the inner pattern.
+		*/
+		pattern() {
+			return this._pattern;
+		}
+		pathsWithCaptures(haystack) {
+			return [!matchPattern(this._pattern, haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, _captures) {
+			const idx = literals.length;
+			literals.push(this._pattern);
+			code.push({
+				type: "NotMatch",
+				patternIndex: idx
+			});
+		}
+		isComplex() {
+			return false;
+		}
+		toString() {
+			return `!${dispatchPatternToString(this._pattern)}`;
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			return this._pattern === other._pattern;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return 1;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/capture-pattern.ts
+	let createMetaCapturePattern;
+	function registerCapturePatternFactory(factory) {
+		createMetaCapturePattern = factory;
+	}
+	/**
+	* A pattern that captures a match with a name.
+	*
+	* Corresponds to the Rust `CapturePattern` struct in capture_pattern.rs
+	*/
+	var CapturePattern = class CapturePattern {
+		_name;
+		_pattern;
+		constructor(name, pattern) {
+			this._name = name;
+			this._pattern = pattern;
+		}
+		/**
+		* Creates a new CapturePattern with the given name and pattern.
+		*/
+		static new(name, pattern) {
+			return new CapturePattern(name, pattern);
+		}
+		/**
+		* Gets the name of the capture.
+		*/
+		name() {
+			return this._name;
+		}
+		/**
+		* Gets the inner pattern.
+		*/
+		pattern() {
+			return this._pattern;
+		}
+		pathsWithCaptures(haystack) {
+			const [paths, caps] = dispatchPathsWithCaptures(this._pattern, haystack);
+			if (paths.length > 0) {
+				const existing = caps.get(this._name) ?? [];
+				caps.set(this._name, [...existing, ...paths]);
+			}
+			return [paths, caps];
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, captures) {
+			const id = captures.length;
+			captures.push(this._name);
+			code.push({
+				type: "CaptureStart",
+				captureIndex: id
+			});
+			dispatchCompile(this._pattern, code, literals, captures);
+			code.push({
+				type: "CaptureEnd",
+				captureIndex: id
+			});
+		}
+		isComplex() {
+			return false;
+		}
+		toString() {
+			return `@${this._name}(${dispatchPatternToString(this._pattern)})`;
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			return this._name === other._name && this._pattern === other._pattern;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			let hash = 0;
+			for (const char of this._name) hash = hash * 31 + char.charCodeAt(0) | 0;
+			return hash;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/search-pattern.ts
+	let createMetaSearchPattern;
+	function registerSearchPatternFactory(factory) {
+		createMetaSearchPattern = factory;
+	}
+	/**
+	* A pattern that searches the entire envelope tree for matches.
+	*
+	* Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
+	*/
+	var SearchPattern = class SearchPattern {
+		_pattern;
+		constructor(pattern) {
+			this._pattern = pattern;
+		}
+		/**
+		* Creates a new SearchPattern with the given pattern.
+		*/
+		static new(pattern) {
+			return new SearchPattern(pattern);
+		}
+		/**
+		* Gets the inner pattern.
+		*/
+		pattern() {
+			return this._pattern;
+		}
+		pathsWithCaptures(haystack) {
+			const resultPaths = [];
+			this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
+				const newPath = [...pathToCurrent, currentEnvelope];
+				const patternPaths = dispatchPaths(this._pattern, currentEnvelope);
+				for (const patternPath of patternPaths) {
+					const fullPath = [...newPath];
+					if (patternPath.length > 1) fullPath.push(...patternPath.slice(1));
+					else if (patternPath.length === 1) {
+						const firstEnv = patternPath[0];
+						if (firstEnv !== void 0 && !firstEnv.digest().equals(currentEnvelope.digest())) fullPath.push(...patternPath);
 					}
-					case "CaptureEnd": {
-						const id = instr.captureIndex;
-						if (id < th.captureStack.length) {
-							const startIdx = th.captureStack[id].pop();
-							if (startIdx !== void 0 && id < th.captures.length) {
-								let end = th.path.length;
-								if (prog.code[th.pc + 1]?.type === "ExtendTraversal") end = Math.max(0, end - 1);
-								const cap = th.path.slice(startIdx, end);
-								th.captures[id].push(cap);
-							}
-						}
-						th.pc += 1;
-						continue;
+					resultPaths.push(fullPath);
+				}
+			});
+			const seen = /* @__PURE__ */ new Set();
+			const uniquePaths = [];
+			for (const path of resultPaths) {
+				const digestPath = path.map((e) => e.digest().hex()).join(",");
+				if (!seen.has(digestPath)) {
+					seen.add(digestPath);
+					uniquePaths.push(path);
+				}
+			}
+			return [uniquePaths, /* @__PURE__ */ new Map()];
+		}
+		/**
+		* Walk the envelope tree recursively.
+		*/
+		_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);
+			}
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, captures) {
+			const idx = literals.length;
+			literals.push(this._pattern);
+			const innerNames = [];
+			collectCaptureNames(this._pattern, innerNames);
+			const captureMap = [];
+			for (const name of innerNames) {
+				let pos = captures.indexOf(name);
+				if (pos === -1) {
+					pos = captures.length;
+					captures.push(name);
+				}
+				captureMap.push([name, pos]);
+			}
+			code.push({
+				type: "Search",
+				patternIndex: idx,
+				captureMap
+			});
+		}
+		isComplex() {
+			return true;
+		}
+		toString() {
+			return `search(${dispatchPatternToString(this._pattern)})`;
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			return this._pattern === other._pattern;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return 1;
+		}
+	};
+	/**
+	* Collect capture names from a pattern.
+	*/
+	function collectCaptureNames(pattern, out) {
+		const p = pattern;
+		if (p.collectCaptureNames !== void 0) p.collectCaptureNames(out);
+	}
+
+//#endregion
+//#region src/pattern/meta/traverse-pattern.ts
+	let createMetaTraversePattern;
+	function registerTraversePatternFactory(factory) {
+		createMetaTraversePattern = factory;
+	}
+	let _patternPathsWithCaptures;
+	let _patternCompile;
+	let _patternIsComplex;
+	function registerTraverseDispatchFunctions(pathsWithCaptures, compile, isComplex) {
+		_patternPathsWithCaptures = pathsWithCaptures;
+		_patternCompile = compile;
+		_patternIsComplex = isComplex;
+	}
+	/**
+	* A pattern that matches a traversal order of patterns.
+	*
+	* Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
+	*/
+	var TraversePattern = class TraversePattern {
+		_first;
+		_rest;
+		constructor(first, rest) {
+			this._first = first;
+			this._rest = rest;
+		}
+		/**
+		* Creates a new TraversePattern with the given patterns.
+		*/
+		static new(patterns) {
+			if (patterns.length === 0) throw new Error("TraversePattern requires at least one pattern");
+			const firstPat = patterns[0];
+			const restPatterns = patterns.slice(1);
+			return new TraversePattern(firstPat, restPatterns.length === 0 ? void 0 : TraversePattern.new(restPatterns));
+		}
+		/**
+		* Gets all patterns in this traversal.
+		*/
+		patterns() {
+			const result = [this._first];
+			if (this._rest !== void 0) result.push(...this._rest.patterns());
+			return result;
+		}
+		pathsWithCaptures(haystack) {
+			if (_patternPathsWithCaptures === void 0) throw new Error("TraversePattern dispatch functions not registered");
+			const headPaths = _patternPathsWithCaptures(this._first, haystack)[0];
+			if (this._rest === void 0) return [headPaths, /* @__PURE__ */ new Map()];
+			const result = [];
+			for (const path of headPaths) {
+				const lastEnv = path[path.length - 1];
+				if (lastEnv !== void 0) {
+					const tailPaths = this._rest.paths(lastEnv);
+					for (const tailPath of tailPaths) {
+						const combined = [...path, ...tailPath];
+						result.push(combined);
 					}
 				}
-				break;
 			}
+			return [result, /* @__PURE__ */ new Map()];
 		}
-		return produced;
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return this.paths(haystack).length > 0;
+		}
+		compile(code, literals, captures) {
+			if (_patternCompile === void 0) throw new Error("TraversePattern dispatch functions not registered");
+			_patternCompile(this._first, code, literals, captures);
+			if (this._rest !== void 0) {
+				code.push({ type: "ExtendTraversal" });
+				this._rest.compile(code, literals, captures);
+				code.push({ type: "CombineTraversal" });
+			}
+		}
+		isComplex() {
+			if (_patternIsComplex === void 0) throw new Error("TraversePattern dispatch functions not registered");
+			return _patternIsComplex(this._first) || this._rest !== void 0;
+		}
+		toString() {
+			return this.patterns().map((p) => p.toString()).join(" -> ");
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			const thisPatterns = this.patterns();
+			const otherPatterns = other.patterns();
+			if (thisPatterns.length !== otherPatterns.length) return false;
+			for (let i = 0; i < thisPatterns.length; i++) if (thisPatterns[i] !== otherPatterns[i]) return false;
+			return true;
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return this.patterns().length;
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/group-pattern.ts
+	let createMetaGroupPattern;
+	function registerGroupPatternFactory(factory) {
+		createMetaGroupPattern = factory;
 	}
 	/**
-	* Execute prog starting at root.
-	* Every time SAVE or ACCEPT executes, the current path is pushed into the result.
+	* A pattern that matches with repetition.
+	*
+	* Corresponds to the Rust `GroupPattern` struct in repeat_pattern.rs
 	*/
-	function run(prog, root) {
-		const out = [];
-		runThread(prog, {
-			pc: 0,
-			env: root,
-			path: [root],
-			savedPaths: [],
-			captures: prog.captureNames.map(() => []),
-			captureStack: prog.captureNames.map(() => []),
-			seen: /* @__PURE__ */ new Set()
-		}, out);
-		return out.map(([path, caps]) => {
-			const map = /* @__PURE__ */ new Map();
-			for (let i = 0; i < caps.length; i++) {
-				const paths = caps[i];
-				if (paths.length > 0) map.set(prog.captureNames[i], paths);
-			}
-			return [path, map];
-		});
+	var GroupPattern = class GroupPattern {
+		_pattern;
+		_quantifier;
+		constructor(pattern, quantifier) {
+			this._pattern = pattern;
+			this._quantifier = quantifier;
+		}
+		/**
+		* Creates a new GroupPattern with the specified sub-pattern and quantifier.
+		*/
+		static repeat(pattern, quantifier) {
+			return new GroupPattern(pattern, quantifier);
+		}
+		/**
+		* Creates a new GroupPattern with a quantifier that matches exactly once.
+		*/
+		static new(pattern) {
+			return new GroupPattern(pattern, _bcts_dcbor_pattern.Quantifier.exactly(1));
+		}
+		/**
+		* Gets the sub-pattern of this group pattern.
+		*/
+		pattern() {
+			return this._pattern;
+		}
+		/**
+		* Gets the quantifier of this group pattern.
+		*/
+		quantifier() {
+			return this._quantifier;
+		}
+		pathsWithCaptures(haystack) {
+			if (this._quantifier.min() === 1 && this._quantifier.max() === 1) return dispatchPathsWithCaptures(this._pattern, haystack);
+			throw new Error("GroupPattern does not support pathsWithCaptures directly; use compile instead");
+		}
+		paths(haystack) {
+			return this.pathsWithCaptures(haystack)[0];
+		}
+		matches(haystack) {
+			return matchPattern(this._pattern, haystack);
+		}
+		compile(code, literals, _captures) {
+			const idx = literals.length;
+			literals.push(this._pattern);
+			code.push({
+				type: "Repeat",
+				patternIndex: idx,
+				quantifier: this._quantifier
+			});
+		}
+		isComplex() {
+			return true;
+		}
+		toString() {
+			const formattedRange = this._quantifier.toString();
+			return `(${dispatchPatternToString(this._pattern)})${formattedRange}`;
+		}
+		/**
+		* Equality comparison.
+		*/
+		equals(other) {
+			return this._pattern === other._pattern && this._quantifier.equals(other._quantifier);
+		}
+		/**
+		* Hash code for use in Maps/Sets.
+		*/
+		hashCode() {
+			return this._quantifier.min() * 31 + (this._quantifier.max() ?? 0);
+		}
+	};
+
+//#endregion
+//#region src/pattern/meta/index.ts
+/**
+	* Creates an Any meta pattern.
+	*/
+	function metaAny(pattern) {
+		return {
+			type: "Any",
+			pattern
+		};
 	}
 	/**
-	* Compile a pattern to bytecode program.
+	* Creates an And meta pattern.
 	*/
-	function compile(pattern) {
-		const code = [];
-		const literals = [];
-		const captureNames = [];
-		collectCaptureNames(pattern, captureNames);
-		compilePattern(pattern, code, literals, captureNames);
-		code.push({ type: "Accept" });
+	function metaAnd(pattern) {
 		return {
-			code,
-			literals,
-			captureNames
+			type: "And",
+			pattern
 		};
 	}
 	/**
-	* Collect capture names from a pattern recursively.
+	* Creates an Or meta pattern.
 	*/
-	function collectCaptureNames(pattern, out) {
-		switch (pattern.type) {
-			case "Leaf": break;
-			case "Structure":
-				collectStructureCaptureNames(pattern.pattern, out);
-				break;
-			case "Meta":
-				collectMetaCaptureNames(pattern.pattern, out);
-				break;
-		}
+	function metaOr(pattern) {
+		return {
+			type: "Or",
+			pattern
+		};
 	}
-	function collectStructureCaptureNames(pattern, out) {
-		switch (pattern.type) {
-			case "Subject": {
-				const inner = pattern.pattern.innerPattern();
-				if (inner !== void 0) collectCaptureNames(inner, out);
-				break;
-			}
-			case "Predicate": {
-				const inner = pattern.pattern.innerPattern();
-				if (inner !== void 0) collectCaptureNames(inner, out);
-				break;
-			}
-			case "Object": {
-				const inner = pattern.pattern.innerPattern();
-				if (inner !== void 0) collectCaptureNames(inner, out);
-				break;
-			}
-			case "Assertions": {
-				const predPat = pattern.pattern.predicatePattern();
-				if (predPat !== void 0) collectCaptureNames(predPat, out);
-				const objPat = pattern.pattern.objectPattern();
-				if (objPat !== void 0) collectCaptureNames(objPat, out);
-				break;
-			}
-			case "Node": {
-				const subjPat = pattern.pattern.subjectPattern();
-				if (subjPat !== void 0) collectCaptureNames(subjPat, out);
-				for (const assertionPat of pattern.pattern.assertionPatterns()) collectCaptureNames(assertionPat, out);
-				break;
-			}
-			case "Wrapped": {
-				const inner = pattern.pattern.innerPattern();
-				if (inner !== void 0) collectCaptureNames(inner, out);
-				break;
-			}
-			case "Digest":
-			case "Obscured":
-			case "Leaf": break;
+	/**
+	* Creates a Not meta pattern.
+	*/
+	function metaNot(pattern) {
+		return {
+			type: "Not",
+			pattern
+		};
+	}
+	/**
+	* Creates a Capture meta pattern.
+	*/
+	function metaCapture(pattern) {
+		return {
+			type: "Capture",
+			pattern
+		};
+	}
+	/**
+	* Creates a Search meta pattern.
+	*/
+	function metaSearch(pattern) {
+		return {
+			type: "Search",
+			pattern
+		};
+	}
+	/**
+	* Creates a Traverse meta pattern.
+	*/
+	function metaTraverse(pattern) {
+		return {
+			type: "Traverse",
+			pattern
+		};
+	}
+	/**
+	* Creates a Group meta pattern.
+	*/
+	function metaGroup(pattern) {
+		return {
+			type: "Group",
+			pattern
+		};
+	}
+	/**
+	* Gets paths with captures for a meta pattern.
+	*/
+	function metaPatternPathsWithCaptures(pattern, haystack) {
+		switch (pattern.type) {
+			case "Any": return pattern.pattern.pathsWithCaptures(haystack);
+			case "And": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Or": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Not": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Capture": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Search": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Traverse": return pattern.pattern.pathsWithCaptures(haystack);
+			case "Group": return pattern.pattern.pathsWithCaptures(haystack);
 		}
 	}
-	function collectMetaCaptureNames(pattern, out) {
+	/**
+	* Compiles a meta pattern to bytecode.
+	*/
+	function metaPatternCompile(pattern, code, literals, captures) {
 		switch (pattern.type) {
-			case "Any": break;
+			case "Any":
+				pattern.pattern.compile(code, literals, captures);
+				break;
 			case "And":
-				for (const p of pattern.pattern.patterns()) collectCaptureNames(p, out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
 			case "Or":
-				for (const p of pattern.pattern.patterns()) collectCaptureNames(p, out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
 			case "Not":
-				collectCaptureNames(pattern.pattern.pattern(), out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
-			case "Capture": {
-				const name = pattern.pattern.name();
-				if (!out.includes(name)) out.push(name);
-				collectCaptureNames(pattern.pattern.pattern(), out);
+			case "Capture":
+				pattern.pattern.compile(code, literals, captures);
 				break;
-			}
 			case "Search":
-				collectCaptureNames(pattern.pattern.pattern(), out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
 			case "Traverse":
-				for (const p of pattern.pattern.patterns()) collectCaptureNames(p, out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
 			case "Group":
-				collectCaptureNames(pattern.pattern.pattern(), out);
+				pattern.pattern.compile(code, literals, captures);
 				break;
 		}
 	}
 	/**
-	* Compile a pattern to bytecode.
+	* Checks if a meta pattern is complex.
 	*/
-	function compilePattern(pattern, code, literals, captureNames) {
+	function metaPatternIsComplex(pattern) {
 		switch (pattern.type) {
-			case "Leaf":
-			case "Structure":
-				literals.push(pattern);
-				code.push({
-					type: "MatchPredicate",
-					literalIndex: literals.length - 1
-				});
-				break;
-			case "Meta":
-				compileMetaPattern(pattern.pattern, code, literals, captureNames);
-				break;
+			case "Any": return pattern.pattern.isComplex();
+			case "And": return pattern.pattern.isComplex();
+			case "Or": return pattern.pattern.isComplex();
+			case "Not": return pattern.pattern.isComplex();
+			case "Capture": return pattern.pattern.isComplex();
+			case "Search": return pattern.pattern.isComplex();
+			case "Traverse": return pattern.pattern.isComplex();
+			case "Group": return pattern.pattern.isComplex();
 		}
 	}
-	function compileMetaPattern(pattern, code, literals, captureNames) {
+	/**
+	* Converts a meta pattern to string.
+	*/
+	function metaPatternToString(pattern) {
 		switch (pattern.type) {
-			case "Any": {
-				const anyPattern = {
-					type: "Meta",
-					pattern
-				};
-				literals.push(anyPattern);
-				code.push({
-					type: "MatchPredicate",
-					literalIndex: literals.length - 1
-				});
-				break;
-			}
-			case "And": {
-				const patterns = pattern.pattern.patterns();
-				for (const p of patterns) compilePattern(p, code, literals, captureNames);
+			case "Any": return pattern.pattern.toString();
+			case "And": return pattern.pattern.toString();
+			case "Or": return pattern.pattern.toString();
+			case "Not": return pattern.pattern.toString();
+			case "Capture": return pattern.pattern.toString();
+			case "Search": return pattern.pattern.toString();
+			case "Traverse": return pattern.pattern.toString();
+			case "Group": return pattern.pattern.toString();
+		}
+	}
+	/**
+	* Collects capture names from a meta pattern.
+	*/
+	function metaPatternCollectCaptureNames(pattern, out) {
+		switch (pattern.type) {
+			case "Any": break;
+			case "And":
+				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
 				break;
-			}
-			case "Or": {
-				const patterns = pattern.pattern.patterns();
-				if (patterns.length === 0) return;
-				if (patterns.length === 1) {
-					compilePattern(patterns[0], code, literals, captureNames);
-					return;
-				}
-				const jumpAddresses = [];
-				for (let i = 0; i < patterns.length - 1; i++) {
-					const splitAddr = code.length;
-					code.push({
-						type: "Split",
-						a: 0,
-						b: 0
-					});
-					const aStart = code.length;
-					compilePattern(patterns[i], code, literals, captureNames);
-					jumpAddresses.push(code.length);
-					code.push({
-						type: "Jump",
-						address: 0
-					});
-					const bStart = code.length;
-					code[splitAddr].a = aStart;
-					code[splitAddr].b = bStart;
-				}
-				compilePattern(patterns[patterns.length - 1], code, literals, captureNames);
-				const endAddr = code.length;
-				for (const jumpAddr of jumpAddresses) code[jumpAddr].address = endAddr;
+			case "Or":
+				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
 				break;
-			}
-			case "Not": {
-				const innerPattern = pattern.pattern.pattern();
-				literals.push(innerPattern);
-				code.push({
-					type: "NotMatch",
-					patternIndex: literals.length - 1
-				});
+			case "Not":
+				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
 				break;
-			}
 			case "Capture": {
 				const name = pattern.pattern.name();
-				const captureIndex = captureNames.indexOf(name);
-				code.push({
-					type: "CaptureStart",
-					captureIndex
-				});
-				compilePattern(pattern.pattern.pattern(), code, literals, captureNames);
-				code.push({
-					type: "CaptureEnd",
-					captureIndex
-				});
+				if (!out.includes(name)) out.push(name);
+				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
 				break;
 			}
-			case "Search": {
-				const innerCaptureNames = [];
-				collectCaptureNames(pattern.pattern.pattern(), innerCaptureNames);
-				const captureMap = innerCaptureNames.map((name) => {
-					const idx = captureNames.indexOf(name);
-					return [name, idx >= 0 ? idx : 0];
-				});
-				literals.push(pattern.pattern.pattern());
-				code.push({
-					type: "Search",
-					patternIndex: literals.length - 1,
-					captureMap
-				});
+			case "Search":
+				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
 				break;
-			}
-			case "Traverse": {
-				const patterns = pattern.pattern.patterns();
-				for (let i = 0; i < patterns.length; i++) {
-					const pat = patterns[i];
-					if (pat === void 0) continue;
-					compilePattern(pat, code, literals, captureNames);
-					if (i < patterns.length - 1) code.push({ type: "ExtendTraversal" });
-				}
-				if (patterns.length > 1) code.push({ type: "CombineTraversal" });
+			case "Traverse":
+				for (const pat of pattern.pattern.patterns()) collectCaptureNamesFromPattern(pat, out);
 				break;
-			}
-			case "Group": {
-				const quantifier = pattern.pattern.quantifier();
-				if (quantifier !== void 0) {
-					literals.push(pattern.pattern.pattern());
-					code.push({
-						type: "Repeat",
-						patternIndex: literals.length - 1,
-						quantifier
-					});
-				} else compilePattern(pattern.pattern.pattern(), code, literals, captureNames);
+			case "Group":
+				collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
 				break;
-			}
 		}
 	}
+	/**
+	* Helper to collect capture names from any Pattern.
+	*/
+	function collectCaptureNamesFromPattern(pattern, out) {
+		const p = pattern;
+		if (p.collectCaptureNames !== void 0) p.collectCaptureNames(out);
+	}
 
 //#endregion
 //#region src/pattern/dcbor-integration.ts
@@ -4988,9 +5073,38 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		};
 	}
 	/**
+	* Check if a pattern requires the VM for execution.
+	* Patterns containing Group (repeat), Traverse, or Search require compilation.
+	*/
+	function patternNeedsVM(pattern) {
+		switch (pattern.type) {
+			case "Leaf":
+			case "Structure": return false;
+			case "Meta": return metaPatternNeedsVM(pattern.pattern);
+		}
+	}
+	function metaPatternNeedsVM(pattern) {
+		switch (pattern.type) {
+			case "Any": return false;
+			case "And": return pattern.pattern.patterns().some(patternNeedsVM);
+			case "Or": return pattern.pattern.patterns().some(patternNeedsVM);
+			case "Not": return patternNeedsVM(pattern.pattern.pattern());
+			case "Capture": return patternNeedsVM(pattern.pattern.pattern());
+			case "Search":
+			case "Traverse": return true;
+			case "Group": {
+				const q = pattern.pattern.quantifier();
+				if (q.min() === 1 && q.max() === 1) return patternNeedsVM(pattern.pattern.pattern());
+				return true;
+			}
+		}
+	}
+	/**
 	* Gets paths with captures for a pattern.
+	* Routes through the VM for complex patterns that require compilation.
 	*/
 	function patternPathsWithCaptures(pattern, haystack) {
+		if (patternNeedsVM(pattern)) return patternPathsWithCapturesViaVM(pattern, haystack);
 		switch (pattern.type) {
 			case "Leaf": return leafPatternPathsWithCaptures(pattern.pattern, haystack);
 			case "Structure": return structurePatternPathsWithCaptures(pattern.pattern, haystack);
@@ -4998,6 +5112,23 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		}
 	}
 	/**
+	* Execute a pattern through the VM, merging results.
+	*/
+	function patternPathsWithCapturesViaVM(pattern, haystack) {
+		const results = run(compile(pattern), haystack);
+		const allPaths = [];
+		const mergedCaptures = /* @__PURE__ */ new Map();
+		for (const [path, captures] of results) {
+			allPaths.push(path);
+			for (const [name, paths] of captures) {
+				const existing = mergedCaptures.get(name) ?? [];
+				existing.push(...paths);
+				mergedCaptures.set(name, existing);
+			}
+		}
+		return [allPaths, mergedCaptures];
+	}
+	/**
 	* Gets paths for a pattern.
 	*/
 	function patternPaths(pattern, haystack) {
@@ -5118,6 +5249,24 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		return patternLeaf(leafDate(DatePattern.range(earliest, latest)));
 	}
 	/**
+	* Creates a new Pattern that matches Date values on or after the specified date.
+	*/
+	function dateEarliest(d) {
+		return patternLeaf(leafDate(DatePattern.earliest(d)));
+	}
+	/**
+	* Creates a new Pattern that matches Date values on or before the specified date.
+	*/
+	function dateLatest(d) {
+		return patternLeaf(leafDate(DatePattern.latest(d)));
+	}
+	/**
+	* Creates a new Pattern that matches Date values whose ISO-8601 string matches the regex.
+	*/
+	function dateRegex(pattern) {
+		return patternLeaf(leafDate(DatePattern.regex(pattern)));
+	}
+	/**
 	* Creates a new Pattern that matches any number value.
 	*/
 	function anyNumber() {
@@ -5404,6 +5553,11 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 		registerNodePatternFactory((p) => patternStructure(structureNode(p)));
 		registerObscuredPatternFactory((p) => patternStructure(structureObscured(p)));
 		registerWrappedPatternFactory((p) => patternStructure(structureWrapped(p)));
+		registerWrappedPatternDispatch({
+			pathsWithCaptures: patternPathsWithCaptures,
+			compile: patternCompile,
+			toString: patternToString
+		});
 		registerAnyPatternFactory((p) => patternMeta(metaAny(p)));
 		registerAndPatternFactory((p) => patternMeta(metaAnd(p)));
 		registerOrPatternFactory((p) => patternMeta(metaOr(p)));
@@ -5416,6 +5570,14 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	registerAllFactories();
 	registerVMPatternFunctions(patternPathsWithCaptures, patternMatches, patternPaths);
 	registerPatternMatchFn(patternMatches);
+	registerPatternDispatchFns({
+		pathsWithCaptures: patternPathsWithCaptures,
+		paths: patternPaths,
+		compile: patternCompile,
+		isComplex: patternIsComplex,
+		toString: patternToString
+	});
+	registerTraverseDispatchFunctions(patternPathsWithCaptures, patternCompile, patternIsComplex);
 
 //#endregion
 //#region src/parse/token.ts
@@ -6135,7 +6297,13 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 					token: keyword,
 					span: this.span()
 				};
-				return;
+				return {
+					token: {
+						type: "Identifier",
+						value: ident
+					},
+					span: this.span()
+				};
 			}
 			this.bump(1);
 		}
@@ -6405,7 +6573,8 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			case "BracketClose":
 			case "Comma":
 			case "Ellipsis":
-			case "Range": return err(unexpectedToken(token, span));
+			case "Range":
+			case "Identifier": return err(unexpectedToken(token, span));
 		}
 	}
 	/**
@@ -6544,6 +6713,48 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	* 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));
+			}
+		}
+		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))));
+			}
+			return err({
+				type: "InvalidDateFormat",
+				span
+			});
+		}
 		const parsed = Date.parse(content);
 		if (isNaN(parsed)) return err({
 			type: "InvalidDateFormat",
@@ -6561,10 +6772,40 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	}
 	/**
 	* Parse CBOR pattern.
+	*
+	* 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.
 	*/
 	function parseCbor(lexer) {
-		if (lexer.peekToken()?.token.type !== "ParenOpen") return ok(patternLeaf(leafTag(TaggedPattern.any())));
+		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({
@@ -6576,6 +6817,18 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 	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))));
+		}
 		const inner = parseOr(lexer);
 		if (!inner.ok) return inner;
 		if (lexer.next()?.token.type !== "ParenClose") return err({
@@ -6634,6 +6887,20 @@ var bctsEnvelopePattern = (function(exports, _bcts_dcbor_pattern, _bcts_known_va
 			});
 			return ok(digestPrefix(digestToken.token.value.value));
 		}
+		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 err(unexpectedToken(digestToken.token, digestToken.span));
 	}
 	function parseObject(lexer) {
@@ -6769,13 +7036,21 @@ exports.compileAsAtomic = compileAsAtomic;
 exports.compressed = compressed;
 exports.convertDcborPatternToEnvelopePattern = convertDcborPatternToEnvelopePattern;
 exports.date = date;
+exports.dateEarliest = dateEarliest;
+exports.dateLatest = dateLatest;
 exports.dateRange = dateRange;
+exports.dateRegex = dateRegex;
 exports.dcborPatternError = dcborPatternError;
 exports.defaultFormatPathsOpts = defaultFormatPathsOpts;
 exports.defaultPathElementFormat = defaultPathElementFormat;
 exports.digest = digest;
 exports.digestPrefix = digestPrefix;
 exports.digestURFormat = digestURFormat;
+exports.dispatchCompile = dispatchCompile;
+exports.dispatchIsComplex = dispatchIsComplex;
+exports.dispatchPaths = dispatchPaths;
+exports.dispatchPathsWithCaptures = dispatchPathsWithCaptures;
+exports.dispatchPatternToString = dispatchPatternToString;
 exports.elided = elided;
 exports.emptyInput = emptyInput;
 exports.encrypted = encrypted;
@@ -6884,6 +7159,7 @@ exports.registerNumberPatternFactory = registerNumberPatternFactory;
 exports.registerObjectPatternFactory = registerObjectPatternFactory;
 exports.registerObscuredPatternFactory = registerObscuredPatternFactory;
 exports.registerOrPatternFactory = registerOrPatternFactory;
+exports.registerPatternDispatchFns = registerPatternDispatchFns;
 exports.registerPatternMatchFn = registerPatternMatchFn;
 exports.registerPredicatePatternFactory = registerPredicatePatternFactory;
 exports.registerSearchPatternFactory = registerSearchPatternFactory;
@@ -6892,6 +7168,7 @@ exports.registerTaggedPatternFactory = registerTaggedPatternFactory;
 exports.registerTextPatternFactory = registerTextPatternFactory;
 exports.registerTraversePatternFactory = registerTraversePatternFactory;
 exports.registerVMPatternFunctions = registerVMPatternFunctions;
+exports.registerWrappedPatternDispatch = registerWrappedPatternDispatch;
 exports.registerWrappedPatternFactory = registerWrappedPatternFactory;
 exports.repeat = repeat;
 exports.run = run;
@@ -6930,5 +7207,5 @@ exports.unwrapMatching = unwrapMatching;
 exports.unwrapOr = unwrapOr;
 exports.wrapped = wrapped;
 return exports;
-})({}, bctsDcborPattern, bctsKnownValues, bctsEnvelope, bctsDcbor);
+})({}, bctsDcborPattern, bctsKnownValues, bctsEnvelope, bctsDcbor, bctsDcborParse);
 //# sourceMappingURL=index.iife.js.map