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

package/src/pattern/index.ts

@@ -19,6 +19,7 @@ import {
 
 import type { Path } from "../format";
 import type { Instr } from "./vm";
+import { compile, run } from "./vm";
 
 // Re-export sub-modules
 export * from "./leaf";
@@ -104,6 +105,7 @@ import {
   registerNodePatternFactory,
   registerObscuredPatternFactory,
   registerWrappedPatternFactory,
+  registerWrappedPatternDispatch,
 } from "./structure";
 
 // Import meta patterns
@@ -176,13 +178,57 @@ export function patternMeta(meta: MetaPattern): Pattern {
 // Pattern Matcher Implementation
 // ============================================================================
 
+/**
+ * Check if a pattern requires the VM for execution.
+ * Patterns containing Group (repeat), Traverse, or Search require compilation.
+ */
+function patternNeedsVM(pattern: Pattern): boolean {
+  switch (pattern.type) {
+    case "Leaf":
+    case "Structure":
+      return false;
+    case "Meta":
+      return metaPatternNeedsVM(pattern.pattern);
+  }
+}
+
+function metaPatternNeedsVM(pattern: MetaPattern): boolean {
+  switch (pattern.type) {
+    case "Any":
+      return false;
+    case "And":
+      return pattern.pattern.patterns().some(patternNeedsVM);
+    case "Or":
+      return pattern.pattern.patterns().some(patternNeedsVM);
+    case "Not":
+      return patternNeedsVM(pattern.pattern.pattern());
+    case "Capture":
+      return patternNeedsVM(pattern.pattern.pattern());
+    case "Search":
+    case "Traverse":
+      return true;
+    case "Group": {
+      // Group with exactly(1) is simple pass-through, doesn't need VM
+      const q = pattern.pattern.quantifier();
+      if (q.min() === 1 && q.max() === 1) {
+        return patternNeedsVM(pattern.pattern.pattern());
+      }
+      return true;
+    }
+  }
+}
+
 /**
  * Gets paths with captures for a pattern.
+ * Routes through the VM for complex patterns that require compilation.
  */
 export function patternPathsWithCaptures(
   pattern: Pattern,
   haystack: Envelope,
 ): [Path[], Map<string, Path[]>] {
+  if (patternNeedsVM(pattern)) {
+    return patternPathsWithCapturesViaVM(pattern, haystack);
+  }
   switch (pattern.type) {
     case "Leaf":
       return leafPatternPathsWithCaptures(pattern.pattern, haystack);
@@ -193,6 +239,31 @@ export function patternPathsWithCaptures(
   }
 }
 
+/**
+ * Execute a pattern through the VM, merging results.
+ */
+function patternPathsWithCapturesViaVM(
+  pattern: Pattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  const prog = compile(pattern);
+  const results = run(prog, haystack);
+
+  const allPaths: Path[] = [];
+  const mergedCaptures = new Map<string, Path[]>();
+
+  for (const [path, captures] of results) {
+    allPaths.push(path);
+    for (const [name, paths] of captures) {
+      const existing = mergedCaptures.get(name) ?? [];
+      existing.push(...paths);
+      mergedCaptures.set(name, existing);
+    }
+  }
+
+  return [allPaths, mergedCaptures];
+}
+
 /**
  * Gets paths for a pattern.
  */
@@ -347,6 +418,27 @@ export function dateRange(earliest: CborDate, latest: CborDate): Pattern {
   return patternLeaf(leafDate(DatePattern.range(earliest, latest)));
 }
 
+/**
+ * Creates a new Pattern that matches Date values on or after the specified date.
+ */
+export function dateEarliest(d: CborDate): Pattern {
+  return patternLeaf(leafDate(DatePattern.earliest(d)));
+}
+
+/**
+ * Creates a new Pattern that matches Date values on or before the specified date.
+ */
+export function dateLatest(d: CborDate): Pattern {
+  return patternLeaf(leafDate(DatePattern.latest(d)));
+}
+
+/**
+ * Creates a new Pattern that matches Date values whose ISO-8601 string matches the regex.
+ */
+export function dateRegex(pattern: RegExp): Pattern {
+  return patternLeaf(leafDate(DatePattern.regex(pattern)));
+}
+
 /**
  * Creates a new Pattern that matches any number value.
  */
@@ -700,6 +792,11 @@ function registerAllFactories(): void {
   registerNodePatternFactory((p) => patternStructure(structureNode(p)));
   registerObscuredPatternFactory((p) => patternStructure(structureObscured(p)));
   registerWrappedPatternFactory((p) => patternStructure(structureWrapped(p)));
+  registerWrappedPatternDispatch({
+    pathsWithCaptures: patternPathsWithCaptures,
+    compile: patternCompile,
+    toString: patternToString,
+  });
 
   // Meta pattern factories
   registerAnyPatternFactory((p) => patternMeta(metaAny(p)));
@@ -719,6 +816,17 @@ registerAllFactories();
 import { registerVMPatternFunctions } from "./vm";
 registerVMPatternFunctions(patternPathsWithCaptures, patternMatches, patternPaths);
 
-// Register pattern match function for meta patterns
-import { registerPatternMatchFn } from "./matcher";
+// Register pattern dispatch functions for meta patterns
+import { registerPatternMatchFn, registerPatternDispatchFns } from "./matcher";
 registerPatternMatchFn(patternMatches);
+registerPatternDispatchFns({
+  pathsWithCaptures: patternPathsWithCaptures,
+  paths: patternPaths,
+  compile: patternCompile,
+  isComplex: patternIsComplex,
+  toString: patternToString,
+});
+
+// Register traverse dispatch functions to resolve circular dependencies
+import { registerTraverseDispatchFunctions } from "./meta/traverse-pattern";
+registerTraverseDispatchFunctions(patternPathsWithCaptures, patternCompile, patternIsComplex);

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

@@ -44,10 +44,10 @@ export type ArrayPatternType =
  * Corresponds to the Rust `ArrayPattern` struct in array_pattern.rs
  */
 export class ArrayPattern implements Matcher {
-  readonly #pattern: ArrayPatternType;
+  private readonly _pattern: ArrayPatternType;
 
   private constructor(pattern: ArrayPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -93,12 +93,12 @@ export class ArrayPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): ArrayPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // Try to extract CBOR from the envelope
-    const cbor = haystack.asLeaf();
+    const cbor = haystack.subject().asLeaf();
     if (cbor === undefined) {
       return [[], new Map<string, Path[]>()];
     }
@@ -109,13 +109,13 @@ export class ArrayPattern implements Matcher {
       return [[], new Map<string, Path[]>()];
     }
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return [[[haystack]], new Map<string, Path[]>()];
 
       case "Interval": {
         const length = array.length;
-        if (this.#pattern.interval.contains(length)) {
+        if (this._pattern.interval.contains(length)) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -124,7 +124,7 @@ export class ArrayPattern implements Matcher {
       case "DCBORPattern": {
         // Delegate to dcbor-pattern for matching
         const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-          this.#pattern.pattern,
+          this._pattern.pattern,
           cbor,
         );
 
@@ -167,7 +167,7 @@ export class ArrayPattern implements Matcher {
       case "WithPatterns":
         // For envelope patterns, match if array length equals patterns count
         // Full element-by-element matching would require additional implementation
-        if (array.length === this.#pattern.patterns.length) {
+        if (array.length === this._pattern.patterns.length) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -194,15 +194,15 @@ export class ArrayPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "[*]";
       case "Interval":
-        return `[{${this.#pattern.interval.toString()}}]`;
+        return `[{${this._pattern.interval.toString()}}]`;
       case "DCBORPattern":
-        return dcborPatternDisplay(this.#pattern.pattern);
+        return dcborPatternDisplay(this._pattern.pattern);
       case "WithPatterns":
-        return `[${this.#pattern.patterns.map(String).join(", ")}]`;
+        return `[${this._pattern.patterns.map(String).join(", ")}]`;
     }
   }
 
@@ -210,30 +210,30 @@ export class ArrayPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: ArrayPattern): 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 "Interval":
-        return this.#pattern.interval.equals(
-          (other.#pattern as { type: "Interval"; interval: Interval }).interval,
+        return this._pattern.interval.equals(
+          (other._pattern as { type: "Interval"; interval: Interval }).interval,
         );
       case "DCBORPattern":
         // Compare using display representation
         return (
-          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(this._pattern.pattern) ===
           dcborPatternDisplay(
-            (other.#pattern as { type: "DCBORPattern"; pattern: DCBORPattern }).pattern,
+            (other._pattern as { type: "DCBORPattern"; pattern: DCBORPattern }).pattern,
           )
         );
       case "WithPatterns": {
-        const otherPatterns = (other.#pattern as { type: "WithPatterns"; patterns: Pattern[] })
+        const otherPatterns = (other._pattern as { type: "WithPatterns"; patterns: Pattern[] })
           .patterns;
-        if (this.#pattern.patterns.length !== otherPatterns.length) return false;
-        for (let i = 0; i < this.#pattern.patterns.length; i++) {
-          if (this.#pattern.patterns[i] !== otherPatterns[i]) return false;
+        if (this._pattern.patterns.length !== otherPatterns.length) return false;
+        for (let i = 0; i < this._pattern.patterns.length; i++) {
+          if (this._pattern.patterns[i] !== otherPatterns[i]) return false;
         }
         return true;
       }
@@ -244,17 +244,17 @@ export class ArrayPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Interval":
         // Simple hash based on 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 "DCBORPattern":
         // Simple hash based on display string
-        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+        return simpleStringHash(dcborPatternDisplay(this._pattern.pattern));
       case "WithPatterns":
-        return this.#pattern.patterns.length;
+        return this._pattern.patterns.length;
     }
   }
 }

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

@@ -36,10 +36,10 @@ export function registerBoolPatternFactory(factory: (pattern: BoolPattern) => Pa
  * Corresponds to the Rust `BoolPattern` struct in bool_pattern.rs
  */
 export class BoolPattern implements Matcher {
-  readonly #inner: DCBORBoolPattern;
+  private readonly _inner: DCBORBoolPattern;
 
   private constructor(inner: DCBORBoolPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -67,15 +67,15 @@ export class BoolPattern implements Matcher {
    * Gets the underlying dcbor-pattern BoolPattern.
    */
   get inner(): DCBORBoolPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // For leaf envelopes, extract the CBOR and delegate to dcbor-pattern
-    const cbor = haystack.asLeaf();
+    const cbor = haystack.subject().asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborBoolPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborBoolPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -109,7 +109,7 @@ export class BoolPattern implements Matcher {
   }
 
   toString(): string {
-    return boolPatternDisplay(this.#inner);
+    return boolPatternDisplay(this._inner);
   }
 
   /**
@@ -117,11 +117,11 @@ export class BoolPattern implements Matcher {
    */
   equals(other: BoolPattern): boolean {
     // Compare by variant and value
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    if (this.#inner.variant === "Value" && other.#inner.variant === "Value") {
-      return this.#inner.value === other.#inner.value;
+    if (this._inner.variant === "Value" && other._inner.variant === "Value") {
+      return this._inner.value === other._inner.value;
     }
     return true;
   }
@@ -131,9 +131,9 @@ export class BoolPattern implements Matcher {
    */
   hashCode(): number {
     // Simple hash based on variant and value
-    let hash = this.#inner.variant === "Any" ? 0 : 1;
-    if (this.#inner.variant === "Value") {
-      hash = hash * 31 + (this.#inner.value ? 1 : 0);
+    let hash = this._inner.variant === "Any" ? 0 : 1;
+    if (this._inner.variant === "Value") {
+      hash = hash * 31 + (this._inner.value ? 1 : 0);
     }
     return hash;
   }

package/src/pattern/leaf/byte-string-pattern.ts

@@ -39,10 +39,10 @@ export function registerByteStringPatternFactory(
  * Corresponds to the Rust `ByteStringPattern` struct in byte_string_pattern.rs
  */
 export class ByteStringPattern implements Matcher {
-  readonly #inner: DCBORByteStringPattern;
+  private readonly _inner: DCBORByteStringPattern;
 
   private constructor(inner: DCBORByteStringPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -77,15 +77,15 @@ export class ByteStringPattern implements Matcher {
    * Gets the underlying dcbor-pattern ByteStringPattern.
    */
   get inner(): DCBORByteStringPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // For leaf envelopes, extract the CBOR and delegate to dcbor-pattern
-    const cbor = haystack.asLeaf();
+    const cbor = haystack.subject().asLeaf();
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const dcborPaths = dcborByteStringPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborByteStringPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -117,22 +117,22 @@ export class ByteStringPattern implements Matcher {
   }
 
   toString(): string {
-    return byteStringPatternDisplay(this.#inner);
+    return byteStringPatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: ByteStringPattern): boolean {
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return true;
       case "Value": {
-        const a = (this.#inner as { value: Uint8Array }).value;
-        const b = (other.#inner as { value: Uint8Array }).value;
+        const a = (this._inner as { value: Uint8Array }).value;
+        const b = (other._inner as { value: Uint8Array }).value;
         if (a.length !== b.length) return false;
         for (let i = 0; i < a.length; i++) {
           if (a[i] !== b[i]) return false;
@@ -141,8 +141,8 @@ export class ByteStringPattern implements Matcher {
       }
       case "BinaryRegex":
         return (
-          (this.#inner as { pattern: RegExp }).pattern.source ===
-          (other.#inner as { pattern: RegExp }).pattern.source
+          (this._inner as { pattern: RegExp }).pattern.source ===
+          (other._inner as { pattern: RegExp }).pattern.source
         );
     }
   }
@@ -152,19 +152,19 @@ export class ByteStringPattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         hash = 1;
         break;
       case "Value": {
-        const val = (this.#inner as { value: Uint8Array }).value;
+        const val = (this._inner as { value: Uint8Array }).value;
         for (const byte of val) {
           hash = hash * 31 + byte;
         }
         break;
       }
       case "BinaryRegex":
-        hash = 3 * 31 + (this.#inner as { pattern: RegExp }).pattern.source.length;
+        hash = 3 * 31 + (this._inner as { pattern: RegExp }).pattern.source.length;
         break;
     }
     return hash;

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

@@ -43,10 +43,10 @@ export type CBORPatternType =
  * Corresponds to the Rust `CBORPattern` enum in cbor_pattern.rs
  */
 export class CBORPattern implements Matcher {
-  readonly #pattern: CBORPatternType;
+  private readonly _pattern: CBORPatternType;
 
   private constructor(pattern: CBORPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -81,13 +81,13 @@ export class CBORPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): CBORPatternType {
-    return this.#pattern;
+    return this._pattern;
   }
 
   /**
    * Convert dcbor captures to envelope captures.
    */
-  #convertDcborCapturesToEnvelopeCaptures(
+  private _convertDcborCapturesToEnvelopeCaptures(
     dcborCaptures: Map<string, Cbor[][]>,
     baseEnvelope: Envelope,
     baseCbor: Cbor,
@@ -96,7 +96,7 @@ export class CBORPattern implements Matcher {
 
     for (const [captureName, dcborCapturePaths] of dcborCaptures) {
       const envelopeCapturePaths: Path[] = dcborCapturePaths.map((dcborPath) =>
-        this.#convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor),
+        this._convertDcborPathToEnvelopePath(dcborPath, baseEnvelope, baseCbor),
       );
       envelopeCaptures.set(captureName, envelopeCapturePaths);
     }
@@ -107,7 +107,7 @@ export class CBORPattern implements Matcher {
   /**
    * Convert a single dcbor path to an envelope path.
    */
-  #convertDcborPathToEnvelopePath(
+  private _convertDcborPathToEnvelopePath(
     dcborPath: Cbor[],
     baseEnvelope: Envelope,
     baseCbor: Cbor,
@@ -131,7 +131,7 @@ export class CBORPattern implements Matcher {
   /**
    * Collect capture names from a dcbor pattern.
    */
-  #collectDcborCaptureNames(dcborPattern: DCBORPattern, names: string[]): void {
+  private _collectDcborCaptureNames(dcborPattern: DCBORPattern, names: string[]): void {
     // Parse the pattern string to extract capture names
     const patternStr = dcborPatternDisplay(dcborPattern);
 
@@ -156,26 +156,26 @@ export class CBORPattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const envCase = haystack.case();
+    const envCase = haystack.subject().case();
 
     // Special case for KnownValue envelope
     if (envCase.type === "knownValue") {
       const knownValue = envCase.value;
       const knownValueCbor = knownValue.taggedCbor();
 
-      switch (this.#pattern.type) {
+      switch (this._pattern.type) {
         case "Any":
           return [[[haystack]], new Map<string, Path[]>()];
         case "Value": {
           // Compare using diagnostic representation
-          if (knownValueCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+          if (knownValueCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
             return [[[haystack]], new Map<string, Path[]>()];
           }
           return [[], new Map<string, Path[]>()];
         }
         case "Pattern": {
           const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-            this.#pattern.pattern,
+            this._pattern.pattern,
             knownValueCbor,
           );
 
@@ -193,7 +193,7 @@ export class CBORPattern implements Matcher {
               return extendedPath;
             });
 
-            const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+            const envelopeCaptures = this._convertDcborCapturesToEnvelopeCaptures(
               dcborCaptures,
               haystack,
               knownValueCbor,
@@ -206,25 +206,25 @@ export class CBORPattern implements Matcher {
     }
 
     // Standard case for CBOR leaf
-    const leafCbor = haystack.asLeaf();
+    const leafCbor = haystack.subject().asLeaf();
     if (leafCbor === undefined) {
       return [[], new Map<string, Path[]>()];
     }
 
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return [[[haystack]], new Map<string, Path[]>()];
 
       case "Value":
         // Compare using diagnostic representation
-        if (leafCbor.toDiagnostic() === this.#pattern.cbor.toDiagnostic()) {
+        if (leafCbor.toDiagnostic() === this._pattern.cbor.toDiagnostic()) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
 
       case "Pattern": {
         const { paths: dcborPaths, captures: dcborCaptures } = dcborPatternPathsWithCaptures(
-          this.#pattern.pattern,
+          this._pattern.pattern,
           leafCbor,
         );
 
@@ -245,7 +245,7 @@ export class CBORPattern implements Matcher {
             return extendedPath;
           });
 
-          const envelopeCaptures = this.#convertDcborCapturesToEnvelopeCaptures(
+          const envelopeCaptures = this._convertDcborCapturesToEnvelopeCaptures(
             dcborCaptures,
             haystack,
             leafCbor,
@@ -267,9 +267,9 @@ export class CBORPattern implements Matcher {
 
   compile(code: Instr[], literals: Pattern[], captures: string[]): void {
     // Register any capture names from this CBOR pattern
-    if (this.#pattern.type === "Pattern") {
+    if (this._pattern.type === "Pattern") {
       const captureNames: string[] = [];
-      this.#collectDcborCaptureNames(this.#pattern.pattern, captureNames);
+      this._collectDcborCaptureNames(this._pattern.pattern, captureNames);
       for (const name of captureNames) {
         if (!captures.includes(name)) {
           captures.push(name);
@@ -288,13 +288,13 @@ export class CBORPattern implements Matcher {
   }
 
   toString(): string {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return "cbor";
       case "Value":
-        return `cbor(${this.#pattern.cbor.toDiagnostic()})`;
+        return `cbor(${this._pattern.cbor.toDiagnostic()})`;
       case "Pattern":
-        return `cbor(/${dcborPatternDisplay(this.#pattern.pattern)}/)`;
+        return `cbor(/${dcborPatternDisplay(this._pattern.pattern)}/)`;
     }
   }
 
@@ -302,24 +302,24 @@ export class CBORPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: CBORPattern): 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 "Value":
         // Compare using diagnostic representation
         return (
-          this.#pattern.cbor.toDiagnostic() ===
-          (other.#pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
+          this._pattern.cbor.toDiagnostic() ===
+          (other._pattern as { type: "Value"; cbor: Cbor }).cbor.toDiagnostic()
         );
       case "Pattern":
         // Compare using display representation
         return (
-          dcborPatternDisplay(this.#pattern.pattern) ===
+          dcborPatternDisplay(this._pattern.pattern) ===
           dcborPatternDisplay(
-            (other.#pattern as { type: "Pattern"; pattern: DCBORPattern }).pattern,
+            (other._pattern as { type: "Pattern"; pattern: DCBORPattern }).pattern,
           )
         );
     }
@@ -329,15 +329,15 @@ export class CBORPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#pattern.type) {
+    switch (this._pattern.type) {
       case "Any":
         return 0;
       case "Value":
         // Simple hash based on diagnostic string
-        return simpleStringHash(this.#pattern.cbor.toDiagnostic());
+        return simpleStringHash(this._pattern.cbor.toDiagnostic());
       case "Pattern":
         // Simple hash based on display string
-        return simpleStringHash(dcborPatternDisplay(this.#pattern.pattern));
+        return simpleStringHash(dcborPatternDisplay(this._pattern.pattern));
     }
   }
 }