@bcts/envelope-pattern 1.0.0-alpha.12 → 1.0.0-alpha.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/envelope-pattern",
-  "version": "1.0.0-alpha.12",
+  "version": "1.0.0-alpha.14",
   "type": "module",
   "description": "Pattern matching for Gordian Envelope structures",
   "license": "BSD-2-Clause-Patent",
@@ -58,8 +58,8 @@
     "node": ">=18.0.0"
   },
   "devDependencies": {
-    "@bcts/eslint": "workspace:*",
-    "@bcts/tsconfig": "workspace:*",
+    "@bcts/eslint": "^0.1.0",
+    "@bcts/tsconfig": "^0.1.0",
     "eslint": "^9.39.2",
     "tsdown": "^0.18.3",
     "typedoc": "^0.28.15",
@@ -67,11 +67,10 @@
     "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@bcts/dcbor": "workspace:*",
-    "@bcts/dcbor-pattern": "workspace:*",
-    "@bcts/envelope": "workspace:*",
-    "@bcts/components": "workspace:*",
-    "@bcts/tags": "workspace:*",
-    "@bcts/known-values": "workspace:*"
+    "@bcts/dcbor": "^1.0.0-alpha.14",
+    "@bcts/dcbor-parse": "^1.0.0-alpha.14",
+    "@bcts/dcbor-pattern": "^1.0.0-alpha.14",
+    "@bcts/envelope": "^1.0.0-alpha.14",
+    "@bcts/known-values": "^1.0.0-alpha.14"
   }
 }

package/src/parse/utils.ts

@@ -7,13 +7,8 @@
  */
 
 import type { Cbor } from "@bcts/dcbor";
+import { parseDcborItemPartial } from "@bcts/dcbor-parse";
 import { type Pattern as DCBORPattern, parse as parseDcborPattern } from "@bcts/dcbor-pattern";
