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

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";
 
@@ -34,10 +34,10 @@ export type ObjectPatternType =
  * Corresponds to the Rust `ObjectPattern` enum in object_pattern.rs
  */
 export class ObjectPattern implements Matcher {
-  readonly #pattern: ObjectPatternType;
+  private readonly _pattern: ObjectPatternType;
 
   private constructor(pattern: ObjectPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -58,14 +58,14 @@ export class ObjectPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): ObjectPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the inner pattern if this is a Pattern type, undefined otherwise.
    */
   innerPattern(): Pattern | undefined {
-    return this.#pattern.type === "Pattern" ? this.#pattern.pattern : undefined;
+    return this._pattern.type === "Pattern" ? this._pattern.pattern : undefined;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -77,13 +77,12 @@ export class ObjectPattern implements Matcher {
 
     let paths: Path[];
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         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 = [];
@@ -117,11 +116,11 @@ export class ObjectPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "obj";
       case "Pattern":
-        return `obj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `obj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -129,14 +128,14 @@ export class ObjectPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: ObjectPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    if (this.#pattern.type === "Any") {
+    if (this._pattern.type === "Any") {
       return true;
     }
-    const thisPattern = (this.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
-    const otherPattern = (other.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const thisPattern = (this._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const otherPattern = (other._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
     return thisPattern === otherPattern;
   }
 
@@ -144,6 +143,6 @@ export class ObjectPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#pattern.type === "Any" ? 0 : 1;
+    return this._pattern.type === "Any" ? 0 : 1;
   }
 }

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

@@ -39,10 +39,10 @@ export type ObscuredPatternType =
  * Corresponds to the Rust `ObscuredPattern` enum in obscured_pattern.rs
  */
 export class ObscuredPattern implements Matcher {
-  readonly #pattern: ObscuredPatternType;
+  private readonly _pattern: ObscuredPatternType;
 
   private constructor(pattern: ObscuredPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -77,13 +77,13 @@ export class ObscuredPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): ObscuredPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     let isHit = false;
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         isHit = haystack.isObscured();
         break;
@@ -122,7 +122,7 @@ export class ObscuredPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "obscured";
       case "Elided":
@@ -138,14 +138,14 @@ export class ObscuredPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: ObscuredPattern): boolean {
-    return this.#pattern.type === other.#pattern.type;
+    return this._pattern.type === other._pattern.type;
   }
 
   /**
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Elided":

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";
 
@@ -36,10 +36,10 @@ export type PredicatePatternType =
  * Corresponds to the Rust `PredicatePattern` enum in predicate_pattern.rs
  */
 export class PredicatePattern implements Matcher {
-  readonly #pattern: PredicatePatternType;
+  private readonly _pattern: PredicatePatternType;
 
   private constructor(pattern: PredicatePatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -60,14 +60,14 @@ export class PredicatePattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): PredicatePatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the inner pattern if this is a Pattern type, undefined otherwise.
    */
   innerPattern(): Pattern | undefined {
-    return this.#pattern.type === "Pattern" ? this.#pattern.pattern : undefined;
+    return this._pattern.type === "Pattern" ? this._pattern.pattern : undefined;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -79,13 +79,12 @@ export class PredicatePattern implements Matcher {
 
     let paths: Path[];
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         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 = [];
@@ -119,11 +118,11 @@ export class PredicatePattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "pred";
       case "Pattern":
-        return `pred(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `pred(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -131,14 +130,14 @@ export class PredicatePattern implements Matcher {
    * Equality comparison.
    */
   equals(other: PredicatePattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    if (this.#pattern.type === "Any") {
+    if (this._pattern.type === "Any") {
       return true;
     }
-    const thisPattern = (this.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
-    const otherPattern = (other.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const thisPattern = (this._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const otherPattern = (other._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
     return thisPattern === otherPattern;
   }
 
@@ -146,6 +145,6 @@ export class PredicatePattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#pattern.type === "Any" ? 0 : 1;
+    return this._pattern.type === "Any" ? 0 : 1;
   }
 }

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";
 
@@ -34,10 +34,10 @@ export type SubjectPatternType =
  * Corresponds to the Rust `SubjectPattern` enum in subject_pattern.rs
  */
 export class SubjectPattern implements Matcher {
-  readonly #pattern: SubjectPatternType;
+  private readonly _pattern: SubjectPatternType;
 
   private constructor(pattern: SubjectPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -58,27 +58,26 @@ export class SubjectPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): SubjectPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the inner pattern if this is a Pattern type, undefined otherwise.
    */
   innerPattern(): Pattern | undefined {
-    return this.#pattern.type === "Pattern" ? this.#pattern.pattern : undefined;
+    return this._pattern.type === "Pattern" ? this._pattern.pattern : undefined;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     const subject = haystack.subject();
     let paths: Path[];
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         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 = [];
@@ -99,7 +98,7 @@ export class SubjectPattern implements Matcher {
   }
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         code.push({ type: "NavigateSubject" });
         break;
@@ -108,7 +107,7 @@ export class SubjectPattern implements Matcher {
         code.push({ type: "NavigateSubject" });
         // Save the path and run the inner pattern relative to the subject
         code.push({ type: "ExtendTraversal" });
-        (this.#pattern.pattern as unknown as Matcher).compile(code, literals, captures);
+        (this._pattern.pattern as unknown as Matcher).compile(code, literals, captures);
         code.push({ type: "CombineTraversal" });
         break;
     }
@@ -119,11 +118,11 @@ export class SubjectPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "subj";
       case "Pattern":
-        return `subj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `subj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -131,15 +130,15 @@ export class SubjectPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: SubjectPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    if (this.#pattern.type === "Any") {
+    if (this._pattern.type === "Any") {
       return true;
     }
     // For Pattern type, compare the inner patterns
-    const thisPattern = (this.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
-    const otherPattern = (other.#pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const thisPattern = (this._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
+    const otherPattern = (other._pattern as { type: "Pattern"; pattern: Pattern }).pattern;
     return thisPattern === otherPattern; // Reference equality for now
   }
 
@@ -147,6 +146,6 @@ export class SubjectPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#pattern.type === "Any" ? 0 : 1;
+    return this._pattern.type === "Any" ? 0 : 1;
   }
 }

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.
  *
@@ -34,10 +53,10 @@ export type WrappedPatternType =
  * Corresponds to the Rust `WrappedPattern` enum in wrapped_pattern.rs
  */
 export class WrappedPattern implements Matcher {
-  readonly #pattern: WrappedPatternType;
+  private readonly _pattern: WrappedPatternType;
 
   private constructor(pattern: WrappedPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -69,14 +88,14 @@ export class WrappedPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): WrappedPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the inner pattern if this is an Unwrap type, undefined otherwise.
    */
   innerPattern(): Pattern | undefined {
-    return this.#pattern.type === "Unwrap" ? this.#pattern.pattern : undefined;
+    return this._pattern.type === "Unwrap" ? this._pattern.pattern : undefined;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -88,7 +107,7 @@ export class WrappedPattern implements Matcher {
 
     let paths: Path[];
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         // Just match the wrapped envelope itself, don't descend
         paths = [[haystack]];
@@ -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];
@@ -126,7 +144,7 @@ export class WrappedPattern implements Matcher {
       throw new Error("WrappedPattern factory not registered");
     }
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any": {
         // Just match the wrapped envelope itself, don't descend
         const idx = literals.length;
@@ -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;
       }
     }
@@ -157,12 +176,14 @@ export class WrappedPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       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";
         }
@@ -175,14 +196,14 @@ export class WrappedPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: WrappedPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    if (this.#pattern.type === "Any") {
+    if (this._pattern.type === "Any") {
       return true;
     }
-    const thisPattern = (this.#pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
-    const otherPattern = (other.#pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
+    const thisPattern = (this._pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
+    const otherPattern = (other._pattern as { type: "Unwrap"; pattern: Pattern }).pattern;
     return thisPattern === otherPattern;
   }
 
@@ -190,6 +211,6 @@ export class WrappedPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    return this.#pattern.type === "Any" ? 0 : 1;
+    return this._pattern.type === "Any" ? 0 : 1;
   }
 }

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;