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

package/src/pattern/matcher.ts

@@ -88,14 +88,23 @@ export function compileAsAtomic(
 }
 
 // ============================================================================
-// Pattern Match Registry
+// Pattern Dispatch Registry
 // ============================================================================
 
 /**
- * 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: ((pattern: Pattern, haystack: Envelope) => boolean) | undefined;
+let patternPathsWithCapturesFn:
+  | ((pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>])
+  | undefined;
+let patternPathsFn: ((pattern: Pattern, haystack: Envelope) => Path[]) | undefined;
+let patternCompileFn:
+  | ((pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void)
+  | undefined;
+let patternIsComplexFn: ((pattern: Pattern) => boolean) | undefined;
+let patternToStringFn: ((pattern: Pattern) => string) | undefined;
 
 /**
  * Registers the pattern match function.
@@ -107,6 +116,24 @@ export function registerPatternMatchFn(
   patternMatchFn = fn;
 }
 
+/**
+ * Registers all pattern dispatch functions.
+ * Called from index.ts after all patterns are defined.
+ */
+export function registerPatternDispatchFns(fns: {
+  pathsWithCaptures: (pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>];
+  paths: (pattern: Pattern, haystack: Envelope) => Path[];
+  compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void;
+  isComplex: (pattern: Pattern) => boolean;
+  toString: (pattern: Pattern) => string;
+}): void {
+  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.
@@ -117,3 +144,61 @@ export function matchPattern(pattern: Pattern, haystack: Envelope): boolean {
   }
   return patternMatchFn(pattern, haystack);
 }