-
-// Stub for cborFromDiagnostic - not implemented in dcbor yet
-function cborFromDiagnostic(_src: string): { ok: true; value: Cbor } | { ok: false } {
-  // TODO: Implement when dcbor adds diagnostic notation parsing
-  return { ok: false };
-}
 import {
   type Result,
   ok,
@@ -175,20 +170,24 @@ export function parseCborInner(src: string): Result<[Pattern, number]> {
 
   // Check if this is a UR (ur:type/value)
   if (src.slice(pos.value, pos.value + 3) === "ur:") {
-    // For now, parse as CBOR diagnostic notation
-    // TODO: Add proper UR parsing when available
+    // Parse as UR and convert to CBOR
+    const remaining = src.slice(pos.value);
+    const parseResult = parseDcborItemPartial(remaining);
+    if (!parseResult.ok) {
+      return err(unknown());
+    }
+    const [cborValue, consumed] = parseResult.value;
+    return ok([createCborPattern(cborValue), pos.value + consumed]);
   }
 
   // Default: parse as CBOR diagnostic notation
   const remaining = src.slice(pos.value);
-  const cborResult = cborFromDiagnostic(remaining);
-  if (!cborResult.ok) {
+  const parseResult = parseDcborItemPartial(remaining);
+  if (!parseResult.ok) {
     return err(unknown());
   }
-
-  // Count consumed characters (approximation - full string was consumed)
-  const consumed = remaining.length;
-  return ok([createCborPattern(cborResult.value), pos.value + consumed]);
+  const [cborValue, consumed] = parseResult.value;
+  return ok([createCborPattern(cborValue), pos.value + consumed]);
 }
 
 /**

package/src/pattern/dcbor-integration.ts

@@ -0,0 +1,208 @@
+/**
+ * @bcts/envelope-pattern - DCBor Pattern Integration
+ *
+ * This module provides integration between dcbor-pattern and
+ * bc-envelope-pattern, allowing dcbor patterns to be used as envelope patterns
+ * through conversion.
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust dcbor_integration.rs
+ *
+ * @module envelope-pattern/pattern/dcbor-integration
+ */
+
+import {
+  type Pattern as DCBORPattern,
+  type ValuePattern as DCBORValuePattern,
+  type StructurePattern as DCBORStructurePattern,
+  type MetaPattern as DCBORMetaPattern,
+} from "@bcts/dcbor-pattern";
+
+import type { Pattern } from "./index";
+import type { Result } from "../error";
+import { ok } from "../error";
+
+// Import leaf pattern constructors
+import {
+  BoolPattern,
+  NumberPattern,
+  TextPattern,
+  ByteStringPattern,
+  DatePattern,
+  KnownValuePattern,
+  NullPattern,
+  ArrayPattern,
+  MapPattern,
+  TaggedPattern,
+  CBORPattern,
+  leafBool,
+  leafNull,
+  leafNumber,
+  leafText,
+  leafByteString,
+  leafDate,
+  leafKnownValue,
+  leafArray,
+  leafMap,
+  leafTag,
+  leafCbor,
+} from "./leaf";
+
+// Import meta pattern constructors
+import {
+  AnyPattern,
+  AndPattern,
+  OrPattern,
+  NotPattern,
+  metaAny,
+  metaAnd,
+  metaOr,
+  metaNot,
+} from "./meta";
+
+/**
+ * Convert a dcbor-pattern Pattern to a bc-envelope-pattern Pattern.
+ *
+ * This function serves as the bridge between the two pattern systems,
+ * allowing dcbor-pattern expressions to be used in envelope pattern contexts.
+ *
+ * @param dcborPattern - The dcbor-pattern Pattern to convert
+ * @returns The converted envelope pattern, or an error if conversion fails
+ */
+export function convertDcborPatternToEnvelopePattern(dcborPattern: DCBORPattern): Result<Pattern> {
+  switch (dcborPattern.kind) {
+    case "Value":
+      return convertValuePatternToEnvelopePattern(dcborPattern.pattern);
+    case "Structure":
+      return convertStructurePatternToEnvelopePattern(dcborPattern.pattern);
+    case "Meta":
+      return convertMetaPatternToEnvelopePattern(dcborPattern.pattern, dcborPattern);
+  }
+}
+
+/**
+ * Convert a dcbor-pattern ValuePattern to an envelope leaf pattern.
+ */
+function convertValuePatternToEnvelopePattern(valuePattern: DCBORValuePattern): Result<Pattern> {
+  switch (valuePattern.type) {
+    case "Bool": {
+      const boolPattern = BoolPattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafBool(boolPattern) });
+    }
+    case "Number": {
+      const numberPattern = NumberPattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafNumber(numberPattern) });
+    }
+    case "Text": {
+      const textPattern = TextPattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafText(textPattern) });
+    }
+    case "ByteString": {
+      const byteStringPattern = ByteStringPattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafByteString(byteStringPattern) });
+    }
+    case "Date": {
+      const datePattern = DatePattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafDate(datePattern) });
+    }
+    case "KnownValue": {
+      const knownValuePattern = KnownValuePattern.fromDcborPattern(valuePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafKnownValue(knownValuePattern) });
+    }
+    case "Null": {
+      return ok({ type: "Leaf", pattern: leafNull(NullPattern.new()) });
+    }
+    case "Digest": {
+      // Digest patterns don't have a direct envelope equivalent yet
+      // For now, wrap as a generic CBOR pattern
+      const cborPattern = CBORPattern.fromDcborPattern({
+        kind: "Value",
+        pattern: valuePattern,
+      });
+      return ok({ type: "Leaf", pattern: leafCbor(cborPattern) });
+    }
+  }
+}
+
+/**
+ * Convert a dcbor-pattern StructurePattern to an envelope pattern.
+ */
+function convertStructurePatternToEnvelopePattern(
+  structurePattern: DCBORStructurePattern,
+): Result<Pattern> {
+  switch (structurePattern.type) {
+    case "Array": {
+      // Wrap the full dcbor pattern for array matching
+      const arrayPattern = ArrayPattern.fromDcborPattern({
+        kind: "Structure",
+        pattern: structurePattern,
+      });
+      return ok({ type: "Leaf", pattern: leafArray(arrayPattern) });
+    }
+    case "Map": {
+      // MapPattern only supports interval-based matching currently
+      // Use any() for general map patterns from dcbor
+      const mapPattern = MapPattern.any();
+      return ok({ type: "Leaf", pattern: leafMap(mapPattern) });
+    }
+    case "Tagged": {
+      const taggedPattern = TaggedPattern.fromDcborPattern(structurePattern.pattern);
+      return ok({ type: "Leaf", pattern: leafTag(taggedPattern) });
+    }
+  }
+}
+
+/**
+ * Convert a dcbor-pattern MetaPattern to an envelope meta pattern.
+ */
+function convertMetaPatternToEnvelopePattern(
+  metaPattern: DCBORMetaPattern,
+  originalPattern: DCBORPattern,
+): Result<Pattern> {
+  switch (metaPattern.type) {
+    case "Any": {
+      // The dcbor "any" pattern corresponds to our "any" meta pattern
+      return ok({ type: "Meta", pattern: metaAny(AnyPattern.new()) });
+    }
+    case "And": {
+      // Convert AND pattern by recursively converting each sub-pattern
+      // dcbor-pattern structure: { type: "And", pattern: AndPattern }
+      // where AndPattern is { variant: "And", patterns: Pattern[] }
+      const convertedPatterns: Pattern[] = [];
+      for (const pattern of metaPattern.pattern.patterns) {
+        const result = convertDcborPatternToEnvelopePattern(pattern);
+        if (!result.ok) return result;
+        convertedPatterns.push(result.value);
+      }
+      return ok({ type: "Meta", pattern: metaAnd(AndPattern.new(convertedPatterns)) });
+    }
+    case "Or": {
+      // Convert OR pattern by recursively converting each sub-pattern
+      // dcbor-pattern structure: { type: "Or", pattern: OrPattern }
+      // where OrPattern is { variant: "Or", patterns: Pattern[] }
+      const convertedPatterns: Pattern[] = [];
+      for (const pattern of metaPattern.pattern.patterns) {
+        const result = convertDcborPatternToEnvelopePattern(pattern);
+        if (!result.ok) return result;
+        convertedPatterns.push(result.value);
+      }
+      return ok({ type: "Meta", pattern: metaOr(OrPattern.new(convertedPatterns)) });
+    }
+    case "Not": {
+      // Convert NOT pattern by recursively converting the inner pattern
+      // dcbor-pattern structure: { type: "Not", pattern: NotPattern }
+      // where NotPattern is { variant: "Not", pattern: Pattern }
+      const innerResult = convertDcborPatternToEnvelopePattern(metaPattern.pattern.pattern);
+      if (!innerResult.ok) return innerResult;
+      return ok({ type: "Meta", pattern: metaNot(NotPattern.new(innerResult.value)) });
+    }
+    case "Capture":
+    case "Repeat":
+    case "Search":
+    case "Sequence": {
+      // These patterns don't have direct envelope equivalents yet
+      // For now, wrap as a generic CBOR pattern
+      const cborPattern = CBORPattern.fromDcborPattern(originalPattern);
+      return ok({ type: "Leaf", pattern: leafCbor(cborPattern) });
+    }
+  }
+}

