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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/envelope-pattern",
-  "version": "1.0.0-alpha.16",
+  "version": "1.0.0-alpha.18",
   "type": "module",
   "description": "Pattern matching for Gordian Envelope structures",
   "license": "BSD-2-Clause-Patent",
@@ -60,16 +60,16 @@
     "@bcts/eslint": "^0.1.0",
     "@bcts/tsconfig": "^0.1.0",
     "eslint": "^9.39.2",
-    "tsdown": "^0.18.4",
-    "typedoc": "^0.28.15",
+    "tsdown": "^0.20.1",
+    "typedoc": "^0.28.16",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@bcts/dcbor": "^1.0.0-alpha.16",
-    "@bcts/dcbor-parse": "^1.0.0-alpha.16",
-    "@bcts/dcbor-pattern": "^1.0.0-alpha.16",
-    "@bcts/envelope": "^1.0.0-alpha.16",
-    "@bcts/known-values": "^1.0.0-alpha.16"
+    "@bcts/dcbor": "^1.0.0-alpha.18",
+    "@bcts/dcbor-parse": "^1.0.0-alpha.18",
+    "@bcts/dcbor-pattern": "^1.0.0-alpha.18",
+    "@bcts/envelope": "^1.0.0-alpha.18",
+    "@bcts/known-values": "^1.0.0-alpha.18"
   }
 }

package/src/format.ts

