@bcts/envelope-pattern 1.0.0-alpha.12

package/src/pattern/meta/index.ts

@@ -0,0 +1,269 @@
+/**
+ * @bcts/envelope-pattern - Meta patterns module
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust pattern/meta/mod.rs
+ *
+ * @module envelope-pattern/pattern/meta
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Re-export all meta pattern types
+export { AnyPattern, registerAnyPatternFactory } from "./any-pattern";
+export { AndPattern, registerAndPatternFactory } from "./and-pattern";
+export { OrPattern, registerOrPatternFactory } from "./or-pattern";
+export { NotPattern, registerNotPatternFactory } from "./not-pattern";
+export { CapturePattern, registerCapturePatternFactory } from "./capture-pattern";
+export { SearchPattern, registerSearchPatternFactory } from "./search-pattern";
+export { TraversePattern, registerTraversePatternFactory } from "./traverse-pattern";
+export { GroupPattern, registerGroupPatternFactory } from "./group-pattern";
+
+// Import concrete types for use in MetaPattern
+import { type AnyPattern } from "./any-pattern";
+import { type AndPattern } from "./and-pattern";
+import { type OrPattern } from "./or-pattern";
+import { type NotPattern } from "./not-pattern";
+import { type CapturePattern } from "./capture-pattern";
+import { type SearchPattern } from "./search-pattern";
+import { type TraversePattern } from "./traverse-pattern";
+import { type GroupPattern } from "./group-pattern";
+
+/**
+ * Union type for all meta patterns.
+ *
+ * Corresponds to the Rust `MetaPattern` enum in pattern/meta/mod.rs
+ */
+export type MetaPattern =
+  | { readonly type: "Any"; readonly pattern: AnyPattern }
+  | { readonly type: "And"; readonly pattern: AndPattern }
+  | { readonly type: "Or"; readonly pattern: OrPattern }
+  | { readonly type: "Not"; readonly pattern: NotPattern }
+  | { readonly type: "Capture"; readonly pattern: CapturePattern }
+  | { readonly type: "Search"; readonly pattern: SearchPattern }
+  | { readonly type: "Traverse"; readonly pattern: TraversePattern }
+  | { readonly type: "Group"; readonly pattern: GroupPattern };
+
+/**
+ * Creates an Any meta pattern.
+ */
+export function metaAny(pattern: AnyPattern): MetaPattern {
+  return { type: "Any", pattern };
+}
+
+/**
+ * Creates an And meta pattern.
+ */
+export function metaAnd(pattern: AndPattern): MetaPattern {
+  return { type: "And", pattern };
+}
+
+/**
+ * Creates an Or meta pattern.
+ */
+export function metaOr(pattern: OrPattern): MetaPattern {
+  return { type: "Or", pattern };
+}
+
+/**
+ * Creates a Not meta pattern.
+ */
+export function metaNot(pattern: NotPattern): MetaPattern {
+  return { type: "Not", pattern };
+}
+
+/**
+ * Creates a Capture meta pattern.
+ */
+export function metaCapture(pattern: CapturePattern): MetaPattern {
+  return { type: "Capture", pattern };
+}
+
+/**
+ * Creates a Search meta pattern.
+ */
+export function metaSearch(pattern: SearchPattern): MetaPattern {
+  return { type: "Search", pattern };
+}
+
+/**
+ * Creates a Traverse meta pattern.
+ */
+export function metaTraverse(pattern: TraversePattern): MetaPattern {
+  return { type: "Traverse", pattern };
+}
+
+/**
+ * Creates a Group meta pattern.
+ */
+export function metaGroup(pattern: GroupPattern): MetaPattern {
+  return { type: "Group", pattern };
+}
+
+/**
+ * Gets paths with captures for a meta pattern.
+ */
+export function metaPatternPathsWithCaptures(
+  pattern: MetaPattern,
+  haystack: Envelope,
+): [Path[], Map<string, Path[]>] {
+  switch (pattern.type) {
+    case "Any":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "And":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Or":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Not":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Capture":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Search":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Traverse":
+      return pattern.pattern.pathsWithCaptures(haystack);
+    case "Group":
+      return pattern.pattern.pathsWithCaptures(haystack);
+  }
+}
+
+/**
+ * Compiles a meta pattern to bytecode.
+ */
+export function metaPatternCompile(
+  pattern: MetaPattern,
+  code: Instr[],
+  literals: Pattern[],
+  captures: string[],
+): void {
+  switch (pattern.type) {
+    case "Any":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "And":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Or":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Not":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Capture":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Search":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Traverse":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+    case "Group":
+      pattern.pattern.compile(code, literals, captures);
+      break;
+  }
+}
+
+/**
+ * Checks if a meta pattern is complex.
+ */
+export function metaPatternIsComplex(pattern: MetaPattern): boolean {
+  switch (pattern.type) {
+    case "Any":
+      return pattern.pattern.isComplex();
+    case "And":
+      return pattern.pattern.isComplex();
+    case "Or":
+      return pattern.pattern.isComplex();
+    case "Not":
+      return pattern.pattern.isComplex();
+    case "Capture":
+      return pattern.pattern.isComplex();
+    case "Search":
+      return pattern.pattern.isComplex();
+    case "Traverse":
+      return pattern.pattern.isComplex();
+    case "Group":
+      return pattern.pattern.isComplex();
+  }
+}
+
+/**
+ * Converts a meta pattern to string.
+ */
+export function metaPatternToString(pattern: MetaPattern): string {
+  switch (pattern.type) {
+    case "Any":
+      return pattern.pattern.toString();
+    case "And":
+      return pattern.pattern.toString();
+    case "Or":
+      return pattern.pattern.toString();
+    case "Not":
+      return pattern.pattern.toString();
+    case "Capture":
+      return pattern.pattern.toString();
+    case "Search":
+      return pattern.pattern.toString();
+    case "Traverse":
+      return pattern.pattern.toString();
+    case "Group":
+      return pattern.pattern.toString();
+  }
+}
+
+/**
+ * Collects capture names from a meta pattern.
+ */
+export function metaPatternCollectCaptureNames(pattern: MetaPattern, out: string[]): void {
+  switch (pattern.type) {
+    case "Any":
+      // No captures
+      break;
+    case "And":
+      for (const pat of pattern.pattern.patterns()) {
+        collectCaptureNamesFromPattern(pat, out);
+      }
+      break;
+    case "Or":
+      for (const pat of pattern.pattern.patterns()) {
+        collectCaptureNamesFromPattern(pat, out);
+      }
+      break;
+    case "Not":
+      collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+      break;
+    case "Capture": {
+      const name = pattern.pattern.name();
+      if (!out.includes(name)) {
+        out.push(name);
+      }
+      collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+      break;
+    }
+    case "Search":
+      collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+      break;
+    case "Traverse":
+      for (const pat of pattern.pattern.patterns()) {
+        collectCaptureNamesFromPattern(pat, out);
+      }
+      break;
+    case "Group":
+      collectCaptureNamesFromPattern(pattern.pattern.pattern(), out);
+      break;
+  }
+}
+
+/**
+ * Helper to collect capture names from any Pattern.
+ */
+function collectCaptureNamesFromPattern(pattern: Pattern, out: string[]): void {
+  // This will be properly implemented when Pattern type is fully defined
+  const p = pattern as unknown as { collectCaptureNames?: (out: string[]) => void };
+  if (p.collectCaptureNames !== undefined) {
+    p.collectCaptureNames(out);
+  }
+}

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

