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

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;
@@ -25,10 +26,10 @@ export function registerSearchPatternFactory(factory: (pattern: SearchPattern) =
  * Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
  */
 export class SearchPattern implements Matcher {
-  readonly #pattern: Pattern;
+  private readonly _pattern: Pattern;
 
   private constructor(pattern: Pattern) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -42,20 +43,19 @@ export class SearchPattern implements Matcher {
    * Gets the inner pattern.
    */
   pattern(): Pattern {
-    return this.#pattern;
+    return this._pattern;
   }
 
   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) => {
+    this._walkEnvelope(haystack, [], (currentEnvelope, pathToCurrent) => {
       // Create the path to this node
       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) {
@@ -92,7 +92,7 @@ export class SearchPattern implements Matcher {
   /**
    * Walk the envelope tree recursively.
    */
-  #walkEnvelope(
+  private _walkEnvelope(
     envelope: Envelope,
     pathToCurrent: Envelope[],
     visitor: (envelope: Envelope, path: Envelope[]) => void,
@@ -106,24 +106,24 @@ export class SearchPattern implements Matcher {
 
     // Walk subject if it's different from this envelope
     if (!subject.digest().equals(envelope.digest())) {
-      this.#walkEnvelope(subject, newPath, visitor);
+      this._walkEnvelope(subject, newPath, visitor);
     }
 
     // Walk assertions
     for (const assertion of envelope.assertions()) {
-      this.#walkEnvelope(assertion, newPath, visitor);
+      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);
+        this._walkEnvelope(predicate, assertionPath, visitor);
       }
 
       const object = assertion.asObject?.();
       if (object !== undefined) {
         const assertionPath = [...newPath, assertion];
-        this.#walkEnvelope(object, assertionPath, visitor);
+        this._walkEnvelope(object, assertionPath, visitor);
       }
     }
 
@@ -131,7 +131,7 @@ export class SearchPattern implements Matcher {
     if (subject.isWrapped()) {
       const unwrapped = subject.tryUnwrap?.();
       if (unwrapped !== undefined) {
-        this.#walkEnvelope(unwrapped, newPath, visitor);
+        this._walkEnvelope(unwrapped, newPath, visitor);
       }
     }
   }
@@ -146,11 +146,11 @@ export class SearchPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     const idx = literals.length;
-    literals.push(this.#pattern);
+    literals.push(this._pattern);
 
     // Collect capture names from inner pattern
     const innerNames: string[] = [];
-    collectCaptureNames(this.#pattern, innerNames);
+    collectCaptureNames(this._pattern, innerNames);
 
     const captureMap: [string, number][] = [];
     for (const name of innerNames) {
@@ -170,14 +170,14 @@ export class SearchPattern implements Matcher {
   }
 
   toString(): string {
-    return `search(${(this.#pattern as unknown as { toString(): string }).toString()})`;
+    return `search(${dispatchPatternToString(this._pattern)})`;
   }
 
   /**
    * Equality comparison.
    */
   equals(other: SearchPattern): boolean {
-    return this.#pattern === other.#pattern;
+    return this._pattern === other._pattern;
   }
 
   /**

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

@@ -21,18 +21,37 @@ 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.
  *
  * Corresponds to the Rust `TraversePattern` struct in traverse_pattern.rs
  */
 export class TraversePattern implements Matcher {
-  readonly #first: Pattern;
-  readonly #rest: TraversePattern | undefined;
+  private readonly _first: Pattern;
+  private readonly _rest: TraversePattern | undefined;
 
   private constructor(first: Pattern, rest: TraversePattern | undefined) {
-    this.#first = first;
-    this.#rest = rest;
+    this._first = first;
+    this._rest = rest;
   }
 
   /**
@@ -53,19 +72,21 @@ export class TraversePattern implements Matcher {
    * Gets all patterns in this traversal.
    */
   patterns(): Pattern[] {
-    const result: Pattern[] = [this.#first];
-    if (this.#rest !== undefined) {
-      result.push(...this.#rest.patterns());
+    const result: Pattern[] = [this._first];
+    if (this._rest !== undefined) {
+      result.push(...this._rest.patterns());
     }
     return result;
   }
 
   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) {
+    if (this._rest === undefined) {
       return [headPaths, new Map<string, Path[]>()];
     }
 
@@ -74,7 +95,7 @@ export class TraversePattern implements Matcher {
       const lastEnv = path[path.length - 1];
       if (lastEnv !== undefined) {
         // Recursively match the rest of the traversal
-        const tailPaths = this.#rest.paths(lastEnv);
+        const tailPaths = this._rest.paths(lastEnv);
         for (const tailPath of tailPaths) {
           const combined = [...path, ...tailPath];
           result.push(combined);
@@ -94,24 +115,27 @@ 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) {
+    if (this._rest !== undefined) {
       // Save the current path and switch to last envelope
       code.push({ type: "ExtendTraversal" });
       // Compile the rest of the traversal
-      this.#rest.compile(code, literals, captures);
+      this._rest.compile(code, literals, captures);
       // Combine the paths correctly
       code.push({ type: "CombineTraversal" });
     }
   }
 
   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";
 
@@ -42,10 +42,10 @@ export type AssertionsPatternType =
  * Corresponds to the Rust `AssertionsPattern` enum in assertions_pattern.rs
  */
 export class AssertionsPattern implements Matcher {
-  readonly #pattern: AssertionsPatternType;
+  private readonly _pattern: AssertionsPatternType;
 
   private constructor(pattern: AssertionsPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -83,18 +83,18 @@ export class AssertionsPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): AssertionsPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the predicate pattern if this has one, undefined otherwise.
    */
   predicatePattern(): Pattern | undefined {
-    if (this.#pattern.type === "WithPredicate") {
-      return this.#pattern.pattern;
+    if (this._pattern.type === "WithPredicate") {
+      return this._pattern.pattern;
     }
-    if (this.#pattern.type === "WithBoth") {
-      return this.#pattern.predicatePattern;
+    if (this._pattern.type === "WithBoth") {
+      return this._pattern.predicatePattern;
     }
     return undefined;
   }
@@ -103,11 +103,11 @@ export class AssertionsPattern implements Matcher {
    * Gets the object pattern if this has one, undefined otherwise.
    */
   objectPattern(): Pattern | undefined {
-    if (this.#pattern.type === "WithObject") {
-      return this.#pattern.pattern;
+    if (this._pattern.type === "WithObject") {
+      return this._pattern.pattern;
     }
-    if (this.#pattern.type === "WithBoth") {
-      return this.#pattern.objectPattern;
+    if (this._pattern.type === "WithBoth") {
+      return this._pattern.objectPattern;
     }
     return undefined;
   }
@@ -116,15 +116,14 @@ export class AssertionsPattern implements Matcher {
     const paths: Path[] = [];
 
     for (const assertion of haystack.assertions()) {
-      switch (this.#pattern.type) {
+      switch (this._pattern.type) {
         case "Any":
           paths.push([assertion]);
           break;
         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]);
             }
           }
@@ -180,15 +179,15 @@ export class AssertionsPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "assert";
       case "WithPredicate":
-        return `assertpred(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        return `assertpred(${(this._pattern.pattern as unknown as { toString(): string }).toString()})`;
       case "WithObject":
-        return `assertobj(${(this.#pattern.pattern as unknown as { toString(): string }).toString()})`;
+        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()})`;
+        return `assert(${(this._pattern.predicatePattern as unknown as { toString(): string }).toString()}, ${(this._pattern.objectPattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -196,31 +195,31 @@ export class AssertionsPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: AssertionsPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return true;
       case "WithPredicate":
       case "WithObject": {
         const thisPattern = (
-          this.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+          this._pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
         ).pattern;
         const otherPattern = (
-          other.#pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
+          other._pattern as { type: "WithPredicate" | "WithObject"; pattern: Pattern }
         ).pattern;
         return thisPattern === otherPattern;
       }
       case "WithBoth": {
-        const otherBoth = other.#pattern as {
+        const otherBoth = other._pattern as {
           type: "WithBoth";
           predicatePattern: Pattern;
           objectPattern: Pattern;
         };
         return (
-          this.#pattern.predicatePattern === otherBoth.predicatePattern &&
-          this.#pattern.objectPattern === otherBoth.objectPattern
+          this._pattern.predicatePattern === otherBoth.predicatePattern &&
+          this._pattern.objectPattern === otherBoth.objectPattern
         );
       }
     }
@@ -230,7 +229,7 @@ export class AssertionsPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "WithPredicate":

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

@@ -49,10 +49,10 @@ export type DigestPatternType =
  * Corresponds to the Rust `DigestPattern` enum in digest_pattern.rs
  */
 export class DigestPattern implements Matcher {
-  readonly #pattern: DigestPatternType;
+  private readonly _pattern: DigestPatternType;
 
   private constructor(pattern: DigestPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -87,7 +87,7 @@ export class DigestPattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): DigestPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -95,16 +95,16 @@ export class DigestPattern implements Matcher {
     const digestData = digest.data();
     let isHit = false;
 
-    switch (this.#pattern.type) {
+    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);
+        isHit = digest.equals(this._pattern.digest);
         break;
       case "Prefix": {
-        const prefix = this.#pattern.prefix;
+        const prefix = this._pattern.prefix;
         if (digestData.length >= prefix.length) {
           isHit = true;
           for (let i = 0; i < prefix.length; i++) {
@@ -118,7 +118,7 @@ export class DigestPattern implements Matcher {
       }
       case "BinaryRegex": {
         const latin1 = bytesToLatin1(digestData);
-        isHit = this.#pattern.regex.test(latin1);
+        isHit = this._pattern.regex.test(latin1);
         break;
       }
     }
@@ -147,15 +147,15 @@ export class DigestPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "digest";
       case "Digest":
-        return `digest(${this.#pattern.digest.hex()})`;
+        return `digest(${this._pattern.digest.hex()})`;
       case "Prefix":
-        return `digest(${bytesToHex(this.#pattern.prefix)})`;
+        return `digest(${bytesToHex(this._pattern.prefix)})`;
       case "BinaryRegex":
-        return `digest(/${this.#pattern.regex.source}/)`;
+        return `digest(/${this._pattern.regex.source}/)`;
     }
   }
 
@@ -163,19 +163,19 @@ export class DigestPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: DigestPattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return true;
       case "Digest":
-        return this.#pattern.digest.equals(
-          (other.#pattern as { type: "Digest"; digest: Digest }).digest,
+        return this._pattern.digest.equals(
+          (other._pattern as { type: "Digest"; digest: Digest }).digest,
         );
       case "Prefix": {
-        const thisPrefix = this.#pattern.prefix;
-        const otherPrefix = (other.#pattern as { type: "Prefix"; prefix: Uint8Array }).prefix;
+        const thisPrefix = this._pattern.prefix;
+        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;
@@ -184,8 +184,8 @@ export class DigestPattern implements Matcher {
       }
       case "BinaryRegex":
         return (
-          this.#pattern.regex.source ===
-          (other.#pattern as { type: "BinaryRegex"; regex: RegExp }).regex.source
+          this._pattern.regex.source ===
+          (other._pattern as { type: "BinaryRegex"; regex: RegExp }).regex.source
         );
     }
   }
@@ -194,12 +194,12 @@ export class DigestPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    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);
+        const data = this._pattern.digest.data().slice(0, 8);
         let hash = 0;
         for (const byte of data) {
           hash = (hash * 31 + byte) | 0;
@@ -208,14 +208,14 @@ export class DigestPattern implements Matcher {
       }
       case "Prefix": {
         let hash = 0;
-        for (const byte of this.#pattern.prefix) {
+        for (const byte of this._pattern.prefix) {
           hash = (hash * 31 + byte) | 0;
         }
         return hash;
       }
       case "BinaryRegex": {
         let hash = 0;
-        for (const char of this.#pattern.regex.source) {
+        for (const char of this._pattern.regex.source) {
           hash = (hash * 31 + char.charCodeAt(0)) | 0;
         }
         return hash;

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/node-pattern.ts

@@ -37,10 +37,10 @@ export type NodePatternType =
  * Corresponds to the Rust `NodePattern` enum in node_pattern.rs
  */
 export class NodePattern implements Matcher {
-  readonly #pattern: NodePatternType;
+  private readonly _pattern: NodePatternType;
 
   private constructor(pattern: NodePatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -76,14 +76,14 @@ export class NodePattern implements Matcher {
    * Gets the pattern type.
    */
   get patternType(): NodePatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Gets the subject pattern if this is a WithSubject type, undefined otherwise.
    */
   subjectPattern(): Pattern | undefined {
-    return this.#pattern.type === "WithSubject" ? this.#pattern.subjectPattern : undefined;
+    return this._pattern.type === "WithSubject" ? this._pattern.subjectPattern : undefined;
   }
 
   /**
@@ -101,12 +101,12 @@ export class NodePattern implements Matcher {
 
     let isHit = false;
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         isHit = true;
         break;
       case "AssertionsInterval":
-        isHit = this.#pattern.interval.contains(haystack.assertions().length);
+        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)
@@ -138,13 +138,13 @@ export class NodePattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "node";
       case "AssertionsInterval":
-        return `node(${this.#pattern.interval.toString()})`;
+        return `node(${this._pattern.interval.toString()})`;
       case "WithSubject":
-        return `node(${(this.#pattern.subjectPattern as unknown as { toString(): string }).toString()})`;
+        return `node(${(this._pattern.subjectPattern as unknown as { toString(): string }).toString()})`;
     }
   }
 
@@ -152,21 +152,21 @@ export class NodePattern implements Matcher {
    * Equality comparison.
    */
   equals(other: NodePattern): boolean {
-    if (this.#pattern.type !== other.#pattern.type) {
+    if (this._pattern.type !== other._pattern.type) {
       return false;
     }
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return true;
       case "AssertionsInterval":
-        return this.#pattern.interval.equals(
-          (other.#pattern as { type: "AssertionsInterval"; interval: Interval }).interval,
+        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
+          this._pattern.subjectPattern ===
+          (other._pattern as { type: "WithSubject"; subjectPattern: Pattern }).subjectPattern
         );
     }
   }
@@ -175,12 +175,12 @@ export class NodePattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "AssertionsInterval":
         // Simple hash based on interval min/max
-        return this.#pattern.interval.min() * 31 + (this.#pattern.interval.max() ?? 0);
+        return this._pattern.interval.min() * 31 + (this._pattern.interval.max() ?? 0);
       case "WithSubject":
         return 1;
     }