package/src/pattern/index.ts

@@ -26,6 +26,7 @@ export * from "./structure";
 export * from "./meta";
 export * from "./matcher";
 export * from "./vm";
+export * from "./dcbor-integration";
 
 // Import leaf patterns
 import {
@@ -717,3 +718,7 @@ registerAllFactories();
 // Register VM pattern functions to resolve circular dependencies
 import { registerVMPatternFunctions } from "./vm";
 registerVMPatternFunctions(patternPathsWithCaptures, patternMatches, patternPaths);
+
+// Register pattern match function for meta patterns
+import { registerPatternMatchFn } from "./matcher";
+registerPatternMatchFn(patternMatches);

package/src/pattern/matcher.ts

@@ -86,3 +86,34 @@ export function compileAsAtomic(
   literals.push(pat);
   code.push({ type: "MatchPredicate", literalIndex: idx });
 }
+
+// ============================================================================
+// Pattern Match Registry
+// ============================================================================
+
+/**
+ * Registry for pattern matching function to break circular dependencies.
+ * This allows meta patterns to match child patterns without importing from index.ts.
+ */
+let patternMatchFn: ((pattern: Pattern, haystack: Envelope) => boolean) | undefined;
+
+/**
+ * Registers the pattern match function.
+ * Called from index.ts after all patterns are defined.
+ */
+export function registerPatternMatchFn(
+  fn: (pattern: Pattern, haystack: Envelope) => boolean,
+): void {
+  patternMatchFn = fn;
+}
+
+/**
+ * Match a pattern against an envelope using the registered match function.
+ * Used by meta patterns to match child patterns.
+ */
+export function matchPattern(pattern: Pattern, haystack: Envelope): boolean {
+  if (patternMatchFn === undefined) {
+    throw new Error("Pattern match function not registered");
+  }
+  return patternMatchFn(pattern, haystack);
+}

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

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { type Matcher, matchPattern } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -46,10 +46,7 @@ export class AndPattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const allMatch = this.#patterns.every((pattern) => {
-      const matcher = pattern as unknown as Matcher;
-      return matcher.matches(haystack);
-    });
+    const allMatch = this.#patterns.every((pattern) => matchPattern(pattern, haystack));
 
     const paths = allMatch ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];

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

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { type Matcher, matchPattern } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -47,8 +47,7 @@ export class NotPattern implements Matcher {
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
     // If the inner pattern doesn't match, then we return the current envelope as a match
-    const matcher = this.#pattern as unknown as Matcher;
-    const paths = !matcher.matches(haystack) ? [[haystack]] : [];
+    const paths = !matchPattern(this.#pattern, haystack) ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];
   }
 

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

@@ -8,7 +8,7 @@
 
 import type { Envelope } from "@bcts/envelope";
 import type { Path } from "../../format";
-import type { Matcher } from "../matcher";
+import { type Matcher, matchPattern } from "../matcher";
 import type { Instr } from "../vm";
 import type { Pattern } from "../index";
 
@@ -46,10 +46,7 @@ export class OrPattern implements Matcher {
   }
 
   pathsWithCaptures(haystack: Envelope): [Path[], Map<string, Path[]>] {
-    const anyMatch = this.#patterns.some((pattern) => {
-      const matcher = pattern as unknown as Matcher;
-      return matcher.matches(haystack);
-    });
+    const anyMatch = this.#patterns.some((pattern) => matchPattern(pattern, haystack));
 
     const paths = anyMatch ? [[haystack]] : [];
     return [paths, new Map<string, Path[]>()];