@@ -0,0 +1,91 @@
+/**
+ * @bcts/envelope-pattern - Not pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust not_pattern.rs
+ *
+ * @module envelope-pattern/pattern/meta/not-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory (used for late binding)
+export let createMetaNotPattern: ((pattern: NotPattern) => Pattern) | undefined;
+
+export function registerNotPatternFactory(factory: (pattern: NotPattern) => Pattern): void {
+  createMetaNotPattern = factory;
+}
+
+/**
+ * A pattern that negates another pattern; matches when the inner pattern does not match.
+ *
+ * Corresponds to the Rust `NotPattern` struct in not_pattern.rs
+ */
+export class NotPattern implements Matcher {
+  readonly #pattern: Pattern;
+
+  private constructor(pattern: Pattern) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new NotPattern with the given pattern.
+   */
+  static new(pattern: Pattern): NotPattern {
+    return new NotPattern(pattern);
+  }
+
+  /**
+   * Gets the inner pattern.
+   */
+  pattern(): Pattern {
+    return this.#pattern;
+  }
+
+  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]] : [];
+    return [paths, new Map<string, Path[]>()];
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], _captures: string[]): void {
+    // NOT = check that pattern doesn't match
+    const idx = literals.length;
+    literals.push(this.#pattern);
+    code.push({ type: "NotMatch", patternIndex: idx });
+  }
+
+  isComplex(): boolean {
+    return false;
+  }
+
+  toString(): string {
+    return `!${(this.#pattern as unknown as { toString(): string }).toString()}`;
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: NotPattern): boolean {
+    return this.#pattern === other.#pattern;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return 1;
+  }
+}

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

