trellis 3.1.35 → 3.2.0

package/dist/{index-n9f2qyh5.js → chunk-X46IECAC.js}

@@ -1,9 +1,9 @@
-// @bun
 import {
   QueryEngine,
   literal,
   variable
-} from "./index-yp88he8n.js";
+} from "./chunk-2I5JU73Y.js";
+
 // src/core/query/parser.ts
 function tokenize(input) {
   const tokens = [];
@@ -14,9 +14,7 @@ function tokenize(input) {
       continue;
     }
     if (input[i] === "/" && input[i + 1] === "/") {
-      while (i < input.length && input[i] !== `
-`)
-        i++;
+      while (i < input.length && input[i] !== "\n") i++;
       continue;
     }
     const pos = i;
@@ -57,8 +55,7 @@ function tokenize(input) {
           i++;
         }
       }
-      if (i < input.length)
-        i++;
+      if (i < input.length) i++;
       tokens.push({ kind: "string", value: s, pos });
       continue;
     }
@@ -86,8 +83,7 @@ function tokenize(input) {
   tokens.push({ kind: "eof", value: "", pos: input.length });
   return tokens;
 }
-
-class Parser {
+var Parser = class {
   tokens;
   pos = 0;
   constructor(tokens) {
@@ -101,14 +97,14 @@ class Parser {
   }
   expect(kind, value) {
     const t = this.advance();
-    if (t.kind !== kind || value !== undefined && t.value !== value) {
+    if (t.kind !== kind || value !== void 0 && t.value !== value) {
       throw new Error(`Expected ${kind}${value ? ` "${value}"` : ""} at pos ${t.pos}, got ${t.kind} "${t.value}"`);
     }
     return t;
   }
   match(kind, value) {
     const t = this.peek();
-    if (t.kind === kind && (value === undefined || t.value === value)) {
+    if (t.kind === kind && (value === void 0 || t.value === value)) {
       this.pos++;
       return true;
     }
@@ -116,8 +112,11 @@ class Parser {
   }
   isAt(kind, value) {
     const t = this.peek();
-    return t.kind === kind && (value === undefined || t.value === value);
+    return t.kind === kind && (value === void 0 || t.value === value);
   }
+  // -----------------------------------------------------------------------
+  // Terms
+  // -----------------------------------------------------------------------
   parseTerm() {
     const t = this.peek();
     if (t.kind === "word" && t.value.startsWith("?")) {
@@ -136,14 +135,15 @@ class Parser {
     if (t.kind === "word") {
       const v = t.value;
       this.advance();
-      if (v === "true")
-        return literal(true);
-      if (v === "false")
-        return literal(false);
+      if (v === "true") return literal(true);
+      if (v === "false") return literal(false);
       return literal(v);
     }
     throw new Error(`Unexpected token at pos ${t.pos}: ${t.kind} "${t.value}"`);
   }
+  // -----------------------------------------------------------------------
+  // Patterns
+  // -----------------------------------------------------------------------
   parsePattern() {
     const t = this.peek();
     if (t.kind === "word" && t.value.toUpperCase() === "NOT") {
@@ -157,7 +157,7 @@ class Parser {
       while (this.isAt("symbol", "{")) {
         this.advance();
         const branch = [];
-        while (!this.isAt("symbol", "}") && !this.isAt("eof", undefined)) {
+        while (!this.isAt("symbol", "}") && !this.isAt("eof", void 0)) {
           branch.push(this.parsePattern());
         }
         this.expect("symbol", "}");
@@ -186,7 +186,7 @@ class Parser {
       if (this.isAt("symbol", "(")) {
         this.advance();
         const args = [];
-        while (!this.isAt("symbol", ")") && !this.isAt("eof", undefined)) {
+        while (!this.isAt("symbol", ")") && !this.isAt("eof", void 0)) {
           args.push(this.parseTerm());
           this.match("symbol", ",");
         }
@@ -197,12 +197,18 @@ class Parser {
     }
     throw new Error(`Cannot parse pattern at pos ${t.pos}: ${t.kind} "${t.value}"`);
   }
+  // -----------------------------------------------------------------------
+  // Filter
+  // -----------------------------------------------------------------------
   parseFilter() {
     const left = this.parseTerm();
     const op = this.advance().value;
     const right = this.parseTerm();
     return { kind: "filter", left, op, right };
   }
+  // -----------------------------------------------------------------------
+  // Full Query
+  // -----------------------------------------------------------------------
   parseQuery() {
     const query = {
       select: [],
@@ -213,7 +219,7 @@ class Parser {
       limit: 0,
       offset: 0
     };
-    while (!this.isAt("eof", undefined)) {
+    while (!this.isAt("eof", void 0)) {
       const kw = this.peek();
       if (kw.kind !== "word") {
         throw new Error(`Expected keyword at pos ${kw.pos}, got ${kw.kind} "${kw.value}"`);
@@ -229,7 +235,7 @@ class Parser {
         case "WHERE": {
           this.advance();
           this.expect("symbol", "{");
-          while (!this.isAt("symbol", "}") && !this.isAt("eof", undefined)) {
+          while (!this.isAt("symbol", "}") && !this.isAt("eof", void 0)) {
             query.where.push(this.parsePattern());
           }
           this.expect("symbol", "}");
@@ -282,11 +288,14 @@ class Parser {
     }
     return query;
   }
+  // -----------------------------------------------------------------------
+  // Datalog Rule
+  // -----------------------------------------------------------------------
   parseRule() {
     const name = this.expect("word").value;
     this.expect("symbol", "(");
     const params = [];
-    while (!this.isAt("symbol", ")") && !this.isAt("eof", undefined)) {
+    while (!this.isAt("symbol", ")") && !this.isAt("eof", void 0)) {
       const v = this.expect("word").value;
       params.push(v.startsWith("?") ? v.slice(1) : v);
       this.match("symbol", ",");
@@ -302,7 +311,7 @@ class Parser {
     }
     const body = [];
     const filters = [];
-    while (!this.isAt("eof", undefined)) {
+    while (!this.isAt("eof", void 0)) {
       if (this.peek().kind === "word" && this.peek().value.toUpperCase() === "FILTER") {
         this.advance();
         filters.push(this.parseFilter());
@@ -313,7 +322,7 @@ class Parser {
     }
     return { name, params, body, filters };
   }
-}
+};
 function parseQuery(input) {
   const tokens = tokenize(input);
   return new Parser(tokens).parseQuery();
@@ -353,18 +362,18 @@ function parseSimple(input) {
     }
     const fullQuery = `SELECT ${selectVars.join(" ")}
 WHERE {
-  ${patterns.join(`
-  `)}
+  ${patterns.join("\n  ")}
 }
-${filters.join(`
-`)}`;
+${filters.join("\n")}`;
     return parseQuery(fullQuery);
   }
   throw new Error(`Cannot parse query: "${trimmed}". Use full EQL-S syntax or "find ?e where attr = value".`);
 }
+
 // src/core/query/datalog.ts
 function transitiveClosureRules(ruleName, linkAttribute) {
   return [
+    // Base case: direct link
     {
       name: ruleName,
       params: ["x", "y"],
@@ -378,6 +387,7 @@ function transitiveClosureRules(ruleName, linkAttribute) {
       ],
       filters: []
     },
+    // Recursive case: indirect via intermediate
     {
       name: ruleName,
       params: ["x", "y"],
@@ -463,33 +473,45 @@ function siblingRules(ruleName, linkAttribute) {
     }
   ];
 }
-
-class DatalogRuntime {
+var DatalogRuntime = class {
   engine;
   constructor(store) {
     this.engine = new QueryEngine(store);
   }
+  /** Register a Datalog rule (or multiple). */
   addRule(rule) {
     this.engine.addRule(rule);
   }
   addRules(rules) {
-    for (const r of rules)
-      this.engine.addRule(r);
+    for (const r of rules) this.engine.addRule(r);
   }
   removeRule(name) {
     this.engine.removeRule(name);
   }
+  /** Register built-in transitive closure for a link attribute. */
   registerTransitiveClosure(ruleName, linkAttribute) {
     this.addRules(transitiveClosureRules(ruleName, linkAttribute));
   }
+  /** Register built-in reverse reachability for a link attribute. */
   registerReverseReachability(ruleName, linkAttribute) {
     this.addRules(reverseReachabilityRules(ruleName, linkAttribute));
   }
+  /** Register built-in sibling rule for a link attribute. */
   registerSiblings(ruleName, linkAttribute) {
     this.addRules(siblingRules(ruleName, linkAttribute));
   }
+  /** Get the underlying QueryEngine for direct query execution. */
   getEngine() {
     return this.engine;
   }
-}
-export { parseQuery, parseRule, parseSimple, transitiveClosureRules, reverseReachabilityRules, siblingRules, DatalogRuntime };
+};
+
+export {
+  parseQuery,
+  parseRule,
+  parseSimple,
+  transitiveClosureRules,
+  reverseReachabilityRules,
+  siblingRules,
+  DatalogRuntime
+};