@@ -97,15 +97,15 @@ export function defaultFormatPathsOpts(): FormatPathsOpts {
  * Builder for FormatPathsOpts.
  */
 export class FormatPathsOptsBuilder {
-  #indent = true;
-  #elementFormat: PathElementFormat = defaultPathElementFormat();
-  #lastElementOnly = false;
+  private _indent = true;
+  private _elementFormat: PathElementFormat = defaultPathElementFormat();
+  private _lastElementOnly = false;
 
   /**
    * Sets whether to indent each path element.
    */
   indent(indent: boolean): this {
-    this.#indent = indent;
+    this._indent = indent;
     return this;
   }
 
@@ -113,7 +113,7 @@ export class FormatPathsOptsBuilder {
    * Sets the format for each path element.
    */
   elementFormat(format: PathElementFormat): this {
-    this.#elementFormat = format;
+    this._elementFormat = format;
     return this;
   }
 
@@ -121,7 +121,7 @@ export class FormatPathsOptsBuilder {
    * Sets whether to format only the last element of each path.
    */
   lastElementOnly(lastElementOnly: boolean): this {
-    this.#lastElementOnly = lastElementOnly;
+    this._lastElementOnly = lastElementOnly;
     return this;
   }
 
@@ -130,9 +130,9 @@ export class FormatPathsOptsBuilder {
    */
   build(): FormatPathsOpts {
     return {
-      indent: this.#indent,
-      elementFormat: this.#elementFormat,
-      lastElementOnly: this.#lastElementOnly,
+      indent: this._indent,
+      elementFormat: this._elementFormat,
+      lastElementOnly: this._lastElementOnly,
     };
   }
 }
@@ -156,18 +156,37 @@ export function envelopeSummary(env: Envelope): string {
 
   let summary: string;
   switch (c.type) {
-    case "node":
-      summary = `NODE ${env.summary(Number.MAX_SAFE_INTEGER)}`;
+    case "node": {
+      const subjectSummary = env.subject().summary(Number.MAX_SAFE_INTEGER);
+      const assertions = env.assertions();
+      if (assertions.length > 0) {
+        const assertionSummaries = assertions.map((a) => {
+          const ac = a.case();
+          if (ac.type === "assertion") {
+            const pred = ac.assertion.predicate().summary(Number.MAX_SAFE_INTEGER);
+            const obj = ac.assertion.object().summary(Number.MAX_SAFE_INTEGER);
+            return `${pred}: ${obj}`;
+          }
+          return a.summary(Number.MAX_SAFE_INTEGER);
+        });
+        summary = `NODE ${subjectSummary} [ ${assertionSummaries.join(", ")} ]`;
+      } else {
+        summary = `NODE ${subjectSummary}`;
+      }
       break;
+    }
     case "leaf":
       summary = `LEAF ${env.summary(Number.MAX_SAFE_INTEGER)}`;
       break;
     case "wrapped":
       summary = `WRAPPED ${env.summary(Number.MAX_SAFE_INTEGER)}`;
       break;
-    case "assertion":
-      summary = `ASSERTION ${env.summary(Number.MAX_SAFE_INTEGER)}`;
+    case "assertion": {
+      const pred = c.assertion.predicate().summary(Number.MAX_SAFE_INTEGER);
+      const obj = c.assertion.object().summary(Number.MAX_SAFE_INTEGER);
+      summary = `ASSERTION ${pred}: ${obj}`;
       break;
+    }
     case "elided":
       summary = "ELIDED";
       break;

package/src/parse/index.ts

@@ -8,6 +8,7 @@
  */
 
 import { parse as parseDcborPattern } from "@bcts/dcbor-pattern";
+import { parseDcborItemPartial } from "@bcts/dcbor-parse";
 import { Lexer } from "./token";
 import {
   type Result,
@@ -37,10 +38,17 @@ import {
   byteString,
   anyDate,
   date,
+  dateRange,
+  dateEarliest,
+  dateLatest,
+  dateRegex,
   anyKnownValue,
   knownValue,
   anyArray,
   anyTag,
+  anyCbor,
+  cborValue,
+  cborPattern,
   nullPattern,
   // Structure pattern constructors
   leaf,
@@ -79,7 +87,6 @@ import {
   ByteStringPattern,
   KnownValuePattern,
   ArrayPattern,
-  TaggedPattern,
   DigestPattern,
   NodePattern,
   AssertionsPattern,
@@ -87,7 +94,6 @@ import {
   leafByteString,
   leafKnownValue,
   leafArray,
-  leafTag,
   structureDigest,
   structureNode,
   structureAssertions,
@@ -469,6 +475,7 @@ function parsePrimary(lexer: Lexer): Result<Pattern> {
     case "Comma":
     case "Ellipsis":
     case "Range":
+    case "Identifier":
       return err(unexpectedToken(token, span));
   }
 }
@@ -685,7 +692,50 @@ function parseTag(lexer: Lexer): Result<Pattern> {
  * Parse date content from date'...' pattern.
  */
 function parseDateContent(content: string, span: Span): Result<Pattern> {
-  // Try to parse as ISO date
+  // Check for regex syntax: /pattern/
+  if (content.startsWith("/") && content.endsWith("/")) {
+    const regexStr = content.slice(1, -1);
+    try {
+      return ok(dateRegex(new RegExp(regexStr)));
+    } catch {
+      return err(invalidRegex(span));
+    }
+  }
+
+  // Check for range syntax: date1...date2, date1..., ...date2
+  const rangeIdx = content.indexOf("...");
+  if (rangeIdx !== -1) {
+    const left = content.slice(0, rangeIdx).trim();
+    const right = content.slice(rangeIdx + 3).trim();
+
+    if (left.length === 0 && right.length > 0) {
+      // ...date2 → latest
+      const parsed = Date.parse(right);
+      if (isNaN(parsed)) return err({ type: "InvalidDateFormat", span });
+      return ok(dateLatest(CborDate.fromDatetime(new Date(parsed))));
+    }
+    if (left.length > 0 && right.length === 0) {
+      // date1... → earliest
+      const parsed = Date.parse(left);
+      if (isNaN(parsed)) return err({ type: "InvalidDateFormat", span });
+      return ok(dateEarliest(CborDate.fromDatetime(new Date(parsed))));
+    }
+    if (left.length > 0 && right.length > 0) {
+      // date1...date2 → range
+      const parsedStart = Date.parse(left);
+      const parsedEnd = Date.parse(right);
+      if (isNaN(parsedStart) || isNaN(parsedEnd)) return err({ type: "InvalidDateFormat", span });
+      return ok(
+        dateRange(
+          CborDate.fromDatetime(new Date(parsedStart)),
+          CborDate.fromDatetime(new Date(parsedEnd)),
+        ),
+      );
+    }
+    return err({ type: "InvalidDateFormat", span });
+  }
+
+  // Simple exact date
   const parsed = Date.parse(content);
   if (isNaN(parsed)) {
     return err({ type: "InvalidDateFormat", span });
@@ -713,17 +763,64 @@ function parseKnownValueContent(content: string): Result<Pattern> {
 
 /**
  * Parse CBOR pattern.
+ *
+ * Matches Rust parse_cbor: tries dcbor-pattern regex first (/keyword/),
+ * then CBOR diagnostic notation via parseDcborItemPartial, then falls
+ * back to parseOr for envelope pattern expressions.
  */
 function parseCbor(lexer: Lexer): Result<Pattern> {
   // Check for optional content in parentheses
   const next = lexer.peekToken();
   if (next?.token.type !== "ParenOpen") {
-    return ok(patternLeaf(leafTag(TaggedPattern.any()))); // cbor matches any CBOR
+    return ok(anyCbor()); // cbor matches any CBOR value
   }
 
   lexer.next(); // consume (
 
-  // Parse inner content - this is a dcbor-pattern expression
+  // Check for dcbor-pattern regex syntax: cbor(/keyword/)
+  // Use peek() (character-level, non-destructive) instead of peekToken()
+  // to avoid the lexer advancing past the CBOR content.
+  if (lexer.peek() === "/") {
+    const regexTokenResult = lexer.next(); // tokenize /pattern/
+    if (regexTokenResult?.token.type === "Regex") {
+      const regexToken = regexTokenResult.token;
+      if (!regexToken.value.ok) return err(regexToken.value.error);
+      const keyword = regexToken.value.value;
+
+      // Parse the keyword as a dcbor-pattern expression
+      const dcborResult = parseDcborPattern(keyword);
+      if (!dcborResult.ok) {
+        return err(unexpectedToken(regexToken, regexTokenResult.span));
+      }
+
+      const close = lexer.next();
+      if (close?.token.type !== "ParenClose") {
+        return err({ type: "ExpectedCloseParen", span: lexer.span() });
+      }
+
+      return ok(cborPattern(dcborResult.value));
+    }
+  }
+
+  // Try to parse inner content as CBOR diagnostic notation
+  // (matching Rust utils::parse_cbor_inner which calls parse_dcbor_item_partial)
+  const remaining = lexer.remainder();
+  const cborResult = parseDcborItemPartial(remaining);
+  if (cborResult.ok) {
+    const [cborData, consumed] = cborResult.value;
+    lexer.bump(consumed);
+    // Skip whitespace before closing paren
+    while (lexer.peek() === " " || lexer.peek() === "\t" || lexer.peek() === "\n") {
+      lexer.bump(1);
+    }
+    const close = lexer.next();
+    if (close?.token.type !== "ParenClose") {
+      return err({ type: "ExpectedCloseParen", span: lexer.span() });
+    }
+    return ok(cborValue(cborData));
+  }
+
+  // Fallback: try parsing as a regular pattern expression
   const inner = parseOr(lexer);
   if (!inner.ok) return inner;
 
@@ -746,6 +843,24 @@ function parseNode(lexer: Lexer): Result<Pattern> {
   }
 
   lexer.next(); // consume (
+
+  // Check for assertion count range: node({n,m}), node({n}), node({n,})
+  const afterParen = lexer.peekToken();
+  if (afterParen?.token.type === "Range") {
+    lexer.next(); // consume Range token
+    const rangeToken = afterParen.token;
+    if (!rangeToken.value.ok) return err(rangeToken.value.error);
+    const quantifier = rangeToken.value.value;
+    const interval = quantifier.interval();
+
+    const close = lexer.next();
+    if (close?.token.type !== "ParenClose") {
+      return err({ type: "ExpectedCloseParen", span: lexer.span() });
+    }
+
+    return ok(patternStructure(structureNode(NodePattern.fromInterval(interval))));
+  }
+
   const inner = parseOr(lexer);
   if (!inner.ok) return inner;
 
@@ -847,6 +962,24 @@ function parseDigest(lexer: Lexer): Result<Pattern> {
     return ok(digestPrefix(digestToken.token.value.value));
   }
 
+  // Accept raw hex string identifiers: digest(a1b2c3)
+  if (digestToken.token.type === "Identifier") {
+    const hexStr = digestToken.token.value;
+    // Validate hex string: must be even length and all hex digits
+    if (hexStr.length === 0 || hexStr.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(hexStr)) {
+      return err({ type: "InvalidHexString", span: digestToken.span });
+    }
+    const bytes = new Uint8Array(hexStr.length / 2);
+    for (let i = 0; i < hexStr.length; i += 2) {
+      bytes[i / 2] = Number.parseInt(hexStr.slice(i, i + 2), 16);
+    }
+    const close = lexer.next();
+    if (close?.token.type !== "ParenClose") {
+      return err({ type: "ExpectedCloseParen", span: lexer.span() });
+    }
+    return ok(digestPrefix(bytes));
+  }
+
   return err(unexpectedToken(digestToken.token, digestToken.span));
 }
 

package/src/parse/token.ts

@@ -99,7 +99,8 @@ export type Token =
   | { readonly type: "DatePattern"; readonly value: Result<string> }
   | { readonly type: "Range"; readonly value: Result<Quantifier> }
   | { readonly type: "SingleQuotedPattern"; readonly value: Result<string> }
-  | { readonly type: "SingleQuotedRegex"; readonly value: Result<string> };
+  | { readonly type: "SingleQuotedRegex"; readonly value: Result<string> }
+  | { readonly type: "Identifier"; readonly value: string };
 
 /**
  * Keyword to token type mapping.
@@ -183,31 +184,31 @@ function isHexDigit(ch: string): boolean {
  * Lexer for Gordian Envelope pattern syntax.
  */
 export class Lexer {
-  readonly #source: string;
-  #position = 0;
-  #tokenStart = 0;
-  #peekedToken: { token: Token; span: Span } | undefined = undefined;
+  private readonly _source: string;
+  private _position = 0;
+  private _tokenStart = 0;
+  private _peekedToken: { token: Token; span: Span } | undefined = undefined;
 
   constructor(source: string) {
-    this.#source = source;
+    this._source = source;
   }
 
   /**
    * Gets the current position in the source.
    */
   get position(): number {
-    return this.#position;
+    return this._position;
   }
 
   /**
    * Peeks at the next token without consuming it.
    */
   peekToken(): { token: Token; span: Span } | undefined {
-    if (this.#peekedToken !== undefined) {
-      return this.#peekedToken;
+    if (this._peekedToken !== undefined) {
+      return this._peekedToken;
     }
     const result = this.next();
-    this.#peekedToken = result;
+    this._peekedToken = result;
     return result;
   }
 
@@ -215,51 +216,51 @@ export class Lexer {
    * Gets the current span (from token start to current position).
    */
   span(): Span {
-    return { start: this.#tokenStart, end: this.#position };
+    return { start: this._tokenStart, end: this._position };
   }
 
   /**
    * Gets the remaining source string.
    */
   remainder(): string {
-    return this.#source.slice(this.#position);
+    return this._source.slice(this._position);
   }
 
   /**
    * Peeks at the current character without consuming it.
    */
   peek(): string | undefined {
-    if (this.#position >= this.#source.length) {
+    if (this._position >= this._source.length) {
       return undefined;
     }
-    return this.#source[this.#position];
+    return this._source[this._position];
   }
 
   /**
    * Peeks at the next character without consuming current.
    */
   peekNext(): string | undefined {
-    if (this.#position + 1 >= this.#source.length) {
+    if (this._position + 1 >= this._source.length) {
       return undefined;
     }
-    return this.#source[this.#position + 1];
+    return this._source[this._position + 1];
   }
 
   /**
    * Advances the position by n characters.
    */
   bump(n = 1): void {
-    this.#position = Math.min(this.#position + n, this.#source.length);
+    this._position = Math.min(this._position + n, this._source.length);
   }
 
   /**
    * Skips whitespace.
    */
-  #skipWhitespace(): void {
-    while (this.#position < this.#source.length) {
-      const ch = this.#source[this.#position];
+  private _skipWhitespace(): void {
+    while (this._position < this._source.length) {
+      const ch = this._source[this._position];
       if (ch !== undefined && isWhitespace(ch)) {
-        this.#position++;
+        this._position++;
       } else {
         break;
       }
@@ -269,7 +270,7 @@ export class Lexer {
   /**
    * Parses a string literal (after the opening quote).
    */
-  #parseStringLiteral(): Result<string> {
+  private _parseStringLiteral(): Result<string> {
     const src = this.remainder();
     let escape = false;
     let content = "";
@@ -323,7 +324,7 @@ export class Lexer {
   /**
    * Parses a regex pattern (after the opening slash).
    */
-  #parseRegex(): Result<string> {
+  private _parseRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -358,7 +359,7 @@ export class Lexer {
   /**
    * Parses a hex pattern (after h').
    */
-  #parseHexPattern(): Result<Uint8Array> {
+  private _parseHexPattern(): Result<Uint8Array> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -397,7 +398,7 @@ export class Lexer {
   /**
    * Parses a hex binary regex (after h'/).
    */
-  #parseHexBinaryRegex(): Result<string> {
+  private _parseHexBinaryRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -436,7 +437,7 @@ export class Lexer {
   /**
    * Parses a date pattern (after date').
    */
-  #parseDatePattern(): Result<string> {
+  private _parseDatePattern(): Result<string> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -455,7 +456,7 @@ export class Lexer {
   /**
    * Parses a range pattern (after {).
    */
-  #parseRange(): Result<Quantifier> {
+  private _parseRange(): Result<Quantifier> {
     const src = this.remainder();
     let pos = 0;
 
@@ -554,7 +555,7 @@ export class Lexer {
   /**
    * Parses a single quoted pattern (after ').
    */
-  #parseSingleQuotedPattern(): Result<string> {
+  private _parseSingleQuotedPattern(): Result<string> {
     const src = this.remainder();
 
     for (let i = 0; i < src.length; i++) {
@@ -573,7 +574,7 @@ export class Lexer {
   /**
    * Parses a single quoted regex (after '/).
    */
-  #parseSingleQuotedRegex(): Result<string> {
+  private _parseSingleQuotedRegex(): Result<string> {
     const src = this.remainder();
     let escape = false;
 
@@ -612,8 +613,8 @@ export class Lexer {
   /**
    * Parses a number (integer or float).
    */
-  #parseNumber(): Token {
-    const startPos = this.#position;
+  private _parseNumber(): Token {
+    const startPos = this._position;
     let isFloat = false;
     let isNegative = false;
 
@@ -662,7 +663,7 @@ export class Lexer {
       }
     }
 
-    const numStr = this.#source.slice(startPos, this.#position);
+    const numStr = this._source.slice(startPos, this._position);
 
     if (isFloat) {
       const value = parseFloat(numStr);
@@ -688,25 +689,25 @@ export class Lexer {
    */
   next(): { token: Token; span: Span } | undefined {
     // Return peeked token if available
-    if (this.#peekedToken !== undefined) {
-      const peeked = this.#peekedToken;
-      this.#peekedToken = undefined;
+    if (this._peekedToken !== undefined) {
+      const peeked = this._peekedToken;
+      this._peekedToken = undefined;
       return peeked;
     }
 
-    this.#skipWhitespace();
-    this.#tokenStart = this.#position;
+    this._skipWhitespace();
+    this._tokenStart = this._position;
 
-    if (this.#position >= this.#source.length) {
+    if (this._position >= this._source.length) {
       return undefined;
     }
 
-    const ch = this.#source[this.#position];
+    const ch = this._source[this._position];
     if (ch === undefined) return undefined;
 
     // Check for two-character operators first
-    const twoChar = this.#source.slice(this.#position, this.#position + 2);
-    const threeChar = this.#source.slice(this.#position, this.#position + 3);
+    const twoChar = this._source.slice(this._position, this._position + 2);
+    const threeChar = this._source.slice(this._position, this._position + 3);
 
     // Check for ... (ellipsis)
     if (threeChar === "...") {
@@ -715,7 +716,7 @@ export class Lexer {
     }
 
     // Check for -Infinity
-    if (this.#source.slice(this.#position, this.#position + 9) === "-Infinity") {
+    if (this._source.slice(this._position, this._position + 9) === "-Infinity") {
       this.bump(9);
       return { token: { type: "NegativeInfinity" }, span: this.span() };
     }
@@ -755,16 +756,16 @@ export class Lexer {
         if (this.peek() === "/") {
           this.bump(1);
           return {
-            token: { type: "HexBinaryRegex", value: this.#parseHexBinaryRegex() },
+            token: { type: "HexBinaryRegex", value: this._parseHexBinaryRegex() },
             span: this.span(),
           };
         }
-        return { token: { type: "HexPattern", value: this.#parseHexPattern() }, span: this.span() };
+        return { token: { type: "HexPattern", value: this._parseHexPattern() }, span: this.span() };
       }
       case "'/":
         this.bump(2);
         return {
-          token: { type: "SingleQuotedRegex", value: this.#parseSingleQuotedRegex() },
+          token: { type: "SingleQuotedRegex", value: this._parseSingleQuotedRegex() },
           span: this.span(),
         };
     }
@@ -813,25 +814,25 @@ export class Lexer {
       case '"':
         this.bump(1);
         return {
-          token: { type: "StringLiteral", value: this.#parseStringLiteral() },
+          token: { type: "StringLiteral", value: this._parseStringLiteral() },
           span: this.span(),
         };
       case "/":
         this.bump(1);
-        return { token: { type: "Regex", value: this.#parseRegex() }, span: this.span() };
+        return { token: { type: "Regex", value: this._parseRegex() }, span: this.span() };
       case "{":
         this.bump(1);
-        return { token: { type: "Range", value: this.#parseRange() }, span: this.span() };
+        return { token: { type: "Range", value: this._parseRange() }, span: this.span() };
       case "'":
         this.bump(1);
         return {
-          token: { type: "SingleQuotedPattern", value: this.#parseSingleQuotedPattern() },
+          token: { type: "SingleQuotedPattern", value: this._parseSingleQuotedPattern() },
           span: this.span(),
         };
       case "@": {
         // Group name
         this.bump(1);
-        const start = this.#position;
+        const start = this._position;
         let gc = this.peek();
         if (gc !== undefined && isIdentStart(gc)) {
           gc = this.peek();
@@ -839,7 +840,7 @@ export class Lexer {
             this.bump(1);
             gc = this.peek();
           }
-          const name = this.#source.slice(start, this.#position);
+          const name = this._source.slice(start, this._position);
           return { token: { type: "GroupName", name }, span: this.span() };
         }
         // Invalid group name, return as error token
@@ -848,26 +849,26 @@ export class Lexer {
     }
 
     // Check for date' pattern
-    if (this.#source.slice(this.#position, this.#position + 5) === "date'") {
+    if (this._source.slice(this._position, this._position + 5) === "date'") {
       this.bump(5);
-      return { token: { type: "DatePattern", value: this.#parseDatePattern() }, span: this.span() };
+      return { token: { type: "DatePattern", value: this._parseDatePattern() }, span: this.span() };
     }
 
     // Check for number (including negative)
     const nextChar = this.peekNext();
     if (isDigit(ch) || (ch === "-" && nextChar !== undefined && isDigit(nextChar))) {
-      return { token: this.#parseNumber(), span: this.span() };
+      return { token: this._parseNumber(), span: this.span() };
     }
 
     // Check for identifier/keyword
     if (isIdentStart(ch)) {
-      const start = this.#position;
+      const start = this._position;
       let ic = this.peek();
       while (ic !== undefined && isIdentContinue(ic)) {
         this.bump(1);
         ic = this.peek();
       }
-      const ident = this.#source.slice(start, this.#position);
+      const ident = this._source.slice(start, this._position);
 
       // Check for keywords
       const keyword = KEYWORDS.get(ident);
@@ -875,8 +876,8 @@ export class Lexer {
         return { token: keyword, span: this.span() };
       }
 
-      // Unknown identifier - treat as error
-      return undefined;
+      // Unknown identifier - return as Identifier token
+      return { token: { type: "Identifier", value: ident }, span: this.span() };
     }
 
     // Unknown character