@@ -0,0 +1,146 @@
+/**
+ * @bcts/envelope-pattern - Or pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust or_pattern.rs
+ *
+ * @module envelope-pattern/pattern/meta/or-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory (used for late binding)
+export let createMetaOrPattern: ((pattern: OrPattern) => Pattern) | undefined;
+
+export function registerOrPatternFactory(factory: (pattern: OrPattern) => Pattern): void {
+  createMetaOrPattern = factory;
+}
+
+/**
+ * A pattern that matches if any contained pattern matches.
+ *
+ * Corresponds to the Rust `OrPattern` struct in or_pattern.rs
+ */
+export class OrPattern implements Matcher {
+  readonly #patterns: Pattern[];
+
+  private constructor(patterns: Pattern[]) {
+    this.#patterns = patterns;
+  }
+
+  /**
+   * Creates a new OrPattern with the given patterns.
+   */
+  static new(patterns: Pattern[]): OrPattern {
+    return new OrPattern(patterns);
+  }
+
+  /**
+   * Gets the patterns.
+   */
+  patterns(): Pattern[] {
+    return this.#patterns;
+  }
+
+  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 paths = anyMatch ? [[haystack]] : [];
+    return [paths, new Map<string, Path[]>()];
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], captures: string[]): void {
+    if (this.#patterns.length === 0) {
+      return;
+    }
+
+    // For N patterns: Split(p1, Split(p2, ... Split(pN-1, pN)))
+    const splits: number[] = [];
+
+    // Generate splits for all but the last pattern
+    for (let i = 0; i < this.#patterns.length - 1; i++) {
+      splits.push(code.length);
+      code.push({ type: "Split", a: 0, b: 0 }); // Placeholder
+    }
+
+    // Track jump instructions that need patching
+    const jumps: number[] = [];
+
+    // Now fill in the actual split targets
+    for (let i = 0; i < this.#patterns.length; i++) {
+      const patternStart = code.length;
+
+      // Compile this pattern
+      const pattern = this.#patterns[i];
+      const matcher = pattern as unknown as Matcher;
+      matcher.compile(code, literals, captures);
+
+      // This pattern will jump to the end if it matches
+      const jumpPastAll = code.length;
+      code.push({ type: "Jump", address: 0 }); // Placeholder
+      jumps.push(jumpPastAll);
+
+      // If there's a next pattern, update the split to point here
+      if (i < this.#patterns.length - 1) {
+        const nextPattern = code.length;
+        code[splits[i]] = { type: "Split", a: patternStart, b: nextPattern };
+      }
+    }
+
+    // Now patch all the jumps to point past all the patterns
+    const pastAll = code.length;
+    for (const jumpIdx of jumps) {
+      code[jumpIdx] = { type: "Jump", address: pastAll };
+    }
+  }
+
+  isComplex(): boolean {
+    // The pattern is complex if it contains more than one pattern, or if
+    // the one pattern is complex itself.
+    return (
+      this.#patterns.length > 1 || this.#patterns.some((p) => (p as unknown as Matcher).isComplex())
+    );
+  }
+
+  toString(): string {
+    return this.#patterns
+      .map((p) => (p as unknown as { toString(): string }).toString())
+      .join(" | ");
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: OrPattern): boolean {
+    if (this.#patterns.length !== other.#patterns.length) {
+      return false;
+    }
+    for (let i = 0; i < this.#patterns.length; i++) {
+      if (this.#patterns[i] !== other.#patterns[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return this.#patterns.length;
+  }
+}

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

@@ -0,0 +1,201 @@
+/**
+ * @bcts/envelope-pattern - Search pattern matching
+ *
+ * This is a 1:1 TypeScript port of bc-envelope-pattern-rust search_pattern.rs
+ *
+ * @module envelope-pattern/pattern/meta/search-pattern
+ */
+
+import type { Envelope } from "@bcts/envelope";
+import type { Path } from "../../format";
+import type { Matcher } from "../matcher";
+import type { Instr } from "../vm";
+import type { Pattern } from "../index";
+
+// Forward declaration for Pattern factory (used for late binding)
+export let createMetaSearchPattern: ((pattern: SearchPattern) => Pattern) | undefined;
+
+export function registerSearchPatternFactory(factory: (pattern: SearchPattern) => Pattern): void {
+  createMetaSearchPattern = factory;
+}
+
+/**
+ * A pattern that searches the entire envelope tree for matches.
+ *
+ * Corresponds to the Rust `SearchPattern` struct in search_pattern.rs
+ */
+export class SearchPattern implements Matcher {
+  readonly #pattern: Pattern;
+
+  private constructor(pattern: Pattern) {
+    this.#pattern = pattern;
+  }
+
+  /**
+   * Creates a new SearchPattern with the given pattern.
+   */
+  static new(pattern: Pattern): SearchPattern {
+    return new SearchPattern(pattern);
+  }
+
+  /**
+   * Gets the inner pattern.
+   */
+  pattern(): 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) => {
+      // Create the path to this node
+      const newPath: Envelope[] = [...pathToCurrent, currentEnvelope];
+
+      // Test the pattern against this node
+      const patternPaths = matcher.paths(currentEnvelope);
+
+      // If the pattern matches, emit the full paths
+      for (const patternPath of patternPaths) {
+        const fullPath = [...newPath];
+        // If the pattern path has elements beyond just the current envelope,
+        // extend with those additional elements.
+        if (patternPath.length > 1) {
+          fullPath.push(...patternPath.slice(1));
+        } else if (patternPath.length === 1) {
+          const firstEnv = patternPath[0];
+          if (firstEnv !== undefined && !firstEnv.digest().equals(currentEnvelope.digest())) {
+            // Pattern found a different element, add it to the path
+            fullPath.push(...patternPath);
+          }
+        }
+        resultPaths.push(fullPath);
+      }
+    });
+
+    // Deduplicate paths by digest
+    const seen = new Set<string>();
+    const uniquePaths: Path[] = [];
+    for (const path of resultPaths) {
+      const digestPath = path.map((e) => e.digest().hex()).join(",");
+      if (!seen.has(digestPath)) {
+        seen.add(digestPath);
+        uniquePaths.push(path);
+      }
+    }
+
+    return [uniquePaths, new Map<string, Path[]>()];
+  }
+
+  /**
+   * Walk the envelope tree recursively.
+   */
+  #walkEnvelope(
+    envelope: Envelope,
+    pathToCurrent: Envelope[],
+    visitor: (envelope: Envelope, path: Envelope[]) => void,
+  ): void {
+    // Visit this node
+    visitor(envelope, pathToCurrent);
+
+    // Get the subject
+    const subject = envelope.subject();
+    const newPath = [...pathToCurrent, envelope];
+
+    // Walk subject if it's different from this envelope
+    if (!subject.digest().equals(envelope.digest())) {
+      this.#walkEnvelope(subject, newPath, visitor);
+    }
+
+    // Walk assertions
+    for (const assertion of envelope.assertions()) {
+      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);
+      }
+
+      const object = assertion.asObject?.();
+      if (object !== undefined) {
+        const assertionPath = [...newPath, assertion];
+        this.#walkEnvelope(object, assertionPath, visitor);
+      }
+    }
+
+    // Walk wrapped content if present
+    if (subject.isWrapped()) {
+      const unwrapped = subject.tryUnwrap?.();
+      if (unwrapped !== undefined) {
+        this.#walkEnvelope(unwrapped, newPath, visitor);
+      }
+    }
+  }
+
+  paths(haystack: Envelope): Path[] {
+    return this.pathsWithCaptures(haystack)[0];
+  }
+
+  matches(haystack: Envelope): boolean {
+    return this.paths(haystack).length > 0;
+  }
+
+  compile(code: Instr[], literals: Pattern[], captures: string[]): void {
+    const idx = literals.length;
+    literals.push(this.#pattern);
+
+    // Collect capture names from inner pattern
+    const innerNames: string[] = [];
+    collectCaptureNames(this.#pattern, innerNames);
+
+    const captureMap: [string, number][] = [];
+    for (const name of innerNames) {
+      let pos = captures.indexOf(name);
+      if (pos === -1) {
+        pos = captures.length;
+        captures.push(name);
+      }
+      captureMap.push([name, pos]);
+    }
+
+    code.push({ type: "Search", patternIndex: idx, captureMap });
+  }
+
+  isComplex(): boolean {
+    return true;
+  }
+
+  toString(): string {
+    return `search(${(this.#pattern as unknown as { toString(): string }).toString()})`;
+  }
+
+  /**
+   * Equality comparison.
+   */
+  equals(other: SearchPattern): boolean {
+    return this.#pattern === other.#pattern;
+  }
+
+  /**
+   * Hash code for use in Maps/Sets.
+   */
+  hashCode(): number {
+    return 1;
+  }
+}
+
+/**
+ * Collect capture names from a pattern.
+ */
+function collectCaptureNames(pattern: Pattern, out: string[]): void {
+  // This will be properly implemented when Pattern type is fully defined
+  // For now, we check if it has a collectCaptureNames method
+  const p = pattern as unknown as { collectCaptureNames?: (out: string[]) => void };
+  if (p.collectCaptureNames !== undefined) {
+    p.collectCaptureNames(out);
+  }
+}