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

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

@@ -12,7 +12,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import { matchPattern, type Matcher } from "../matcher";
+import { dispatchPatternToString, matchPattern, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -126,7 +126,7 @@ export class PredicatePattern implements Matcher {
       case "Any":
         return "pred";
       case "Pattern":
-        return `pred(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `pred(${dispatchPatternToString(this._pattern.pattern)})`;
     }
   }
 

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

@@ -19,10 +19,28 @@ import type { Pattern } from "../index";
 // Forward declaration for Pattern factory (used for late binding)
 export let createStructureSubjectPattern: ((pattern: SubjectPattern) => Pattern) | undefined;
 
+// Forward declaration for top-level pattern compile/toString dispatch.
+// Mirrors Rust `pat.compile(code, lits, caps)` on the top-level `Pattern`
+// enum — the TS port can't call methods on the tagged-union value, so we
+// register the compile dispatcher (which lives in `pattern/index.ts`)
+// during module initialisation.
+let dispatchPatternCompile:
+  | ((pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void)
+  | undefined;
+let dispatchPatternToString: ((pattern: Pattern) => string) | undefined;
+
 export function registerSubjectPatternFactory(factory: (pattern: SubjectPattern) => Pattern): void {
   createStructureSubjectPattern = factory;
 }
 
+export function registerSubjectPatternDispatch(dispatch: {
+  compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void;
+  toString: (pattern: Pattern) => string;
+}): void {
+  dispatchPatternCompile = dispatch.compile;
+  dispatchPatternToString = dispatch.toString;
+}
+
 /**
  * Pattern type for subject pattern matching.
  *
@@ -106,14 +124,20 @@ export class SubjectPattern implements Matcher {
       case "Any":
         code.push({ type: "NavigateSubject" });
         break;
-      case "Pattern":
+      case "Pattern": {
+        if (dispatchPatternCompile === undefined) {
+          throw new Error(
+            "SubjectPattern.compile requires the top-level Pattern compile dispatch; not registered",
+          );
+        }
         // Navigate to the subject first
         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);
+        dispatchPatternCompile(this._pattern.pattern, code, literals, captures);
         code.push({ type: "CombineTraversal" });
         break;
+      }
     }
   }
 
@@ -125,8 +149,11 @@ export class SubjectPattern implements Matcher {
     switch (this._pattern.type) {
       case "Any":
         return "subj";
-      case "Pattern":
-        return `subj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
+      case "Pattern": {
+        const fmt = dispatchPatternToString;
+        const inner = fmt !== undefined ? fmt(this._pattern.pattern) : "?";
+        return `subj(${inner})`;
+      }
     }
   }
 

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

@@ -19,6 +19,12 @@ import type { Pattern } from "../index";
 // Forward declaration for Pattern factory
 let createStructureWrappedPattern: ((pattern: WrappedPattern) => Pattern) | undefined;
 
+// Forward declaration for `Pattern::any()` so that
+// `WrappedPattern.unwrap()` can mirror Rust's
+// `Self::unwrap_matching(Pattern::any())` factory exactly. Resolved during
+// pattern-module registration to avoid the circular import.
+let createAnyPattern: (() => Pattern) | undefined;
+
 // Forward declaration for pattern dispatch (avoids circular imports)
 let dispatchPatternPathsWithCaptures:
   | ((pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>])
@@ -32,6 +38,10 @@ export function registerWrappedPatternFactory(factory: (pattern: WrappedPattern)
   createStructureWrappedPattern = factory;
 }
 
+export function registerWrappedPatternAny(factory: () => Pattern): void {
+  createAnyPattern = factory;
+}
+
 export function registerWrappedPatternDispatch(dispatch: {
   pathsWithCaptures: (pattern: Pattern, haystack: Envelope) => [Path[], Map<string, Path[]>];
   compile: (pattern: Pattern, code: Instr[], literals: Pattern[], captures: string[]) => void;
@@ -80,12 +90,17 @@ export class WrappedPattern implements Matcher {
 
   /**
    * Creates a new WrappedPattern that matches any wrapped envelope and descends into it.
-   * Note: This requires Pattern.any() to be available, so it's set up during registration.
+   *
+   * Mirrors Rust `WrappedPattern::unwrap()` which delegates to
+   * `Self::unwrap_matching(Pattern::any())`. The `any` factory is wired in
+   * during module-load registration to break the circular import on the
+   * top-level `Pattern` type.
    */
   static unwrap(): WrappedPattern {
-    // This will be filled in when Pattern.any() is available
-    // For now, create a placeholder that will be replaced
-    return new WrappedPattern({ type: "Any" }); // Will be overwritten
+    if (createAnyPattern === undefined) {
+      throw new Error("WrappedPattern.unwrap() requires Pattern.any factory; not registered");
+    }
+    return WrappedPattern.unwrapMatching(createAnyPattern());
   }
 
   /**
@@ -184,13 +199,17 @@ export class WrappedPattern implements Matcher {
       case "Any":
         return "wrapped";
       case "Unwrap": {
-        const patternStr =
-          dispatchPatternToString !== undefined
-            ? dispatchPatternToString(this._pattern.pattern)
-            : "*";
-        if (patternStr === "*") {
+        // Rust collapses `Unwrap(Pattern::any())` to the bare keyword
+        // `unwrap`. We detect the "any" pattern by inspecting the tagged
+        // union shape rather than by string compare so this stays correct
+        // if `Pattern::any()`'s display ever changes.
+        const inner = this._pattern.pattern;
+        const isAny = inner.type === "Meta" && inner.pattern.type === "Any";
+        if (isAny) {
           return "unwrap";
         }
+        const patternStr =
+          dispatchPatternToString !== undefined ? dispatchPatternToString(inner) : "?";
         return `unwrap(${patternStr})`;
       }
     }

package/src/pattern/vm.ts

@@ -86,10 +86,10 @@ export function axisChildren(axis: Axis, env: Envelope): [Envelope, EdgeType][]
       if (envCase.type === "node") {
         const subject = envCase.subject;
         if (subject.isWrapped()) {
-          const unwrapped = subject.unwrap();
-          if (unwrapped !== undefined) {
-            return [[unwrapped, "Content"]];
-          }
+          // Mirror Rust `subject.try_unwrap().unwrap()`: the "is wrapped"
+          // check above already guarantees `tryUnwrap` won't throw.
+          const unwrapped = subject.tryUnwrap();
+          return [[unwrapped, "Content"]];
         }
       } else if (envCase.type === "wrapped") {
         return [[envCase.envelope, "Content"]];