trellis 3.1.35 → 3.2.2

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

@@ -1,9 +1,9 @@
-// @bun
 import {
   QueryEngine,
   literal,
   variable
-} from "./index-yp88he8n.js";
+} from "./chunk-6CTA6MCE.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
+};

package/dist/{index-h7zxhhhh.js → chunk-XMQ7G77X.js}

@@ -1,20 +1,20 @@
-// @bun
 import {
   __require
-} from "./index-a76rekgs.js";
+} from "./chunk-KFQGP6VL.js";
 
 // src/core/persist/sqlite-backend.ts
 var _DatabaseCtor = null;
 function loadDatabaseCtor() {
-  if (_DatabaseCtor)
-    return _DatabaseCtor;
+  if (_DatabaseCtor) return _DatabaseCtor;
   try {
     const { createRequire } = __require("module");
     const requireCJS = createRequire(import.meta.url);
     _DatabaseCtor = requireCJS("bun:sqlite").Database;
     return _DatabaseCtor;
   } catch {
-    throw new Error("SqliteKernelBackend requires the Bun runtime (built-in `bun:sqlite`). " + "In Node / WebContainer use `createKernelBackend()` from " + "`trellis/core` \u2014 it auto-selects better-sqlite3 or sql.js.");
+    throw new Error(
+      "SqliteKernelBackend requires the Bun runtime (built-in `bun:sqlite`). In Node / WebContainer use `createKernelBackend()` from `trellis/core` \u2014 it auto-selects better-sqlite3 or sql.js."
+    );
   }
 }
 var SCHEMA_SQL = `
@@ -45,16 +45,14 @@ CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
 CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
 CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
 `;
-
-class SqliteKernelBackend {
-  dbPath;
-  db;
-  _stmts = null;
+var SqliteKernelBackend = class {
   constructor(dbPath) {
     this.dbPath = dbPath;
     const DatabaseCtor = loadDatabaseCtor();
     this.db = new DatabaseCtor(dbPath);
   }
+  db;
+  _stmts = null;
   init() {
     this.db.exec("PRAGMA journal_mode=WAL;");
     this.db.exec("PRAGMA foreign_keys=ON;");
@@ -110,6 +108,9 @@ class SqliteKernelBackend {
       `)
     };
   }
+  // -------------------------------------------------------------------------
+  // Op operations
+  // -------------------------------------------------------------------------
   append(op) {
     const payload = JSON.stringify({
       facts: op.facts,
@@ -129,8 +130,7 @@ class SqliteKernelBackend {
     });
   }
   appendBatch(ops) {
-    if (ops.length === 0)
-      return;
+    if (ops.length === 0) return;
     this.db.transaction(() => {
       for (const op of ops) {
         this.append(op);
@@ -150,13 +150,15 @@ class SqliteKernelBackend {
     return rows.map(rowToOp);
   }
   readUntilTimestamp(isoTimestamp) {
-    const rows = this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`).all({ $ts: isoTimestamp });
+    const rows = this.db.prepare(
+      `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`
+    ).all({ $ts: isoTimestamp });
     return rows.map(rowToOp);
   }
   getLastOp() {
     const row = this._stmts.getLast.get();
-    return row ? rowToOp(row) : undefined;
+    return row ? rowToOp(row) : void 0;
   }
   getByHash(hash) {
     return this.getOpByHash(hash);
@@ -166,14 +168,18 @@ class SqliteKernelBackend {
   }
   getOpByHash(hash) {
     const row = this._stmts.getByHash.get({ $hash: hash });
-    return row ? rowToOp(row) : undefined;
+    return row ? rowToOp(row) : void 0;
   }
   count() {
     const row = this._stmts.count.get();
     return row?.cnt ?? 0;
   }
+  /**
+   * Find the common ancestor op of two op hashes by walking
+   * previousHash chains until they converge.
+   */
   findCommonAncestor(hashA, hashB) {
-    const ancestorsA = new Set;
+    const ancestorsA = /* @__PURE__ */ new Set();
     let cursor = hashA;
     while (cursor) {
       ancestorsA.add(cursor);
@@ -188,8 +194,11 @@ class SqliteKernelBackend {
       const op = this.getOpByHash(cursor);
       cursor = op?.previousHash;
     }
-    return;
+    return void 0;
   }
+  // -------------------------------------------------------------------------
+  // Snapshot operations
+  // -------------------------------------------------------------------------
   saveSnapshot(lastOpHash, data) {
     this._stmts.saveSnapshot.run({
       $lastOpHash: lastOpHash,
@@ -198,13 +207,15 @@ class SqliteKernelBackend {
   }
   loadLatestSnapshot() {
     const row = this._stmts.loadSnapshot.get();
-    if (!row)
-      return;
+    if (!row) return void 0;
     return {
       lastOpHash: row.last_op_hash,
       data: JSON.parse(row.data)
     };
   }
+  // -------------------------------------------------------------------------
+  // Blob operations
+  // -------------------------------------------------------------------------
   putBlob(hash, content) {
     this._stmts.putBlob.run({
       $hash: hash,
@@ -213,17 +224,19 @@ class SqliteKernelBackend {
   }
   getBlob(hash) {
     const row = this._stmts.getBlob.get({ $hash: hash });
-    if (!row)
-      return;
+    if (!row) return void 0;
     return new Uint8Array(row.content);
   }
   hasBlob(hash) {
     return !!this._stmts.hasBlob.get({ $hash: hash });
   }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
   close() {
     this.db.close();
   }
-}
+};
 function rowToOp(row) {
   const payload = JSON.parse(row.payload);
   const op = {
@@ -232,21 +245,16 @@ function rowToOp(row) {
     timestamp: row.timestamp,
     agentId: row.agent_id
   };
-  if (row.previous_hash)
-    op.previousHash = row.previous_hash;
-  if (payload.facts)
-    op.facts = payload.facts;
-  if (payload.links)
-    op.links = payload.links;
-  if (payload.deleteFacts)
-    op.deleteFacts = payload.deleteFacts;
-  if (payload.deleteLinks)
-    op.deleteLinks = payload.deleteLinks;
-  if (payload.vcs)
-    op.vcs = payload.vcs;
-  if (payload.signature)
-    op.signature = payload.signature;
+  if (row.previous_hash) op.previousHash = row.previous_hash;
+  if (payload.facts) op.facts = payload.facts;
+  if (payload.links) op.links = payload.links;
+  if (payload.deleteFacts) op.deleteFacts = payload.deleteFacts;
+  if (payload.deleteLinks) op.deleteLinks = payload.deleteLinks;
+  if (payload.vcs) op.vcs = payload.vcs;
+  if (payload.signature) op.signature = payload.signature;
   return op;
 }
 
-export { SqliteKernelBackend };
+export {
+  SqliteKernelBackend
+};