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

package/src/pattern/leaf/cbor-pattern.ts

@@ -12,7 +12,7 @@
 
 import { Envelope } from "@bcts/envelope";
 import type { Cbor } from "@bcts/dcbor";
-import { cbor as toCbor, type CborInput } from "@bcts/dcbor";
+import { cbor as toCbor, cborData, cborEquals, type CborInput } from "@bcts/dcbor";
 import {
   type Pattern as DCBORPattern,
   patternPathsWithCaptures as dcborPatternPathsWithCaptures,
@@ -110,6 +110,13 @@ export class CBORPattern implements Matcher {
 
   /**
    * Convert a single dcbor path to an envelope path.
+   *
+   * Uses canonical CBOR-byte equality (`cborEquals`) for the "skip the
+   * dcbor root if it duplicates our base envelope" check, mirroring
+   * Rust's `dcbor_path.first().map(|first| first == &base_cbor)`. The
+   * earlier port compared diagnostic strings, which collapses values
+   * that share a textual representation but differ structurally
+   * (e.g. NaN payloads).
    */
   private _convertDcborPathToEnvelopePath(
     dcborPath: Cbor[],
@@ -118,14 +125,12 @@ export class CBORPattern implements Matcher {
   ): Envelope[] {
     const envelopePath: Envelope[] = [baseEnvelope];
 
-    // Skip first element if it matches the base envelope's CBOR content (compare by diagnostic)
-    const skipFirst =
-      dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === baseCbor.toDiagnostic();
+    const first = dcborPath[0];
+    const skipFirst = first !== undefined && cborEquals(first, baseCbor);
 
     const elementsToAdd = skipFirst ? dcborPath.slice(1) : dcborPath;
 
     for (const cborElement of elementsToAdd) {
-      // Use newLeaf to create envelope from CBOR value
       envelopePath.push(Envelope.newLeaf(cborElement));
     }
 
@@ -162,7 +167,10 @@ export class CBORPattern implements Matcher {
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     const envCase = haystack.subject().case();
 
-    // Special case for KnownValue envelope
+    // Special case for KnownValue envelope. Rust uses `known_value.to_cbor()`,
+    // and the `From<KnownValue> for CBOR` impl returns
+    // `tagged_cbor()` — i.e. the same tagged form `taggedCbor()` produces
+    // here.
     if (envCase.type === "knownValue") {
       const knownValue = envCase.value;
       const knownValueCbor = knownValue.taggedCbor();
@@ -171,8 +179,8 @@ export class CBORPattern implements Matcher {
         case "Any":
           return [[[haystack]], new Map<string, Path[]>()];
         case "Value": {
-          // Compare using diagnostic representation
-          if (knownValueCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
+          // Use canonical CBOR equality (mirrors Rust `==`).
+          if (cborEquals(knownValueCbor, this._pattern.cbor)) {
             return [[[haystack]], new Map<string, Path[]>()];
           }
           return [[], new Map<string, Path[]>()];
@@ -220,8 +228,8 @@ export class CBORPattern implements Matcher {
         return [[[haystack]], new Map<string, Path[]>()];
 
       case "Value":
-        // Compare using diagnostic representation
-        if (leafCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
+        // Canonical CBOR-byte equality, mirroring Rust `==`.
+        if (cborEquals(leafCbor, this._pattern.cbor)) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -237,9 +245,8 @@ export class CBORPattern implements Matcher {
 
           const envelopePaths: Path[] = dcborPaths.map((dcborPath: Cbor[]) => {
             const extendedPath = [...basePath];
-            // Skip the first element only if it exactly matches our root CBOR
-            const skipFirst =
-              dcborPath.length > 0 && dcborPath[0]?.toDiagnostic() === leafCbor.toDiagnostic();
+            const first = dcborPath[0];
+            const skipFirst = first !== undefined && cborEquals(first, leafCbor);
 
             const elementsToAdd = skipFirst ? dcborPath.slice(1) : dcborPath;
 
@@ -303,7 +310,10 @@ export class CBORPattern implements Matcher {
   }
 
   /**
-   * Equality comparison.
+   * Equality comparison. `Value` variants compare by canonical CBOR
+   * byte sequence (mirrors Rust `==` on `CBOR`); `Pattern` variants fall
+   * back to display-string compare since `DCBORPattern` doesn't expose
+   * structural equality outside the crate.
    */
   equals(other: CBORPattern): boolean {
     if (this._pattern.type !== other._pattern.type) {
@@ -313,13 +323,11 @@ export class CBORPattern implements Matcher {
       case "Any":
         return true;
       case "Value":
-        // Compare using diagnostic representation
-        return (
-          this._pattern.cbor.toDiagnostic() ===
-          (other._pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
+        return cborEquals(
+          this._pattern.cbor,
+          (other._pattern as { type: "Value"; cbor: Cbor }).cbor,
         );
       case "Pattern":
-        // Compare using display representation
         return (
           dcborPatternDisplay(this._pattern.pattern) ===
           dcborPatternDisplay(
@@ -336,11 +344,17 @@ export class CBORPattern implements Matcher {
     switch (this._pattern.type) {
       case "Any":
         return 0;
-      case "Value":
-        // Simple hash based on diagnostic string
-        return simpleStringHash(this._pattern.cbor.toDiagnostic());
+      case "Value": {
+        // Hash the canonical CBOR-byte representation so two values
+        // that compare equal under `cborEquals` always hash the same.
+        const bytes = cborData(this._pattern.cbor);
+        let hash = 0;
+        for (const byte of bytes) {
+          hash = (hash * 31 + byte) | 0;
+        }
+        return hash;
+      }
       case "Pattern":
-        // Simple hash based on display string
         return simpleStringHash(dcborPatternDisplay(this._pattern.pattern));
     }
   }

package/src/pattern/leaf/index.ts

@@ -22,7 +22,7 @@ export { NumberPattern, registerNumberPatternFactory } from "./number-pattern";
 export { TextPattern, registerTextPatternFactory } from "./text-pattern";
 export { ByteStringPattern, registerByteStringPatternFactory } from "./byte-string-pattern";
 export { DatePattern, registerDatePatternFactory } from "./date-pattern";
-export { ArrayPattern, type ArrayPatternType, registerArrayPatternFactory } from "./array-pattern";
+export { ArrayPattern, registerArrayPatternFactory } from "./array-pattern";
 export { MapPattern, type MapPatternType, registerMapPatternFactory } from "./map-pattern";
 export { KnownValuePattern, registerKnownValuePatternFactory } from "./known-value-pattern";
 export { TaggedPattern, registerTaggedPatternFactory } from "./tagged-pattern";

package/src/pattern/leaf/map-pattern.ts

@@ -62,6 +62,17 @@ export class MapPattern implements Matcher {
     return new MapPattern({ type: "Interval", interval });
   }
 
+  /**
+   * Creates a new MapPattern from a length Interval.
+   *
+   * Mirrors Rust `MapPattern::from_interval`. Used by the
+   * dcbor-pattern → envelope-pattern bridge to preserve `{{n,m}}`
+   * length info.
+   */
+  static fromInterval(interval: Interval): MapPattern {
+    return new MapPattern({ type: "Interval", interval });
+  }
+
   /**
    * Gets the pattern type.
    */
@@ -118,9 +129,17 @@ export class MapPattern implements Matcher {
   toString(): string {
     switch (this._pattern.type) {
       case "Any":
-        return "{*}";
+        return "map";
       case "Interval":
-        return `{{${this._pattern.interval.toString()}}}`;
+        // Mirror Rust `bc-dcbor-pattern-rust/src/pattern/structure/
+        // map_pattern.rs` `MapPattern::Length` Display:
+        //   `write!(f, "{{{}}}", interval)`  → `{<interval>}`.
+        // The interval's own `Display` already produces `{n}` /
+        // `{n,m}` / `{n,}`, so the final output is `{{n}}` (double
+        // brace from the outer literal `{` + interval's `{n}` + `}`).
+        // Earlier this port wrapped with `{{...}}` and produced
+        // `{{{n}}}` (triple brace), breaking parser parity.
+        return `{${this._pattern.interval.toString()}}`;
     }
   }
 

package/src/pattern/leaf/tagged-pattern.ts

@@ -159,7 +159,12 @@ export class TaggedPattern implements Matcher {
   }
 
   toString(): string {
-    return taggedPatternDisplay(this._inner, patternDisplay);
+    // Mirror Rust `bc-envelope-pattern-rust/src/pattern/leaf/tagged_pattern.rs`'s
+    // `Display`: delegate to the underlying dcbor-pattern `Display`, then
+    // normalize the regex-variant's `,  ` (comma + two spaces — see
+    // `bc-dcbor-pattern-rust/src/pattern/structure/tagged_pattern.rs:239`)
+    // back to `, ` so envelope-pattern's surface API stays consistent.
+    return taggedPatternDisplay(this._inner, patternDisplay).replace(",  ", ", ");
   }
 
   /**

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

@@ -94,50 +94,25 @@ export class SearchPattern implements Matcher {
   }
 
   /**
-   * Walk the envelope tree recursively.
+   * Walk the envelope tree using the canonical `Envelope.walk` traversal.
+   *
+   * Mirrors Rust `bc_envelope::Envelope::walk(false, vec![], visitor)`
+   * which is what `SearchPattern::paths_with_captures` uses. The earlier
+   * port hand-rolled a recursion that double-recursed assertions and
+   * stepped through wrapped subjects manually, producing a different
+   * path order (and extra duplicates that the digest-set deduplication
+   * would partially mask).
    */
   private _walkEnvelope(
     envelope: Envelope,
     pathToCurrent: Envelope[],
     visitor: (envelope: Envelope, path: Envelope[]) => void,
   ): void {
-    // Visit this node
-    visitor(envelope, pathToCurrent);
-
-    // Get the subject
-    const subject = envelope.subject();
-    const newPath = [...pathToCurrent, envelope];
-
-    // Walk subject if it's different from this envelope
-    if (!subject.digest().equals(envelope.digest())) {
-      this._walkEnvelope(subject, newPath, visitor);
-    }
-
-    // Walk assertions
-    for (const assertion of envelope.assertions()) {
-      this._walkEnvelope(assertion, newPath, visitor);
-
-      // Walk predicate and object if available
-      const predicate = assertion.asPredicate?.();
-      if (predicate !== undefined) {
-        const assertionPath = [...newPath, assertion];
-        this._walkEnvelope(predicate, assertionPath, visitor);
-      }
-
-      const object = assertion.asObject?.();
-      if (object !== undefined) {
-        const assertionPath = [...newPath, assertion];
-        this._walkEnvelope(object, assertionPath, visitor);
-      }
-    }
-
-    // Walk wrapped content if present
-    if (subject.isWrapped()) {
-      const unwrapped = subject.tryUnwrap?.();
-      if (unwrapped !== undefined) {
-        this._walkEnvelope(unwrapped, newPath, visitor);
-      }
-    }
+    envelope.walk<Envelope[]>(false, pathToCurrent, (current, _level, _edge, state) => {
+      visitor(current, state);
+      // Children inherit a path that includes the current node.
+      return [[...state, current], false];
+    });
   }
 
   paths(haystack: Envelope): Path[] {

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

@@ -12,7 +12,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { dispatchPatternToString, type Matcher } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -144,7 +144,7 @@ export class TraversePattern implements Matcher {
 
   toString(): string {
     return this.patterns()
-      .map((p) => (p as unknown as { toString(): string }).toString())
+      .map((p) => dispatchPatternToString(p))
       .join(" -> ");
   }
 

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

@@ -18,6 +18,7 @@ import type { Pattern } from "../index";
 
 // Forward declaration for Pattern factory
 let createStructureAssertionsPattern: ((pattern: AssertionsPattern) => Pattern) | undefined;
+let dispatchPatternToString: ((pattern: Pattern) => string) | undefined;
 
 export function registerAssertionsPatternFactory(
   factory: (pattern: AssertionsPattern) => Pattern,
@@ -25,20 +26,22 @@ export function registerAssertionsPatternFactory(
   createStructureAssertionsPattern = factory;
 }
 
+export function registerAssertionsPatternToStringDispatch(fn: (pattern: Pattern) => string): void {
+  dispatchPatternToString = fn;
+}
+
 /**
  * Pattern type for assertions pattern matching.
  *
- * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
+ * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs:
+ * - `Any` matches any assertion.
+ * - `WithPredicate` matches assertions whose predicate matches a sub-pattern.
+ * - `WithObject` matches assertions whose object matches a sub-pattern.
  */
 export type AssertionsPatternType =
   | { readonly type: "Any" }
   | { readonly type: "WithPredicate"; readonly pattern: Pattern }
-  | { readonly type: "WithObject"; readonly pattern: Pattern }
-  | {
-      readonly type: "WithBoth";
-      readonly predicatePattern: Pattern;
-      readonly objectPattern: Pattern;
-    };
+  | { readonly type: "WithObject"; readonly pattern: Pattern };
 
 /**
  * Pattern for matching assertions in envelopes.
@@ -75,14 +78,6 @@ export class AssertionsPattern implements Matcher {
     return new AssertionsPattern({ type: "WithObject", pattern });
   }
 
-  /**
-   * Creates a new AssertionsPattern that matches assertions with both
-   * predicate and object patterns.
-   */
-  static withBoth(predicatePattern: Pattern, objectPattern: Pattern): AssertionsPattern {
-    return new AssertionsPattern({ type: "WithBoth", predicatePattern, objectPattern });
-  }
-
   /**
    * Gets the pattern type.
    */
@@ -97,9 +92,6 @@ export class AssertionsPattern implements Matcher {
     if (this._pattern.type === "WithPredicate") {
       return this._pattern.pattern;
     }
-    if (this._pattern.type === "WithBoth") {
-      return this._pattern.predicatePattern;
-    }
     return undefined;
   }
 
@@ -110,9 +102,6 @@ export class AssertionsPattern implements Matcher {
     if (this._pattern.type === "WithObject") {
       return this._pattern.pattern;
     }
-    if (this._pattern.type === "WithBoth") {
-      return this._pattern.objectPattern;
-    }
     return undefined;
   }
 
@@ -142,19 +131,6 @@ export class AssertionsPattern implements Matcher {
           }
           break;
         }
-        case "WithBoth": {
-          const predicate = assertion.asPredicate?.();
-          const object = assertion.asObject?.();
-          if (predicate !== undefined && object !== undefined) {
-            if (
-              matchPattern(this._pattern.predicatePattern, predicate) &&
-              matchPattern(this._pattern.objectPattern, object)
-            ) {
-              paths.push([assertion]);
-            }
-          }
-          break;
-        }
       }
     }
 
@@ -183,15 +159,18 @@ export class AssertionsPattern implements Matcher {
   }
 
   toString(): string {
+    const fmt = dispatchPatternToString;
     switch (this._pattern.type) {
       case "Any":
         return "assert";
-      case "WithPredicate":
-        return `assertpred(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
-      case "WithObject":
-        return `assertobj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
-      case "WithBoth":
-        return `assert(${(this._pattern.predicatePattern as unknown as { toString(): string }).toString()}, ${(this._pattern.objectPattern as unknown as { toString(): string }).toString()})`;
+      case "WithPredicate": {
+        const inner = fmt !== undefined ? fmt(this._pattern.pattern) : "?";
+        return `assertpred(${inner})`;
+      }
+      case "WithObject": {
+        const inner = fmt !== undefined ? fmt(this._pattern.pattern) : "?";
+        return `assertobj(${inner})`;
+      }
     }
   }
 
@@ -215,17 +194,6 @@ export class AssertionsPattern implements Matcher {
         ).pattern;
         return thisPattern === otherPattern;
       }
-      case "WithBoth": {
-        const otherBoth = other._pattern as {
-          type: "WithBoth";
-          predicatePattern: Pattern;
-          objectPattern: Pattern;
-        };
-        return (
-          this._pattern.predicatePattern === otherBoth.predicatePattern &&
-          this._pattern.objectPattern === otherBoth.objectPattern
-        );
-      }
     }
   }
 
@@ -240,8 +208,6 @@ export class AssertionsPattern implements Matcher {
         return 1;
       case "WithObject":
         return 2;
-      case "WithBoth":
-        return 3;
     }
   }
 }

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

@@ -39,10 +39,11 @@ function bytesToLatin1(bytes: Uint8Array): string {
 /**
  * Pattern type for digest pattern matching.
  *
- * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
+ * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs.
+ * Rust has only `Digest`, `Prefix`, and `BinaryRegex` variants — there is
+ * no `Any` here. To match "any digest", use the meta `any()` pattern.
  */
 export type DigestPatternType =
-  | { readonly type: "Any" }
   | { readonly type: "Digest"; readonly digest: Digest }
   | { readonly type: "Prefix"; readonly prefix: Uint8Array }
   | { readonly type: "BinaryRegex"; readonly regex: RegExp };
@@ -59,13 +60,6 @@ export class DigestPattern implements Matcher {
     this._pattern = pattern;
   }
 
-  /**
-   * Creates a new DigestPattern that matches any digest.
-   */
-  static any(): DigestPattern {
-    return new DigestPattern({ type: "Any" });
-  }
-
   /**
    * Creates a new DigestPattern that matches the exact digest.
    */
@@ -100,10 +94,6 @@ export class DigestPattern implements Matcher {
     let isHit = false;
 
     switch (this._pattern.type) {
-      case "Any":
-        // Any digest matches - every envelope has a digest
-        isHit = true;
-        break;
       case "Digest":
         isHit = digest.equals(this._pattern.digest);
         break;
@@ -152,8 +142,6 @@ export class DigestPattern implements Matcher {
 
   toString(): string {
     switch (this._pattern.type) {
-      case "Any":
-        return "digest";
       case "Digest":
         return `digest(${this._pattern.digest.hex()})`;
       case "Prefix":
@@ -165,14 +153,17 @@ export class DigestPattern implements Matcher {
 
   /**
    * Equality comparison.
+   *
+   * `Prefix` comparison is case-insensitive on the *hex representation* to
+   * mirror Rust's `eq_ignore_ascii_case` (which compares the underlying
+   * `Vec<u8>` of hex bytes byte-for-byte modulo ASCII case). For raw byte
+   * prefixes that happen to be ASCII, this is an ordinary byte compare.
    */
   equals(other: DigestPattern): boolean {
     if (this._pattern.type !== other._pattern.type) {
       return false;
     }
     switch (this._pattern.type) {
-      case "Any":
-        return true;
       case "Digest":
         return this._pattern.digest.equals(
           (other._pattern as { type: "Digest"; digest: Digest }).digest,
@@ -182,7 +173,13 @@ export class DigestPattern implements Matcher {
         const otherPrefix = (other._pattern as { type: "Prefix"; prefix: Uint8Array }).prefix;
         if (thisPrefix.length !== otherPrefix.length) return false;
         for (let i = 0; i < thisPrefix.length; i++) {
-          if (thisPrefix[i] !== otherPrefix[i]) return false;
+          const a = thisPrefix[i];
+          const b = otherPrefix[i];
+          if (a === b) continue;
+          // ASCII case-insensitive compare ('A'..='Z' ↔ 'a'..='z')
+          const aLower = a >= 0x41 && a <= 0x5a ? a + 0x20 : a;
+          const bLower = b >= 0x41 && b <= 0x5a ? b + 0x20 : b;
+          if (aLower !== bLower) return false;
         }
         return true;
       }
@@ -199,10 +196,7 @@ export class DigestPattern implements Matcher {
    */
   hashCode(): number {
     switch (this._pattern.type) {
-      case "Any":
-        return 0;
       case "Digest": {
-        // Hash based on first few bytes of digest
         const data = this._pattern.digest.data().slice(0, 8);
         let hash = 0;
         for (const byte of data) {
@@ -213,7 +207,9 @@ export class DigestPattern implements Matcher {
       case "Prefix": {
         let hash = 0;
         for (const byte of this._pattern.prefix) {
-          hash = (hash * 31 + byte) | 0;
+          // Fold ASCII case to match equality semantics.
+          const folded = byte >= 0x41 && byte <= 0x5a ? byte + 0x20 : byte;
+          hash = (hash * 31 + folded) | 0;
         }
         return hash;
       }

package/src/pattern/structure/index.ts

@@ -24,6 +24,7 @@ export {
   SubjectPattern,
   type SubjectPatternType,
   registerSubjectPatternFactory,
+  registerSubjectPatternDispatch,
 } from "./subject-pattern";
 export {
   PredicatePattern,
@@ -39,6 +40,7 @@ export {
   AssertionsPattern,
   type AssertionsPatternType,
   registerAssertionsPatternFactory,
+  registerAssertionsPatternToStringDispatch,
 } from "./assertions-pattern";
 export {
   DigestPattern,
@@ -56,6 +58,7 @@ export {
   type WrappedPatternType,
   registerWrappedPatternFactory,
   registerWrappedPatternDispatch,
+  registerWrappedPatternAny,
 } from "./wrapped-pattern";
 
 // Import concrete types for use in StructurePattern

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

@@ -28,12 +28,14 @@ export function registerNodePatternFactory(factory: (pattern: NodePattern) => Pa
 /**
  * Pattern type for node pattern matching.
  *
- * Corresponds to the Rust `NodePattern` enum in node_pattern.rs
+ * Corresponds to the Rust `NodePattern` enum in node_pattern.rs:
+ * - `Any` matches any node.
+ * - `AssertionsInterval` matches a node whose number of assertions falls in
+ *   the given interval (e.g., `node({2,5})`).
  */
 export type NodePatternType =
   | { readonly type: "Any" }
-  | { readonly type: "AssertionsInterval"; readonly interval: Interval }
-  | { readonly type: "WithSubject"; readonly subjectPattern: Pattern };
+  | { readonly type: "AssertionsInterval"; readonly interval: Interval };
 
 /**
  * Pattern for matching node envelopes.
@@ -69,13 +71,6 @@ export class NodePattern implements Matcher {
     return new NodePattern({ type: "AssertionsInterval", interval });
   }
 
-  /**
-   * Creates a new NodePattern with a subject pattern constraint.
-   */
-  static withSubject(subjectPattern: Pattern): NodePattern {
-    return new NodePattern({ type: "WithSubject", subjectPattern });
-  }
-
   /**
    * Gets the pattern type.
    */
@@ -84,17 +79,18 @@ export class NodePattern implements Matcher {
   }
 
   /**
-   * Gets the subject pattern if this is a WithSubject type, undefined otherwise.
+   * Returns the subject pattern, if any. Rust's `NodePattern` does not carry
+   * subject patterns, so this always returns `undefined`.
    */
   subjectPattern(): Pattern | undefined {
-    return this._pattern.type === "WithSubject" ? this._pattern.subjectPattern : undefined;
+    return undefined;
   }
 
   /**
-   * Gets the assertion patterns (empty array if none).
+   * Returns the assertion patterns. Rust's `NodePattern` does not carry
+   * assertion sub-patterns, so this always returns an empty array.
    */
   assertionPatterns(): Pattern[] {
-    // NodePattern doesn't support assertion patterns directly; return empty array
     return [];
   }
 
@@ -112,10 +108,6 @@ export class NodePattern implements Matcher {
       case "AssertionsInterval":
         isHit = this._pattern.interval.contains(haystack.assertions().length);
         break;
-      case "WithSubject":
-        // For WithSubject, we match if the node exists (subject pattern matching done at higher level)
-        isHit = true;
-        break;
     }
 
     const paths = isHit ? [[haystack]] : [];
@@ -147,8 +139,6 @@ export class NodePattern implements Matcher {
         return "node";
       case "AssertionsInterval":
         return `node(${this._pattern.interval.toString()})`;
-      case "WithSubject":
-        return `node(${(this._pattern.subjectPattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -166,12 +156,6 @@ export class NodePattern implements Matcher {
         return this._pattern.interval.equals(
           (other._pattern as { type: "AssertionsInterval"; interval: Interval }).interval,
         );
-      case "WithSubject":
-        // Simple reference equality for pattern (could be improved with deep equality)
-        return (
-          this._pattern.subjectPattern ===
-          (other._pattern as { type: "WithSubject"; subjectPattern: Pattern }).subjectPattern
-        );
     }
   }
 
@@ -183,10 +167,7 @@ export class NodePattern implements Matcher {
       case "Any":
         return 0;
       case "AssertionsInterval":
-        // Simple hash based on interval min/max
         return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
-      case "WithSubject":
-        return 1;
     }
   }
 }

package/src/pattern/structure/object-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";
 
@@ -124,7 +124,7 @@ export class ObjectPattern implements Matcher {
       case "Any":
         return "obj";
       case "Pattern":
-        return `obj(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `obj(${dispatchPatternToString(this._pattern.pattern)})`;
     }
   }