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

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

@@ -42,10 +42,10 @@ export function registerDatePatternFactory(factory: (pattern: DatePattern) => Pa
  * Corresponds to the Rust `DatePattern` struct in date_pattern.rs
  */
 export class DatePattern implements Matcher {
-  readonly #inner: DCBORDatePattern;
+  private readonly _inner: DCBORDatePattern;
 
   private constructor(inner: DCBORDatePattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -109,15 +109,15 @@ export class DatePattern implements Matcher {
    * Gets the underlying dcbor-pattern DatePattern.
    */
   get inner(): DCBORDatePattern {
-    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 = dcborDatePatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborDatePatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -149,18 +149,18 @@ export class DatePattern implements Matcher {
   }
 
   toString(): string {
-    return datePatternDisplay(this.#inner);
+    return datePatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: DatePattern): boolean {
-    if (this.#inner.variant !== other.#inner.variant) {
+    if (this._inner.variant !== other._inner.variant) {
       return false;
     }
     // Simplified equality - compare variant names
-    return JSON.stringify(this.#inner) === JSON.stringify(other.#inner);
+    return JSON.stringify(this._inner) === JSON.stringify(other._inner);
   }
 
   /**
@@ -169,7 +169,7 @@ export class DatePattern implements Matcher {
   hashCode(): number {
     // Simple hash based on variant
     let hash = 0;
-    const str = this.#inner.variant;
+    const str = this._inner.variant;
     for (let i = 0; i < str.length; i++) {
       hash = hash * 31 + str.charCodeAt(i);
     }

package/src/pattern/leaf/index.ts

@@ -141,8 +141,7 @@ export function leafPatternPathsWithCaptures(
 ): [Path[], Map<string, Path[]>] {
   switch (pattern.type) {
     case "Cbor":
-      // CBOR patterns from dcbor-pattern need special handling
-      return [[], new Map<string, Path[]>()];
+      return pattern.pattern.pathsWithCaptures(haystack);
     case "Number":
       return pattern.pattern.pathsWithCaptures(haystack);
     case "Text":

package/src/pattern/leaf/known-value-pattern.ts

@@ -41,10 +41,10 @@ export function registerKnownValuePatternFactory(
  * Corresponds to the Rust `KnownValuePattern` struct in known_value_pattern.rs
  */
 export class KnownValuePattern implements Matcher {
-  readonly #inner: DCBORKnownValuePattern;
+  private readonly _inner: DCBORKnownValuePattern;
 
   private constructor(inner: DCBORKnownValuePattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -86,25 +86,26 @@ export class KnownValuePattern implements Matcher {
    * Gets the underlying dcbor-pattern KnownValuePattern.
    */
   get inner(): DCBORKnownValuePattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    // Check if the envelope is a known value via case()
-    const envCase = haystack.case();
+    // Check if the envelope subject is a known value via case()
+    const subject = haystack.subject();
+    const envCase = subject.case();
 
     if (envCase.type === "knownValue") {
       // Get the KnownValue and create CBOR for pattern matching
       const knownValueCbor = envCase.value.taggedCbor();
-      if (knownValuePatternMatches(this.#inner, knownValueCbor)) {
+      if (knownValuePatternMatches(this._inner, knownValueCbor)) {
         return [[[haystack]], new Map<string, Path[]>()];
       }
     }
 
     // Also try matching as a leaf (for tagged CBOR containing known values)
-    const leafCbor = haystack.asLeaf();
+    const leafCbor = subject.asLeaf();
     if (leafCbor !== undefined) {
-      if (knownValuePatternMatches(this.#inner, leafCbor)) {
+      if (knownValuePatternMatches(this._inner, leafCbor)) {
         return [[[haystack]], new Map<string, Path[]>()];
       }
     }
@@ -132,7 +133,7 @@ export class KnownValuePattern implements Matcher {
   }
 
   toString(): string {
-    return knownValuePatternDisplay(this.#inner);
+    return knownValuePatternDisplay(this._inner);
   }
 
   /**
@@ -140,23 +141,23 @@ export class KnownValuePattern implements Matcher {
    */
   equals(other: KnownValuePattern): boolean {
     // Compare by variant type and values
-    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":
         return (
-          this.#inner.value.valueBigInt() ===
-          (other.#inner as { variant: "Value"; value: KnownValue }).value.valueBigInt()
+          this._inner.value.valueBigInt() ===
+          (other._inner as { variant: "Value"; value: KnownValue }).value.valueBigInt()
         );
       case "Named":
-        return this.#inner.name === (other.#inner as { variant: "Named"; name: string }).name;
+        return this._inner.name === (other._inner as { variant: "Named"; name: string }).name;
       case "Regex":
         return (
-          this.#inner.pattern.source ===
-          (other.#inner as { variant: "Regex"; pattern: RegExp }).pattern.source
+          this._inner.pattern.source ===
+          (other._inner as { variant: "Regex"; pattern: RegExp }).pattern.source
         );
     }
   }
@@ -165,15 +166,15 @@ export class KnownValuePattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return 0;
       case "Value":
-        return Number(this.#inner.value.valueBigInt() & BigInt(0xffffffff));
+        return Number(this._inner.value.valueBigInt() & BigInt(0xffffffff));
       case "Named":
-        return simpleStringHash(this.#inner.name);
+        return simpleStringHash(this._inner.name);
       case "Regex":
-        return simpleStringHash(this.#inner.pattern.source);
+        return simpleStringHash(this._inner.pattern.source);
     }
   }
 }

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

@@ -37,10 +37,10 @@ export type MapPatternType =
  * Corresponds to the Rust `MapPattern` struct in map_pattern.rs
  */
 export class MapPattern implements Matcher {
-  readonly #pattern: MapPatternType;
+  private readonly _pattern: MapPatternType;
 
   private constructor(pattern: MapPatternType) {
-    this.#pattern = pattern;
+    this._pattern = pattern;
   }
 
   /**
@@ -62,12 +62,12 @@ export class MapPattern implements Matcher {
    * Gets the pattern type.
    */
   get pattern(): MapPatternType {
-    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[]>()];
     }
@@ -78,13 +78,13 @@ export class MapPattern 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 size = map.size;
-        if (this.#pattern.interval.contains(size)) {
+        if (this._pattern.interval.contains(size)) {
           return [[[haystack]], new Map<string, Path[]>()];
         }
         return [[], new Map<string, Path[]>()];
@@ -112,11 +112,11 @@ export class MapPattern 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()}}}`;
     }
   }
 
@@ -124,15 +124,15 @@ export class MapPattern implements Matcher {
    * Equality comparison.
    */
   equals(other: MapPattern): 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,
         );
     }
   }
@@ -141,12 +141,12 @@ export class MapPattern 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 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);
     }
   }
 }

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

@@ -34,34 +34,34 @@ export function registerNullPatternFactory(factory: (pattern: NullPattern) => Pa
  * Corresponds to the Rust `NullPattern` struct in null_pattern.rs
  */
 export class NullPattern implements Matcher {
-  readonly #inner: DCBORNullPattern;
-  static readonly #instance = new NullPattern();
+  private readonly _inner: DCBORNullPattern;
+  private static readonly _instance = new NullPattern();
 
   private constructor() {
     // Create the NullPattern directly - it's just { variant: "Null" }
-    this.#inner = { variant: "Null" };
+    this._inner = { variant: "Null" };
   }
 
   /**
    * Creates a new NullPattern (returns singleton).
    */
   static new(): NullPattern {
-    return NullPattern.#instance;
+    return NullPattern._instance;
   }
 
   /**
    * Gets the underlying dcbor-pattern NullPattern.
    */
   get inner(): DCBORNullPattern {
-    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 = dcborNullPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborNullPatternPaths(this._inner, cbor);
 
       if (dcborPaths.length > 0) {
         return [[[haystack]], new Map<string, Path[]>()];
@@ -91,7 +91,7 @@ export class NullPattern implements Matcher {
   }
 
   toString(): string {
-    return nullPatternDisplay(this.#inner);
+    return nullPatternDisplay(this._inner);
   }
 
   /**

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

@@ -44,10 +44,10 @@ export function registerNumberPatternFactory(factory: (pattern: NumberPattern) =
  * Corresponds to the Rust `NumberPattern` struct in number_pattern.rs
  */
 export class NumberPattern implements Matcher {
-  readonly #inner: DCBORNumberPattern;
+  private readonly _inner: DCBORNumberPattern;
 
   private constructor(inner: DCBORNumberPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -131,15 +131,15 @@ export class NumberPattern implements Matcher {
    * Gets the underlying dcbor-pattern NumberPattern.
    */
   get inner(): DCBORNumberPattern {
-    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 = dcborNumberPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborNumberPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -171,7 +171,7 @@ export class NumberPattern implements Matcher {
   }
 
   toString(): string {
-    return numberPatternDisplay(this.#inner);
+    return numberPatternDisplay(this._inner);
   }
 
   /**
@@ -179,10 +179,10 @@ export class NumberPattern implements Matcher {
    */
   equals(other: NumberPattern): boolean {
     // Compare by variant and values
-    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":
       case "NaN":
       case "Infinity":
@@ -194,14 +194,14 @@ export class NumberPattern implements Matcher {
       case "LessThan":
       case "LessThanOrEqual":
         return (
-          (this.#inner as { value: number }).value === (other.#inner as { value: number }).value
+          (this._inner as { value: number }).value === (other._inner as { value: number }).value
         );
       case "Range":
         return (
-          (this.#inner as { min: number; max: number }).min ===
-            (other.#inner as { min: number; max: number }).min &&
-          (this.#inner as { min: number; max: number }).max ===
-            (other.#inner as { min: number; max: number }).max
+          (this._inner as { min: number; max: number }).min ===
+            (other._inner as { min: number; max: number }).min &&
+          (this._inner as { min: number; max: number }).max ===
+            (other._inner as { min: number; max: number }).max
         );
     }
   }
@@ -211,27 +211,27 @@ export class NumberPattern implements Matcher {
    */
   hashCode(): number {
     let hash = 0;
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         hash = 1;
         break;
       case "Value":
-        hash = 2 * 31 + (this.#inner as { value: number }).value;
+        hash = 2 * 31 + (this._inner as { value: number }).value;
         break;
       case "Range":
-        hash = 3 * 31 + (this.#inner as { min: number }).min + (this.#inner as { max: number }).max;
+        hash = 3 * 31 + (this._inner as { min: number }).min + (this._inner as { max: number }).max;
         break;
       case "GreaterThan":
-        hash = 4 * 31 + (this.#inner as { value: number }).value;
+        hash = 4 * 31 + (this._inner as { value: number }).value;
         break;
       case "GreaterThanOrEqual":
-        hash = 5 * 31 + (this.#inner as { value: number }).value;
+        hash = 5 * 31 + (this._inner as { value: number }).value;
         break;
       case "LessThan":
-        hash = 6 * 31 + (this.#inner as { value: number }).value;
+        hash = 6 * 31 + (this._inner as { value: number }).value;
         break;
       case "LessThanOrEqual":
-        hash = 7 * 31 + (this.#inner as { value: number }).value;
+        hash = 7 * 31 + (this._inner as { value: number }).value;
         break;
       case "NaN":
         hash = 8;

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

@@ -41,10 +41,10 @@ export function registerTaggedPatternFactory(factory: (pattern: TaggedPattern) =
  * Corresponds to the Rust `TaggedPattern` struct in tagged_pattern.rs
  */
 export class TaggedPattern implements Matcher {
-  readonly #inner: DCBORTaggedPattern;
+  private readonly _inner: DCBORTaggedPattern;
 
   private constructor(inner: DCBORTaggedPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -86,7 +86,7 @@ export class TaggedPattern implements Matcher {
    * Gets the underlying dcbor-pattern TaggedPattern.
    */
   get inner(): DCBORTaggedPattern {
-    return this.#inner;
+    return this._inner;
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
@@ -96,7 +96,7 @@ export class TaggedPattern implements Matcher {
 
     if (cbor !== undefined) {
       // Delegate to dcbor-pattern for CBOR matching
-      const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this.#inner, cbor);
+      const [dcborPaths, dcborCaptures] = taggedPatternPathsWithCaptures(this._inner, cbor);
 
       if (dcborPaths.length > 0) {
         // Convert dcbor paths to envelope paths
@@ -155,7 +155,7 @@ export class TaggedPattern implements Matcher {
   }
 
   toString(): string {
-    return taggedPatternDisplay(this.#inner, patternDisplay);
+    return taggedPatternDisplay(this._inner, patternDisplay);
   }
 
   /**
@@ -163,35 +163,35 @@ export class TaggedPattern implements Matcher {
    */
   equals(other: TaggedPattern): boolean {
     // Compare by variant type and values
-    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 "Tag": {
-        const otherTag = other.#inner as { variant: "Tag"; tag: Tag; pattern: DCBORPattern };
+        const otherTag = other._inner as { variant: "Tag"; tag: Tag; pattern: DCBORPattern };
         return (
-          this.#inner.tag.value === otherTag.tag.value &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherTag.pattern)
+          this._inner.tag.value === otherTag.tag.value &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherTag.pattern)
         );
       }
       case "Name": {
-        const otherName = other.#inner as { variant: "Name"; name: string; pattern: DCBORPattern };
+        const otherName = other._inner as { variant: "Name"; name: string; pattern: DCBORPattern };
         return (
-          this.#inner.name === otherName.name &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherName.pattern)
+          this._inner.name === otherName.name &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherName.pattern)
         );
       }
       case "Regex": {
-        const otherRegex = other.#inner as {
+        const otherRegex = other._inner as {
           variant: "Regex";
           regex: RegExp;
           pattern: DCBORPattern;
         };
         return (
-          this.#inner.regex.source === otherRegex.regex.source &&
-          patternDisplay(this.#inner.pattern) === patternDisplay(otherRegex.pattern)
+          this._inner.regex.source === otherRegex.regex.source &&
+          patternDisplay(this._inner.pattern) === patternDisplay(otherRegex.pattern)
         );
       }
     }
@@ -201,15 +201,15 @@ export class TaggedPattern implements Matcher {
    * Hash code for use in Maps/Sets.
    */
   hashCode(): number {
-    switch (this.#inner.variant) {
+    switch (this._inner.variant) {
       case "Any":
         return 0;
       case "Tag":
-        return Number(BigInt(this.#inner.tag.value) & BigInt(0xffffffff));
+        return Number(BigInt(this._inner.tag.value) & BigInt(0xffffffff));
       case "Name":
-        return simpleStringHash(this.#inner.name);
+        return simpleStringHash(this._inner.name);
       case "Regex":
-        return simpleStringHash(this.#inner.regex.source);
+        return simpleStringHash(this._inner.regex.source);
     }
   }
 }

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

@@ -37,10 +37,10 @@ export function registerTextPatternFactory(factory: (pattern: TextPattern) => Pa
  * Corresponds to the Rust `TextPattern` struct in text_pattern.rs
  */
 export class TextPattern implements Matcher {
-  readonly #inner: DCBORTextPattern;
+  private readonly _inner: DCBORTextPattern;
 
   private constructor(inner: DCBORTextPattern) {
-    this.#inner = inner;
+    this._inner = inner;
   }
 
   /**
@@ -75,15 +75,15 @@ export class TextPattern implements Matcher {
    * Gets the underlying dcbor-pattern TextPattern.
    */
   get inner(): DCBORTextPattern {
-    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 = dcborTextPatternPaths(this.#inner, cbor);
+      const dcborPaths = dcborTextPatternPaths(this._inner, cbor);
 
       // For simple leaf patterns, if dcbor-pattern found matches, return the envelope
       if (dcborPaths.length > 0) {
@@ -115,27 +115,27 @@ export class TextPattern implements Matcher {
   }
 
   toString(): string {
-    return textPatternDisplay(this.#inner);
+    return textPatternDisplay(this._inner);
   }
 
   /**
    * Equality comparison.
    */
   equals(other: TextPattern): 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":
         return (
-          (this.#inner as { value: string }).value === (other.#inner as { value: string }).value
+          (this._inner as { value: string }).value === (other._inner as { value: string }).value
         );
       case "Regex":
         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
         );
     }
   }
@@ -145,19 +145,19 @@ export class TextPattern 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: string }).value;
+        const val = (this._inner as { value: string }).value;
         for (let i = 0; i < val.length; i++) {
           hash = hash * 31 + val.charCodeAt(i);
         }
         break;
       }
       case "Regex":
-        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;