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

package/dist/index.cjs

@@ -2,6 +2,7 @@ let _bcts_dcbor_pattern = require("@bcts/dcbor-pattern");
 let _bcts_known_values = require("@bcts/known-values");
 let _bcts_envelope = require("@bcts/envelope");
 let _bcts_dcbor = require("@bcts/dcbor");
+let _bcts_dcbor_parse = require("@bcts/dcbor-parse");
 
 //#region src/error.ts
 /**
@@ -314,9 +315,17 @@ function envelopeSummary(env) {
 	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;
@@ -324,7 +333,7 @@ function envelopeSummary(env) {
 			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";
@@ -498,10 +507,15 @@ function compileAsAtomic(pat, code, literals, _captures) {
 	});
 }
 /**
-* 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.
@@ -510,6 +524,17 @@ function registerPatternMatchFn(fn) {
 	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.
 */
@@ -517,6 +542,41 @@ function matchPattern(pattern, haystack) {
 	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
@@ -562,7 +622,7 @@ var BoolPattern = class BoolPattern {
 		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()];
 		}
@@ -635,7 +695,7 @@ var NullPattern = class NullPattern {
 		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()];
 		}
@@ -763,7 +823,7 @@ var NumberPattern = class NumberPattern {
 		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()];
 		}
@@ -894,7 +954,7 @@ var TextPattern = class TextPattern {
 		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()];
 		}
@@ -999,7 +1059,7 @@ var ByteStringPattern = class ByteStringPattern {
 		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()];
 		}
@@ -1135,7 +1195,7 @@ var DatePattern = class DatePattern {
 		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()];
 		}
@@ -1247,7 +1307,7 @@ var ArrayPattern = class ArrayPattern {
 		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()];
@@ -1391,7 +1451,7 @@ var MapPattern = class MapPattern {
 		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()];
@@ -1500,12 +1560,13 @@ var KnownValuePattern = class KnownValuePattern {
 		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()];
 		}
@@ -1817,7 +1878,7 @@ var CBORPattern = class CBORPattern {
 		} 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) {
@@ -1842,7 +1903,7 @@ var CBORPattern = class CBORPattern {
 				}
 			}
 		}
-		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()];
@@ -2029,7 +2090,7 @@ function leafKnownValue(pattern) {
 */
 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);
@@ -2229,7 +2290,7 @@ var SubjectPattern = class SubjectPattern {
 				paths = [[subject]];
 				break;
 			case "Pattern":
-				if (this._pattern.pattern.matches(subject)) paths = [[subject]];
+				if (matchPattern(this._pattern.pattern, subject)) paths = [[subject]];
 				else paths = [];
 				break;
 		}
@@ -2331,7 +2392,7 @@ var PredicatePattern = class PredicatePattern {
 				paths = [[predicate]];
 				break;
 			case "Pattern":
-				if (this._pattern.pattern.matches(predicate)) paths = [[predicate]];
+				if (matchPattern(this._pattern.pattern, predicate)) paths = [[predicate]];
 				else paths = [];
 				break;
 		}
@@ -2429,7 +2490,7 @@ var ObjectPattern = class ObjectPattern {
 				paths = [[object]];
 				break;
 			case "Pattern":
-				if (this._pattern.pattern.matches(object)) paths = [[object]];
+				if (matchPattern(this._pattern.pattern, object)) paths = [[object]];
 				else paths = [];
 				break;
 		}
@@ -2557,14 +2618,14 @@ var AssertionsPattern = class AssertionsPattern {
 			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;
 			}
@@ -2572,9 +2633,7 @@ var AssertionsPattern = class AssertionsPattern {
 				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;
 			}
@@ -3026,9 +3085,17 @@ var ObscuredPattern = class ObscuredPattern {
 //#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.
 *
@@ -3084,10 +3151,12 @@ var WrappedPattern = class WrappedPattern {
 				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;
 			}
 		}
@@ -3122,7 +3191,7 @@ var WrappedPattern = class WrappedPattern {
 					type: "PushAxis",
 					axis: "Wrapped"
 				});
-				this._pattern.pattern.compile(code, literals, captures);
+				if (dispatchPatternCompile !== void 0) dispatchPatternCompile(this._pattern.pattern, code, literals, captures);
 				break;
 			}
 		}
@@ -3134,7 +3203,7 @@ var WrappedPattern = class WrappedPattern {
 		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})`;
 			}
@@ -3329,1503 +3398,1520 @@ function structurePatternToString(pattern) {
 }
 
 //#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
@@ -4990,9 +5076,38 @@ function patternMeta(meta) {
 	};
 }
 /**
+* 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);
@@ -5000,6 +5115,23 @@ function patternPathsWithCaptures(pattern, haystack) {
 	}
 }
 /**
+* 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) {
@@ -5120,6 +5252,24 @@ function dateRange(earliest, latest) {
 	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() {
@@ -5406,6 +5556,11 @@ function registerAllFactories() {
 	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)));
@@ -5418,6 +5573,14 @@ function registerAllFactories() {
 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
@@ -6137,7 +6300,13 @@ var Lexer = class {
 				token: keyword,
 				span: this.span()
 			};
-			return;
+			return {
+				token: {
+					type: "Identifier",
+					value: ident
+				},
+				span: this.span()
+			};
 		}
 		this.bump(1);
 	}
@@ -6407,7 +6576,8 @@ function parsePrimary(lexer) {
 		case "BracketClose":
 		case "Comma":
 		case "Ellipsis":
-		case "Range": return err(unexpectedToken(token, span));
+		case "Range":
+		case "Identifier": return err(unexpectedToken(token, span));
 	}
 }
 /**
@@ -6546,6 +6716,48 @@ function parseTag(lexer) {
 * 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",
@@ -6563,10 +6775,40 @@ function parseKnownValueContent(content) {
 }
 /**
 * 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({
@@ -6578,6 +6820,18 @@ function parseCbor(lexer) {
 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({
@@ -6636,6 +6890,20 @@ function parseDigest(lexer) {
 		});
 		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) {
@@ -6771,13 +7039,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;
@@ -6886,6 +7162,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;
@@ -6894,6 +7171,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;