+
+/**
+ * Dispatch pathsWithCaptures on a Pattern.
+ */
+export function dispatchPathsWithCaptures(
+  pattern: Pattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  if (patternPathsWithCapturesFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternPathsWithCapturesFn(pattern, haystack);
+}
+
+/**
+ * Dispatch paths on a Pattern.
+ */
+export function dispatchPaths(pattern: Pattern, haystack: Envelope): Path[] {
+  if (patternPathsFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternPathsFn(pattern, haystack);
+}
+
+/**
+ * Dispatch compile on a Pattern.
+ */
+export function dispatchCompile(
+  pattern: Pattern,
+  code: Instr[],
+  literals: Pattern[],
+  captures: string[],
+): void {
+  if (patternCompileFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  patternCompileFn(pattern, code, literals, captures);
+}
+
+/**
+ * Dispatch isComplex on a Pattern.
+ */
+export function dispatchIsComplex(pattern: Pattern): boolean {
+  if (patternIsComplexFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternIsComplexFn(pattern);
+}
+
+/**
+ * Dispatch toString on a Pattern.
+ */
+export function dispatchPatternToString(pattern: Pattern): string {
+  if (patternToStringFn === undefined) {
+    throw new Error("Pattern dispatch functions not registered");
+  }
+  return patternToStringFn(pattern);
+}

package/src/pattern/meta/and-pattern.ts

@@ -8,9 +8,15 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import {
+  matchPattern,
+  dispatchCompile,
+  dispatchIsComplex,
+  dispatchPatternToString,
+} from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaAndPattern: ((pattern: AndPattern) => Pattern) | undefined;
@@ -63,23 +69,18 @@ export class AndPattern implements Matcher {
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Each pattern must match at this position
     for (const pattern of this._patterns) {
-      const matcher = pattern as unknown as Matcher;
-      matcher.compile(code, literals, captures);
+      dispatchCompile(pattern, code, literals, captures);
     }
   }
 
   isComplex(): boolean {
     // The pattern is complex if it contains more than one pattern, or if
     // the one pattern is complex itself.
-    return (
-      this._patterns.length > 1 || this._patterns.some((p) => (p as unknown as Matcher).isComplex())
-    );
+    return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
   }
 
   toString(): string {
-    return this._patterns
-      .map((p) => (p as unknown as { toString(): string }).toString())
-      .join(" & ");
+    return this._patterns.map((p) => dispatchPatternToString(p)).join(" & ");
   }
 
   /**

package/src/pattern/meta/capture-pattern.ts

@@ -8,9 +8,10 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { dispatchPathsWithCaptures, dispatchCompile, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaCapturePattern: ((pattern: CapturePattern) => Pattern) | undefined;
@@ -55,8 +56,7 @@ export class CapturePattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const matcher = this._pattern as unknown as Matcher;
-    const [paths, caps] = matcher.pathsWithCaptures(haystack);
+    const [paths, caps] = dispatchPathsWithCaptures(this._pattern, haystack);
 
     if (paths.length > 0) {
       const existing = caps.get(this._name) ?? [];
@@ -78,8 +78,7 @@ export class CapturePattern implements Matcher {
     const id = captures.length;
     captures.push(this._name);
     code.push({ type: "CaptureStart", captureIndex: id });
-    const matcher = this._pattern as unknown as Matcher;
-    matcher.compile(code, literals, captures);
+    dispatchCompile(this._pattern, code, literals, captures);
     code.push({ type: "CaptureEnd", captureIndex: id });
   }
 
@@ -88,7 +87,7 @@ export class CapturePattern implements Matcher {
   }
 
   toString(): string {
-    return `@${this._name}(${(this._pattern as unknown as { toString(): string }).toString()})`;
+    return `@${this._name}(${dispatchPatternToString(this._pattern)})`;
   }
 
   /**

package/src/pattern/meta/group-pattern.ts

@@ -9,9 +9,10 @@
 import type { Envelope } from "@bcts/envelope";
 import { Quantifier } from "@bcts/dcbor-pattern";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, dispatchPathsWithCaptures, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaGroupPattern: ((pattern: GroupPattern) => Pattern) | undefined;
@@ -62,7 +63,11 @@ export class GroupPattern implements Matcher {
     return this._quantifier;
   }
 
-  pathsWithCaptures(_haystack: Envelope): [Path[], Map<string, Path[]>] {
+  pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
+    // For simple grouping (exactly 1), delegate to the inner pattern
+    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",
     );
@@ -73,9 +78,7 @@ export class GroupPattern implements Matcher {
   }
 
   matches(haystack: Envelope): boolean {
-    // GroupPattern needs VM execution
-    const matcher = this._pattern as unknown as Matcher;
-    return matcher.matches(haystack);
+    return matchPattern(this._pattern, haystack);
   }
 
   compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
@@ -90,7 +93,7 @@ export class GroupPattern implements Matcher {
 
   toString(): string {
     const formattedRange = this._quantifier.toString();
-    return `(${(this._pattern as unknown as { toString(): string }).toString()})${formattedRange}`;
+    return `(${dispatchPatternToString(this._pattern)})${formattedRange}`;
   }
 
   /**

package/src/pattern/meta/not-pattern.ts

@@ -8,9 +8,10 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import { matchPattern, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaNotPattern: ((pattern: NotPattern) => Pattern) | undefined;
@@ -71,7 +72,7 @@ export class NotPattern implements Matcher {
   }
 
   toString(): string {
-    return `!${(this._pattern as unknown as { toString(): string }).toString()}`;
+    return `!${dispatchPatternToString(this._pattern)}`;
   }
 
   /**

package/src/pattern/meta/or-pattern.ts

@@ -8,9 +8,15 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { type Matcher, matchPattern } from "../matcher";
+import {
+  dispatchPathsWithCaptures,
+  dispatchCompile,
+  dispatchIsComplex,
+  dispatchPatternToString,
+} from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaOrPattern: ((pattern: OrPattern) => Pattern) | undefined;
@@ -46,10 +52,14 @@ export class OrPattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const anyMatch = this._patterns.some((pattern) => matchPattern(pattern, haystack));
-
-    const paths = anyMatch ? [[haystack]] : [];
-    return [paths, new Map<string, Path[]>()];
+    // Try each pattern and return paths+captures from the first match
+    for (const pattern of this._patterns) {
+      const [paths, captures] = dispatchPathsWithCaptures(pattern, haystack);
+      if (paths.length > 0) {
+        return [paths, captures];
+      }
+    }
+    return [[], new Map<string, Path[]>()];
   }
 
   paths(haystack: Envelope): Path[] {
@@ -83,8 +93,7 @@ export class OrPattern implements Matcher {
 
       // Compile this pattern
       const pattern = this._patterns[i];
-      const matcher = pattern as unknown as Matcher;
-      matcher.compile(code, literals, captures);
+      dispatchCompile(pattern, code, literals, captures);
 
       // This pattern will jump to the end if it matches
       const jumpPastAll = code.length;
@@ -108,15 +117,11 @@ export class OrPattern implements Matcher {
   isComplex(): boolean {
     // The pattern is complex if it contains more than one pattern, or if
     // the one pattern is complex itself.
-    return (
-      this._patterns.length > 1 || this._patterns.some((p) => (p as unknown as Matcher).isComplex())
-    );
+    return this._patterns.length > 1 || this._patterns.some((p) => dispatchIsComplex(p));
   }
 
   toString(): string {
-    return this._patterns
-      .map((p) => (p as unknown as { toString(): string }).toString())
-      .join(" | ");
+    return this._patterns.map((p) => dispatchPatternToString(p)).join(" | ");
   }
 
   /**

package/src/pattern/meta/search-pattern.ts

@@ -8,9 +8,10 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { dispatchPaths, dispatchPatternToString } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
+import type { Matcher } from "../matcher";
 
 // Forward declaration for Pattern factory (used for late binding)
 export let createMetaSearchPattern: ((pattern: SearchPattern) => Pattern) | undefined;
@@ -47,7 +48,6 @@ export class SearchPattern implements Matcher {
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     const resultPaths: Path[] = [];
-    const matcher = this._pattern as unknown as Matcher;
 
     // Walk the envelope tree
     this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
@@ -55,7 +55,7 @@ export class SearchPattern implements Matcher {
       const newPath: Envelope[] = [...pathToCurrent, currentEnvelope];
 
       // Test the pattern against this node
-      const patternPaths = matcher.paths(currentEnvelope);
+      const patternPaths = dispatchPaths(this._pattern, currentEnvelope);
 
       // If the pattern matches, emit the full paths
       for (const patternPath of patternPaths) {
@@ -170,7 +170,7 @@ export class SearchPattern implements Matcher {
   }
 
   toString(): string {
-    return `search(${(this._pattern as unknown as { toString(): string }).toString()})`;
+    return `search(${dispatchPatternToString(this._pattern)})`;
   }
 
   /**

package/src/pattern/meta/traverse-pattern.ts

@@ -21,6 +21,25 @@ export function registerTraversePatternFactory(
   createMetaTraversePattern = factory;
 }
 
+// Late-binding dispatch functions to avoid circular dependency with Pattern
+let _patternPathsWithCaptures:
+  | ((pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>])
+  | undefined;
+let _patternCompile:
+  | ((pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void)
+  | undefined;
+let _patternIsComplex: ((pattern: Pattern) => boolean) | undefined;
+
+export function registerTraverseDispatchFunctions(
+  pathsWithCaptures: (pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>],
+  compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void,
+  isComplex: (pattern: Pattern) => boolean,
+): void {
+  _patternPathsWithCaptures = pathsWithCaptures;
+  _patternCompile = compile;
+  _patternIsComplex = isComplex;
+}
+
 /**
  * A pattern that matches a traversal order of patterns.
  *
@@ -61,8 +80,10 @@ export class TraversePattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const firstMatcher = this._first as unknown as Matcher;
-    const headPaths = firstMatcher.paths(haystack);
+    if (_patternPathsWithCaptures === undefined) {
+      throw new Error("TraversePattern dispatch functions not registered");
+    }
+    const headPaths = _patternPathsWithCaptures(this._first, haystack)[0];
 
     // If there's no further traversal, return head paths
     if (this._rest === undefined) {
@@ -94,9 +115,11 @@ export class TraversePattern implements Matcher {
   }
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
+    if (_patternCompile === undefined) {
+      throw new Error("TraversePattern dispatch functions not registered");
+    }
     // Compile the first pattern
-    const firstMatcher = this._first as unknown as Matcher;
-    firstMatcher.compile(code, literals, captures);
+    _patternCompile(this._first, code, literals, captures);
 
     if (this._rest !== undefined) {
       // Save the current path and switch to last envelope
@@ -109,9 +132,10 @@ export class TraversePattern implements Matcher {
   }
 
   isComplex(): boolean {
-    // A traversal is complex if `first` is complex, or it has more than one pattern
-    const firstMatcher = this._first as unknown as Matcher;
-    return firstMatcher.isComplex() || this._rest !== undefined;
+    if (_patternIsComplex === undefined) {
+      throw new Error("TraversePattern dispatch functions not registered");
+    }
+    return _patternIsComplex(this._first) || this._rest !== undefined;
   }
 
   toString(): string {

package/src/pattern/structure/assertions-pattern.ts

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -123,8 +123,7 @@ export class AssertionsPattern implements Matcher {
         case "WithPredicate": {
           const predicate = assertion.asPredicate?.();
           if (predicate !== undefined) {
-            const innerMatcher = this._pattern.pattern as unknown as Matcher;
-            if (innerMatcher.matches(predicate)) {
+            if (matchPattern(this._pattern.pattern, predicate)) {
               paths.push([assertion]);
             }
           }
@@ -133,8 +132,7 @@ export class AssertionsPattern implements Matcher {
         case "WithObject": {
           const object = assertion.asObject?.();
           if (object !== undefined) {
-            const innerMatcher = this._pattern.pattern as unknown as Matcher;
-            if (innerMatcher.matches(object)) {
+            if (matchPattern(this._pattern.pattern, object)) {
               paths.push([assertion]);
             }
           }
@@ -144,9 +142,10 @@ export class AssertionsPattern implements Matcher {
           const predicate = assertion.asPredicate?.();
           const object = assertion.asObject?.();
           if (predicate !== undefined && object !== undefined) {
-            const predMatcher = this._pattern.predicatePattern as unknown as Matcher;
-            const objMatcher = this._pattern.objectPattern as unknown as Matcher;
-            if (predMatcher.matches(predicate) && objMatcher.matches(object)) {
+            if (
+              matchPattern(this._pattern.predicatePattern, predicate) &&
+              matchPattern(this._pattern.objectPattern, object)
+            ) {
               paths.push([assertion]);
             }
           }

package/src/pattern/structure/index.ts

@@ -51,6 +51,7 @@ export {
   WrappedPattern,
   type WrappedPatternType,
   registerWrappedPatternFactory,
+  registerWrappedPatternDispatch,
 } from "./wrapped-pattern";
 
 // Import concrete types for use in StructurePattern

package/src/pattern/structure/object-pattern.ts

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -82,8 +82,7 @@ export class ObjectPattern implements Matcher {
         paths = [[object]];
         break;
       case "Pattern": {
-        const innerMatcher = this._pattern.pattern as unknown as Matcher;
-        if (innerMatcher.matches(object)) {
+        if (matchPattern(this._pattern.pattern, object)) {
           paths = [[object]];
         } else {
           paths = [];

package/src/pattern/structure/predicate-pattern.ts

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -84,8 +84,7 @@ export class PredicatePattern implements Matcher {
         paths = [[predicate]];
         break;
       case "Pattern": {
-        const innerMatcher = this._pattern.pattern as unknown as Matcher;
-        if (innerMatcher.matches(predicate)) {
+        if (matchPattern(this._pattern.pattern, predicate)) {
           paths = [[predicate]];
         } else {
           paths = [];

package/src/pattern/structure/subject-pattern.ts

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { matchPattern, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -77,8 +77,7 @@ export class SubjectPattern implements Matcher {
         paths = [[subject]];
         break;
       case "Pattern": {
-        const innerMatcher = this._pattern.pattern as unknown as Matcher;
-        if (innerMatcher.matches(subject)) {
+        if (matchPattern(this._pattern.pattern, subject)) {
           paths = [[subject]];
         } else {
           paths = [];

package/src/pattern/structure/wrapped-pattern.ts

@@ -15,10 +15,29 @@ import type { Pattern } from "../index";
 // Forward declaration for Pattern factory
 let createStructureWrappedPattern: ((pattern: WrappedPattern) => Pattern) | undefined;
 
+// Forward declaration for pattern dispatch (avoids circular imports)
+let dispatchPatternPathsWithCaptures:
+  | ((pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>])
+  | undefined;
+let dispatchPatternCompile:
+  | ((pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void)
+  | undefined;
+let dispatchPatternToString: ((pattern: Pattern) => string) | undefined;
+
 export function registerWrappedPatternFactory(factory: (pattern: WrappedPattern) => Pattern): void {
   createStructureWrappedPattern = factory;
 }
 
+export function registerWrappedPatternDispatch(dispatch: {
+  pathsWithCaptures: (pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>];
+  compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void;
+  toString: (pattern: Pattern) => string;
+}): void {
+  dispatchPatternPathsWithCaptures = dispatch.pathsWithCaptures;
+  dispatchPatternCompile = dispatch.compile;
+  dispatchPatternToString = dispatch.toString;
+}
+
 /**
  * Pattern type for wrapped pattern matching.
  *
@@ -96,9 +115,8 @@ export class WrappedPattern implements Matcher {
       case "Unwrap": {
         // Match the content of the wrapped envelope
         const unwrapped = subject.tryUnwrap?.();
-        if (unwrapped !== undefined) {
-          const innerMatcher = this._pattern.pattern as unknown as Matcher;
-          const innerPaths = innerMatcher.paths(unwrapped);
+        if (unwrapped !== undefined && dispatchPatternPathsWithCaptures !== undefined) {
+          const [innerPaths] = dispatchPatternPathsWithCaptures(this._pattern.pattern, unwrapped);
           paths = innerPaths.map((path) => {
             // Add the current envelope to the path
             return [haystack, ...path];
@@ -145,8 +163,9 @@ export class WrappedPattern implements Matcher {
         code.push({ type: "PushAxis", axis });
 
         // Then match the pattern
-        const innerMatcher = this._pattern.pattern as unknown as Matcher;
-        innerMatcher.compile(code, literals, captures);
+        if (dispatchPatternCompile !== undefined) {
+          dispatchPatternCompile(this._pattern.pattern, code, literals, captures);
+        }
         break;
       }
     }
@@ -161,8 +180,10 @@ export class WrappedPattern implements Matcher {
       case "Any":
         return "wrapped";
       case "Unwrap": {
-        // Check if it's the "any" pattern by string comparison
-        const patternStr = (this._pattern.pattern as unknown as { toString(): string }).toString();
+        const patternStr =
+          dispatchPatternToString !== undefined
+            ? dispatchPatternToString(this._pattern.pattern)
+            : "*";
         if (patternStr === "*") {
           return "unwrap";
         }

package/src/pattern/vm.ts

@@ -987,24 +987,25 @@ function compileMetaPattern(
       break;
     }
     case "Traverse": {
+      // Matches Rust's recursive compilation: each ExtendTraversal gets a
+      // matching CombineTraversal so saved paths are properly restored.
       const patterns = pattern.pattern.patterns();
-      for (let i = 0; i < patterns.length; i++) {
-        const pat = patterns[i];
-        if (pat === undefined) continue;
-        compilePattern(pat, code, literals, captureNames);
-        if (i < patterns.length - 1) {
+      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);
+        }
+        for (let i = 1; i < patterns.length; i++) {
+          code.push({ type: "CombineTraversal" });
         }
-      }
-      if (patterns.length > 1) {
-        code.push({ type: "CombineTraversal" });
       }
       break;
     }
     case "Group": {
       const quantifier = pattern.pattern.quantifier();
-      if (quantifier !== undefined) {
-        // Repeat pattern
+      if (quantifier !== undefined && !(quantifier.min() === 1 && quantifier.max() === 1)) {
+        // Repeat pattern (skip for exactly-1 which is simple pass-through)
         literals.push(pattern.pattern.pattern());
         code.push({
           type: "Repeat",
@@ -1012,7 +1013,7 @@ function compileMetaPattern(
           quantifier,
         });
       } else {
-        // Simple grouping
+        // Simple grouping (including exactly-1 quantifier)
         compilePattern(pattern.pattern.pattern(), code, literals, captureNames);
       }
       break;