trellis 2.0.8 → 2.0.13

package/dist/index-hybgxe40.js

@@ -0,0 +1,1174 @@
+// @bun
+import {
+  __esm
+} from "./index-a76rekgs.js";
+
+// src/core/store/eav-store.ts
+function* flatten(obj, base = "") {
+  if (Array.isArray(obj)) {
+    for (const v of obj) {
+      yield* flatten(v, base);
+    }
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      yield* flatten(v, base ? `${base}.${k}` : k);
+    }
+  } else {
+    yield [base, obj];
+  }
+}
+function jsonEntityFacts(entityId, root, type) {
+  const facts = [{ e: entityId, a: "type", v: type }];
+  for (const [a, v] of flatten(root)) {
+    if (v === undefined || v === null)
+      continue;
+    if (Array.isArray(v)) {
+      for (const el of v) {
+        facts.push({ e: entityId, a, v: el });
+      }
+    } else if (typeof v === "object") {} else {
+      facts.push({ e: entityId, a, v });
+    }
+  }
+  return facts;
+}
+
+class EAVStore {
+  facts = [];
+  links = [];
+  catalog = new Map;
+  eavIndex = new Map;
+  aevIndex = new Map;
+  aveIndex = new Map;
+  linkIndex = new Map;
+  linkReverseIndex = new Map;
+  linkAttrIndex = new Map;
+  distinct = new Map;
+  addFacts(facts) {
+    for (let i = 0;i < facts.length; i++) {
+      const fact = facts[i];
+      if (fact) {
+        this.facts.push(fact);
+        this.updateIndexes(fact, this.facts.length - 1);
+        this.updateCatalog(fact);
+      }
+    }
+  }
+  addLinks(links) {
+    for (const link of links) {
+      this.links.push(link);
+      this.updateLinkIndexes(link);
+    }
+  }
+  deleteFacts(factsToDelete) {
+    for (const fact of factsToDelete) {
+      const valueKey = this.valueKey(fact.v);
+      const indices = this.aveIndex.get(fact.a)?.get(valueKey);
+      if (!indices)
+        continue;
+      let foundIdx = -1;
+      for (const idx of indices) {
+        const storedFact = this.facts[idx];
+        if (storedFact && storedFact.e === fact.e && storedFact.a === fact.a) {
+          foundIdx = idx;
+          break;
+        }
+      }
+      if (foundIdx !== -1) {
+        this.facts[foundIdx] = undefined;
+        this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
+        this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
+        this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
+        const entry = this.catalog.get(fact.a);
+        if (entry) {}
+      }
+    }
+  }
+  deleteLinks(linksToDelete) {
+    for (const link of linksToDelete) {
+      const initialLen = this.links.length;
+      this.links = this.links.filter((l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2));
+      if (this.links.length < initialLen) {
+        this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
+        this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
+        const attrPairs = this.linkAttrIndex.get(link.a);
+        if (attrPairs) {
+          for (const pair of attrPairs) {
+            if (pair[0] === link.e1 && pair[1] === link.e2) {
+              attrPairs.delete(pair);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  updateIndexes(fact, index) {
+    if (!this.eavIndex.has(fact.e)) {
+      this.eavIndex.set(fact.e, new Map);
+    }
+    if (!this.eavIndex.get(fact.e).has(fact.a)) {
+      this.eavIndex.get(fact.e).set(fact.a, new Set);
+    }
+    this.eavIndex.get(fact.e).get(fact.a).add(index);
+    if (!this.aevIndex.has(fact.a)) {
+      this.aevIndex.set(fact.a, new Map);
+    }
+    if (!this.aevIndex.get(fact.a).has(fact.e)) {
+      this.aevIndex.get(fact.a).set(fact.e, new Set);
+    }
+    this.aevIndex.get(fact.a).get(fact.e).add(index);
+    if (!this.aveIndex.has(fact.a)) {
+      this.aveIndex.set(fact.a, new Map);
+    }
+    const valueKey = this.valueKey(fact.v);
+    if (!this.aveIndex.get(fact.a).has(valueKey)) {
+      this.aveIndex.get(fact.a).set(valueKey, new Set);
+    }
+    this.aveIndex.get(fact.a).get(valueKey).add(index);
+  }
+  updateLinkIndexes(link) {
+    if (!this.linkIndex.has(link.e1)) {
+      this.linkIndex.set(link.e1, new Map);
+    }
+    const e1Attrs = this.linkIndex.get(link.e1);
+    if (!e1Attrs.has(link.a)) {
+      e1Attrs.set(link.a, new Set);
+    }
+    e1Attrs.get(link.a).add(link.e2);
+    if (!this.linkReverseIndex.has(link.e2)) {
+      this.linkReverseIndex.set(link.e2, new Map);
+    }
+    const e2Attrs = this.linkReverseIndex.get(link.e2);
+    if (!e2Attrs.has(link.a)) {
+      e2Attrs.set(link.a, new Set);
+    }
+    e2Attrs.get(link.a).add(link.e1);
+    if (!this.linkAttrIndex.has(link.a)) {
+      this.linkAttrIndex.set(link.a, new Set);
+    }
+    this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
+  }
+  valueKey(v) {
+    if (v instanceof Date)
+      return `date:${v.toISOString()}`;
+    return `${typeof v}:${v}`;
+  }
+  updateCatalog(fact) {
+    const entry = this.catalog.get(fact.a) || {
+      attribute: fact.a,
+      type: this.inferType(fact.v),
+      cardinality: "one",
+      distinctCount: 0,
+      examples: []
+    };
+    const factType = this.inferType(fact.v);
+    if (entry.type !== factType && entry.type !== "mixed") {
+      entry.type = "mixed";
+    }
+    const entityAttrs = this.eavIndex.get(fact.e)?.get(fact.a);
+    if (entityAttrs && entityAttrs.size > 1) {
+      entry.cardinality = "many";
+    }
+    const k = this.valueKey(fact.v);
+    const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, new Set), this.distinct.get(fact.a));
+    s.add(k);
+    entry.distinctCount = s.size;
+    if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
+      entry.examples.push(fact.v);
+    }
+    if (typeof fact.v === "number") {
+      entry.min = Math.min(entry.min ?? fact.v, fact.v);
+      entry.max = Math.max(entry.max ?? fact.v, fact.v);
+    }
+    this.catalog.set(fact.a, entry);
+  }
+  inferType(v) {
+    if (typeof v === "string")
+      return "string";
+    if (typeof v === "number")
+      return "number";
+    if (typeof v === "boolean")
+      return "boolean";
+    if (v instanceof Date)
+      return "date";
+    return "mixed";
+  }
+  getFactsByEntity(entity) {
+    const indices = this.eavIndex.get(entity);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const attrIndices of indices.values()) {
+      for (const idx of attrIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByAttribute(attribute) {
+    const indices = this.aevIndex.get(attribute);
+    if (!indices)
+      return [];
+    const result = [];
+    for (const entityIndices of indices.values()) {
+      for (const idx of entityIndices) {
+        const fact = this.facts[idx];
+        if (fact) {
+          result.push(fact);
+        }
+      }
+    }
+    return result;
+  }
+  getFactsByValue(attribute, value) {
+    const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
+    if (!indices)
+      return [];
+    return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== undefined);
+  }
+  getCatalog() {
+    return Array.from(this.catalog.values());
+  }
+  getCatalogEntry(attribute) {
+    return this.catalog.get(attribute);
+  }
+  getAllFacts() {
+    return this.facts.filter((f) => f !== undefined);
+  }
+  getAllLinks() {
+    return [...this.links];
+  }
+  getLinksByEntity(entity) {
+    const results = [];
+    const forwardLinks = this.linkIndex.get(entity);
+    if (forwardLinks) {
+      for (const [attr, targets] of forwardLinks) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attr, e2: target });
+        }
+      }
+    }
+    const reverseLinks = this.linkReverseIndex.get(entity);
+    if (reverseLinks) {
+      for (const [attr, sources] of reverseLinks) {
+        for (const source of sources) {
+          results.push({ e1: source, a: attr, e2: entity });
+        }
+      }
+    }
+    return results;
+  }
+  getLinksByAttribute(attribute) {
+    const results = [];
+    const links = this.linkAttrIndex.get(attribute);
+    if (links) {
+      for (const [e1, e2] of links) {
+        results.push({ e1, a: attribute, e2 });
+      }
+    }
+    return results;
+  }
+  getLinksByEntityAndAttribute(entity, attribute) {
+    const results = [];
+    const attrs = this.linkIndex.get(entity);
+    if (attrs) {
+      const targets = attrs.get(attribute);
+      if (targets) {
+        for (const target of targets) {
+          results.push({ e1: entity, a: attribute, e2: target });
+        }
+      }
+    }
+    return results;
+  }
+  getStats() {
+    return {
+      totalFacts: this.facts.length,
+      totalLinks: this.links.length,
+      uniqueEntities: this.eavIndex.size,
+      uniqueAttributes: this.aevIndex.size,
+      catalogEntries: this.catalog.size
+    };
+  }
+  snapshot() {
+    return {
+      facts: this.facts.filter((f) => f !== undefined),
+      links: [...this.links],
+      catalog: this.getCatalog()
+    };
+  }
+  restore(snapshot) {
+    this.facts = [];
+    this.links = [];
+    this.catalog.clear();
+    this.eavIndex.clear();
+    this.aevIndex.clear();
+    this.aveIndex.clear();
+    this.linkIndex.clear();
+    this.linkReverseIndex.clear();
+    this.linkAttrIndex.clear();
+    this.distinct.clear();
+    this.addFacts(snapshot.facts);
+    this.addLinks(snapshot.links);
+    if (snapshot.catalog) {
+      for (const entry of snapshot.catalog) {
+        this.catalog.set(entry.attribute, entry);
+      }
+    }
+  }
+}
+var init_eav_store = () => {};
+
+// src/core/query/types.ts
+function isVariable(t) {
+  return t.kind === "variable";
+}
+function isLiteral(t) {
+  return t.kind === "literal";
+}
+function variable(name) {
+  return { kind: "variable", name };
+}
+function literal(value) {
+  return { kind: "literal", value };
+}
+
+// src/core/query/engine.ts
+class QueryEngine {
+  store;
+  rules = new Map;
+  maxRuleDepth = 32;
+  constructor(store) {
+    this.store = store;
+  }
+  addRule(rule) {
+    const existing = this.rules.get(rule.name) ?? [];
+    existing.push(rule);
+    this.rules.set(rule.name, existing);
+  }
+  removeRule(name) {
+    this.rules.delete(name);
+  }
+  execute(query) {
+    const start = performance.now();
+    let results = this._evaluatePatterns(query.where, [new Map]);
+    for (const filter of query.filters) {
+      results = results.filter((b) => this._evalFilter(filter, b));
+    }
+    if (query.aggregates.length > 0) {
+      results = this._aggregate(results, query.aggregates, query.select);
+    }
+    if (query.orderBy.length > 0) {
+      results = this._order(results, query.orderBy);
+    }
+    if (query.offset > 0)
+      results = results.slice(query.offset);
+    if (query.limit > 0)
+      results = results.slice(0, query.limit);
+    const projected = this._project(results, query.select);
+    return {
+      bindings: projected,
+      executionTime: performance.now() - start,
+      count: projected.length
+    };
+  }
+  _evaluatePatterns(patterns, bindings) {
+    let current = bindings;
+    for (const pattern of patterns) {
+      if (current.length === 0)
+        break;
+      current = this._evaluatePattern(pattern, current);
+    }
+    return current;
+  }
+  _evaluatePattern(pattern, bindings) {
+    switch (pattern.kind) {
+      case "fact":
+        return this._evalFactPattern(pattern, bindings);
+      case "link":
+        return this._evalLinkPattern(pattern, bindings);
+      case "not":
+        return this._evalNotPattern(pattern, bindings);
+      case "or":
+        return this._evalOrPattern(pattern, bindings);
+      case "rule":
+        return this._evalRuleApplication(pattern, bindings);
+    }
+  }
+  _evalFactPattern(p, bindings) {
+    const results = [];
+    for (const b of bindings) {
+      const eResolved = this._resolve(p.entity, b);
+      const aResolved = this._resolve(p.attribute, b);
+      const vResolved = this._resolve(p.value, b);
+      let facts;
+      if (eResolved !== undefined && aResolved !== undefined) {
+        facts = this.store.getFactsByEntity(String(eResolved)).filter((f) => f.a === aResolved);
+      } else if (eResolved !== undefined) {
+        facts = this.store.getFactsByEntity(String(eResolved));
+      } else if (aResolved !== undefined && vResolved !== undefined) {
+        facts = this.store.getFactsByValue(String(aResolved), vResolved);
+      } else if (aResolved !== undefined) {
+        facts = this.store.getFactsByAttribute(String(aResolved));
+      } else {
+        facts = this.store.getAllFacts();
+      }
+      if (vResolved !== undefined) {
+        facts = facts.filter((f) => f.v === vResolved);
+      }
+      for (const fact of facts) {
+        const nb = new Map(b);
+        if (this._bind(p.entity, fact.e, nb) && this._bind(p.attribute, fact.a, nb) && this._bind(p.value, fact.v, nb)) {
+          results.push(nb);
+        }
+      }
+    }
+    return results;
+  }
+  _evalLinkPattern(p, bindings) {
+    const results = [];
+    for (const b of bindings) {
+      const srcResolved = this._resolve(p.source, b);
+      const attrResolved = this._resolve(p.attribute, b);
+      const tgtResolved = this._resolve(p.target, b);
+      let links;
+      if (srcResolved !== undefined && attrResolved !== undefined) {
+        links = this.store.getLinksByEntityAndAttribute(String(srcResolved), String(attrResolved));
+      } else if (srcResolved !== undefined) {
+        links = this.store.getLinksByEntity(String(srcResolved));
+      } else if (attrResolved !== undefined) {
+        links = this.store.getLinksByAttribute(String(attrResolved));
+      } else {
+        links = this.store.getAllLinks();
+      }
+      if (tgtResolved !== undefined) {
+        links = links.filter((l) => l.e2 === tgtResolved);
+      }
+      for (const link of links) {
+        const nb = new Map(b);
+        if (this._bind(p.source, link.e1, nb) && this._bind(p.attribute, link.a, nb) && this._bind(p.target, link.e2, nb)) {
+          results.push(nb);
+        }
+      }
+    }
+    return results;
+  }
+  _evalNotPattern(p, bindings) {
+    return bindings.filter((b) => {
+      const matches = this._evaluatePattern(p.pattern, [b]);
+      return matches.length === 0;
+    });
+  }
+  _evalOrPattern(p, bindings) {
+    const results = [];
+    for (const branch of p.branches) {
+      const branchResults = this._evaluatePatterns(branch, bindings);
+      results.push(...branchResults);
+    }
+    return this._dedup(results);
+  }
+  _evalRuleApplication(p, bindings, depth = 0) {
+    if (depth > this.maxRuleDepth)
+      return [];
+    const ruleDefs = this.rules.get(p.name);
+    if (!ruleDefs)
+      return [];
+    const results = [];
+    for (const b of bindings) {
+      for (const rule of ruleDefs) {
+        const ruleBindings = new Map(b);
+        let ok = true;
+        for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+          const resolved = this._resolve(p.args[i], b);
+          if (resolved !== undefined) {
+            ruleBindings.set(rule.params[i], resolved);
+          } else if (isVariable(p.args[i])) {}
+        }
+        if (!ok)
+          continue;
+        let bodyResults = this._evaluatePatterns(rule.body, [ruleBindings]);
+        for (const f of rule.filters) {
+          bodyResults = bodyResults.filter((rb) => this._evalFilter(f, rb));
+        }
+        for (const rb of bodyResults) {
+          const nb = new Map(b);
+          for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+            if (isVariable(p.args[i])) {
+              const val = rb.get(rule.params[i]);
+              if (val !== undefined)
+                nb.set(p.args[i].name, val);
+            }
+          }
+          results.push(nb);
+        }
+      }
+    }
+    return this._dedup(results);
+  }
+  _evalFilter(filter, b) {
+    const left = this._resolve(filter.left, b);
+    const right = this._resolve(filter.right, b);
+    if (left === undefined || right === undefined)
+      return false;
+    switch (filter.op) {
+      case "=":
+        return left === right;
+      case "!=":
+        return left !== right;
+      case "<":
+        return left < right;
+      case "<=":
+        return left <= right;
+      case ">":
+        return left > right;
+      case ">=":
+        return left >= right;
+      case "contains":
+        return String(left).includes(String(right));
+      case "startsWith":
+        return String(left).startsWith(String(right));
+      case "endsWith":
+        return String(left).endsWith(String(right));
+      case "matches":
+        return new RegExp(String(right)).test(String(left));
+      default:
+        return false;
+    }
+  }
+  _aggregate(bindings, aggregates, groupBy) {
+    const aggVarNames = new Set(aggregates.map((a) => a.as));
+    const groupVars = groupBy.filter((v) => !aggVarNames.has(v));
+    const groups = new Map;
+    for (const b of bindings) {
+      const key = groupVars.map((v) => String(b.get(v) ?? "")).join("\x00");
+      const group = groups.get(key) ?? [];
+      group.push(b);
+      groups.set(key, group);
+    }
+    const results = [];
+    for (const [, group] of groups) {
+      const nb = new Map(group[0]);
+      for (const agg of aggregates) {
+        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== undefined);
+        nb.set(agg.as, this._computeAggregate(agg.op, vals));
+      }
+      results.push(nb);
+    }
+    return results;
+  }
+  _computeAggregate(op, vals) {
+    switch (op) {
+      case "count":
+        return vals.length;
+      case "sum":
+        return vals.reduce((s, v) => s + (Number(v) || 0), 0);
+      case "avg":
+        return vals.length ? vals.reduce((s, v) => s + (Number(v) || 0), 0) / vals.length : 0;
+      case "min":
+        return vals.reduce((m, v) => v < m ? v : m, vals[0]);
+      case "max":
+        return vals.reduce((m, v) => v > m ? v : m, vals[0]);
+      case "collect":
+        return JSON.stringify(vals);
+      default:
+        return vals.length;
+    }
+  }
+  _order(bindings, orderBy) {
+    return [...bindings].sort((a, b) => {
+      for (const o of orderBy) {
+        const va = a.get(o.variable);
+        const vb = b.get(o.variable);
+        if (va === vb)
+          continue;
+        if (va === undefined)
+          return 1;
+        if (vb === undefined)
+          return -1;
+        const cmp = va < vb ? -1 : 1;
+        return o.direction === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  _project(bindings, select) {
+    return bindings.map((b) => {
+      const row = {};
+      if (select.length === 0) {
+        for (const [k, v] of b)
+          row[k] = v;
+      } else {
+        for (const s of select) {
+          const v = b.get(s);
+          if (v !== undefined)
+            row[s] = v;
+        }
+      }
+      return row;
+    });
+  }
+  _resolve(term, bindings) {
+    if (isLiteral(term))
+      return term.value;
+    return bindings.get(term.name);
+  }
+  _bind(term, value, bindings) {
+    if (isLiteral(term))
+      return term.value === value;
+    const existing = bindings.get(term.name);
+    if (existing !== undefined)
+      return existing === value;
+    bindings.set(term.name, value);
+    return true;
+  }
+  _dedup(bindings) {
+    const seen = new Set;
+    return bindings.filter((b) => {
+      const key = [...b.entries()].sort(([a], [b2]) => a.localeCompare(b2)).map(([k, v]) => `${k}=${v}`).join("\x00");
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+  }
+}
+
+// src/core/kernel/trellis-kernel.ts
+init_eav_store();
+async function hashOp(kind, timestamp, agentId, previousHash, payload) {
+  const data = `${kind}|${timestamp}|${agentId}|${previousHash ?? ""}|${payload}`;
+  const buf = new TextEncoder().encode(data);
+  const hashBuf = await crypto.subtle.digest("SHA-256", buf);
+  const hex = Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `trellis:op:${hex}`;
+}
+
+class TrellisKernel {
+  store;
+  backend;
+  middleware;
+  agentId;
+  snapshotThreshold;
+  opsSinceSnapshot = 0;
+  _booted = false;
+  constructor(config) {
+    this.store = new EAVStore;
+    this.backend = config.backend;
+    this.agentId = config.agentId;
+    this.middleware = config.middleware ?? [];
+    this.snapshotThreshold = config.snapshotThreshold ?? 0;
+  }
+  boot() {
+    this.backend.init();
+    let opsReplayed = 0;
+    let fromSnapshot = false;
+    const snapshot = this.backend.loadLatestSnapshot();
+    if (snapshot) {
+      this.store.restore(snapshot.data);
+      fromSnapshot = true;
+      const recentOps = this.backend.readAfter(snapshot.lastOpHash);
+      for (const op of recentOps) {
+        this._replayOp(op);
+        opsReplayed++;
+      }
+    } else {
+      const allOps = this.backend.readAll();
+      for (const op of allOps) {
+        this._replayOp(op);
+        opsReplayed++;
+      }
+    }
+    this._booted = true;
+    return { opsReplayed, fromSnapshot };
+  }
+  close() {
+    this.backend.close?.();
+    this._booted = false;
+  }
+  isBooted() {
+    return this._booted;
+  }
+  async mutate(kind, payload, ctx) {
+    const timestamp = new Date().toISOString();
+    const lastOp = this.backend.getLastOp();
+    const agentId = ctx?.agentId ?? this.agentId;
+    const payloadStr = JSON.stringify(payload);
+    const hash = await hashOp(kind, timestamp, agentId, lastOp?.hash, payloadStr);
+    const op = {
+      hash,
+      kind,
+      timestamp,
+      agentId,
+      previousHash: lastOp?.hash,
+      facts: [...payload.facts ?? []],
+      links: [...payload.links ?? []],
+      deleteFacts: payload.deleteFacts?.length ? [...payload.deleteFacts] : undefined,
+      deleteLinks: payload.deleteLinks?.length ? [...payload.deleteLinks] : undefined
+    };
+    const extOp = op;
+    if (payload.meta) {
+      for (const [k, v] of Object.entries(payload.meta)) {
+        extOp[k] = v;
+      }
+    }
+    const mwCtx = { agentId, ...ctx };
+    await this._runMiddleware(op, mwCtx);
+    let factsAdded = 0;
+    let factsDeleted = 0;
+    let linksAdded = 0;
+    let linksDeleted = 0;
+    if (payload.deleteFacts && payload.deleteFacts.length > 0) {
+      this.store.deleteFacts(payload.deleteFacts);
+      factsDeleted = payload.deleteFacts.length;
+    }
+    if (payload.deleteLinks && payload.deleteLinks.length > 0) {
+      this.store.deleteLinks(payload.deleteLinks);
+      linksDeleted = payload.deleteLinks.length;
+    }
+    if (payload.facts && payload.facts.length > 0) {
+      this.store.addFacts(payload.facts);
+      factsAdded = payload.facts.length;
+    }
+    if (payload.links && payload.links.length > 0) {
+      this.store.addLinks(payload.links);
+      linksAdded = payload.links.length;
+    }
+    this.backend.append(op);
+    this.opsSinceSnapshot++;
+    if (this.snapshotThreshold > 0 && this.opsSinceSnapshot >= this.snapshotThreshold) {
+      this.checkpoint();
+    }
+    return {
+      op,
+      factsDelta: { added: factsAdded, deleted: factsDeleted },
+      linksDelta: { added: linksAdded, deleted: linksDeleted }
+    };
+  }
+  checkpoint() {
+    const lastOp = this.backend.getLastOp();
+    if (!lastOp)
+      return;
+    this.backend.saveSnapshot(lastOp.hash, this.store.snapshot());
+    this.opsSinceSnapshot = 0;
+  }
+  getStore() {
+    return this.store;
+  }
+  getBackend() {
+    return this.backend;
+  }
+  getAgentId() {
+    return this.agentId;
+  }
+  readAllOps() {
+    return this.backend.readAll();
+  }
+  getLastOp() {
+    return this.backend.getLastOp();
+  }
+  createQueryEngine() {
+    return new QueryEngine(this.store);
+  }
+  async query(q) {
+    const engine = new QueryEngine(this.store);
+    const ctx = { agentId: this.agentId };
+    const chain = this.middleware.filter((m) => m.handleQuery);
+    if (chain.length === 0) {
+      return engine.execute(q);
+    }
+    let result;
+    let idx = 0;
+    const next = (query, context) => {
+      if (idx < chain.length) {
+        const mw = chain[idx++];
+        return mw.handleQuery(query, context, next);
+      }
+      result = engine.execute(query);
+      return result;
+    };
+    result = next(q, ctx);
+    return result;
+  }
+  timeTravel(opHash) {
+    const ops = this.backend.readUntil(opHash);
+    const snapshot = new EAVStore;
+    for (const op of ops) {
+      if (op.deleteFacts && op.deleteFacts.length > 0) {
+        snapshot.deleteFacts(op.deleteFacts);
+      }
+      if (op.deleteLinks && op.deleteLinks.length > 0) {
+        snapshot.deleteLinks(op.deleteLinks);
+      }
+      if (op.facts && op.facts.length > 0) {
+        snapshot.addFacts(op.facts);
+      }
+      if (op.links && op.links.length > 0) {
+        snapshot.addLinks(op.links);
+      }
+    }
+    return snapshot;
+  }
+  async createEntity(entityId, type, attributes = {}, links) {
+    const facts = [
+      { e: entityId, a: "type", v: type },
+      { e: entityId, a: "createdAt", v: new Date().toISOString() }
+    ];
+    for (const [attr, value] of Object.entries(attributes)) {
+      facts.push({ e: entityId, a: attr, v: value });
+    }
+    const linkRecords = (links ?? []).map((l) => ({
+      e1: entityId,
+      a: l.attribute,
+      e2: l.targetEntityId
+    }));
+    return this.mutate("addFacts", {
+      facts,
+      links: linkRecords.length > 0 ? linkRecords : undefined
+    });
+  }
+  getEntity(entityId) {
+    const facts = this.store.getFactsByEntity(entityId);
+    if (facts.length === 0)
+      return null;
+    const typeFact = facts.find((f) => f.a === "type");
+    return {
+      id: entityId,
+      type: typeFact?.v ?? "unknown",
+      facts,
+      links: this.store.getLinksByEntity(entityId)
+    };
+  }
+  async updateEntity(entityId, updates) {
+    const existingFacts = this.store.getFactsByEntity(entityId);
+    const deleteFacts = [];
+    const addFacts = [];
+    for (const [attr, newValue] of Object.entries(updates)) {
+      const existing = existingFacts.filter((f) => f.a === attr);
+      deleteFacts.push(...existing);
+      addFacts.push({ e: entityId, a: attr, v: newValue });
+    }
+    const updatedAtFacts = existingFacts.filter((f) => f.a === "updatedAt");
+    deleteFacts.push(...updatedAtFacts);
+    addFacts.push({ e: entityId, a: "updatedAt", v: new Date().toISOString() });
+    return this.mutate("addFacts", {
+      facts: addFacts,
+      deleteFacts
+    });
+  }
+  async deleteEntity(entityId) {
+    const facts = this.store.getFactsByEntity(entityId);
+    const links = this.store.getLinksByEntity(entityId);
+    return this.mutate("deleteFacts", {
+      deleteFacts: facts,
+      deleteLinks: links
+    });
+  }
+  listEntities(type, filters) {
+    let entityIds;
+    if (type) {
+      const typeFacts = this.store.getFactsByValue("type", type);
+      entityIds = new Set(typeFacts.map((f) => f.e));
+    } else {
+      const allTypeFacts = this.store.getFactsByAttribute("type");
+      entityIds = new Set(allTypeFacts.map((f) => f.e));
+    }
+    if (filters) {
+      for (const [attr, value] of Object.entries(filters)) {
+        const matchingFacts = this.store.getFactsByValue(attr, value);
+        const matchingEntities = new Set(matchingFacts.map((f) => f.e));
+        for (const id of entityIds) {
+          if (!matchingEntities.has(id)) {
+            entityIds.delete(id);
+          }
+        }
+      }
+    }
+    return Array.from(entityIds).map((id) => this.getEntity(id)).filter(Boolean);
+  }
+  async addLink(sourceId, attribute, targetId) {
+    return this.mutate("addLinks", {
+      links: [{ e1: sourceId, a: attribute, e2: targetId }]
+    });
+  }
+  async removeLink(sourceId, attribute, targetId) {
+    return this.mutate("deleteLinks", {
+      deleteLinks: [{ e1: sourceId, a: attribute, e2: targetId }]
+    });
+  }
+  async addFact(entityId, attribute, value) {
+    return this.mutate("addFacts", {
+      facts: [{ e: entityId, a: attribute, v: value }]
+    });
+  }
+  async removeFact(entityId, attribute, value) {
+    return this.mutate("deleteFacts", {
+      deleteFacts: [{ e: entityId, a: attribute, v: value }]
+    });
+  }
+  addMiddleware(mw) {
+    this.middleware.push(mw);
+  }
+  removeMiddleware(name) {
+    this.middleware = this.middleware.filter((m) => m.name !== name);
+  }
+  async _runMiddleware(op, ctx) {
+    const chain = [...this.middleware];
+    let idx = 0;
+    const next = async (op2, ctx2) => {
+      const mw = chain[idx++];
+      if (mw?.handleOp) {
+        await mw.handleOp(op2, ctx2, next);
+      }
+    };
+    if (chain.length > 0) {
+      await next(op, ctx);
+    }
+  }
+  _replayOp(op) {
+    if (op.deleteFacts && op.deleteFacts.length > 0) {
+      this.store.deleteFacts(op.deleteFacts);
+    }
+    if (op.deleteLinks && op.deleteLinks.length > 0) {
+      this.store.deleteLinks(op.deleteLinks);
+    }
+    if (op.facts && op.facts.length > 0) {
+      this.store.addFacts(op.facts);
+    }
+    if (op.links && op.links.length > 0) {
+      this.store.addLinks(op.links);
+    }
+  }
+}
+
+// src/core/persist/sqlite-backend.ts
+import { Database } from "bun:sqlite";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS ops (
+  hash TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  previous_hash TEXT,
+  payload TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  last_op_hash TEXT NOT NULL,
+  data TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS blobs (
+  hash TEXT PRIMARY KEY,
+  content BLOB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_ops_kind ON ops(kind);
+CREATE INDEX IF NOT EXISTS idx_ops_timestamp ON ops(timestamp);
+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;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = new Database(dbPath);
+  }
+  init() {
+    this.db.exec("PRAGMA journal_mode=WAL;");
+    this.db.exec("PRAGMA foreign_keys=ON;");
+    this.db.exec("PRAGMA synchronous=NORMAL;");
+    this.db.exec(SCHEMA_SQL);
+    this._prepareStatements();
+  }
+  _prepareStatements() {
+    this._stmts = {
+      insert: this.db.prepare(`
+        INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
+        VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)
+      `),
+      readAll: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops ORDER BY rowid ASC
+      `),
+      readUntil: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE rowid <= (SELECT rowid FROM ops WHERE hash = $hash)
+        ORDER BY rowid ASC
+      `),
+      readAfter: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE rowid > (SELECT rowid FROM ops WHERE hash = $hash)
+        ORDER BY rowid ASC
+      `),
+      getByHash: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops WHERE hash = $hash
+      `),
+      getLast: this.db.prepare(`
+        SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+        FROM ops ORDER BY rowid DESC LIMIT 1
+      `),
+      count: this.db.prepare("SELECT COUNT(*) as cnt FROM ops"),
+      saveSnapshot: this.db.prepare(`
+        INSERT INTO snapshots (last_op_hash, data)
+        VALUES ($lastOpHash, $data)
+      `),
+      loadSnapshot: this.db.prepare(`
+        SELECT last_op_hash, data FROM snapshots
+        ORDER BY id DESC LIMIT 1
+      `),
+      putBlob: this.db.prepare(`
+        INSERT OR IGNORE INTO blobs (hash, content) VALUES ($hash, $content)
+      `),
+      getBlob: this.db.prepare(`
+        SELECT content FROM blobs WHERE hash = $hash
+      `),
+      hasBlob: this.db.prepare(`
+        SELECT 1 FROM blobs WHERE hash = $hash
+      `)
+    };
+  }
+  append(op) {
+    const payload = JSON.stringify({
+      facts: op.facts,
+      links: op.links,
+      ...op.deleteFacts?.length ? { deleteFacts: op.deleteFacts } : {},
+      ...op.deleteLinks?.length ? { deleteLinks: op.deleteLinks } : {},
+      ...op.vcs ? { vcs: op.vcs } : {},
+      ...op.signature ? { signature: op.signature } : {}
+    });
+    this._stmts.insert.run({
+      $hash: op.hash,
+      $kind: op.kind,
+      $timestamp: op.timestamp,
+      $agentId: op.agentId,
+      $previousHash: op.previousHash ?? null,
+      $payload: payload
+    });
+  }
+  appendBatch(ops) {
+    if (ops.length === 0)
+      return;
+    this.db.transaction(() => {
+      for (const op of ops) {
+        this.append(op);
+      }
+    })();
+  }
+  readAll() {
+    const rows = this._stmts.readAll.all();
+    return rows.map(rowToOp);
+  }
+  readUntil(hash) {
+    const rows = this._stmts.readUntil.all({ $hash: hash });
+    return rows.map(rowToOp);
+  }
+  readAfter(hash) {
+    const rows = this._stmts.readAfter.all({ $hash: hash });
+    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 });
+    return rows.map(rowToOp);
+  }
+  getLastOp() {
+    const row = this._stmts.getLast.get();
+    return row ? rowToOp(row) : undefined;
+  }
+  getOpByHash(hash) {
+    const row = this._stmts.getByHash.get({ $hash: hash });
+    return row ? rowToOp(row) : undefined;
+  }
+  count() {
+    const row = this._stmts.count.get();
+    return row?.cnt ?? 0;
+  }
+  findCommonAncestor(hashA, hashB) {
+    const ancestorsA = new Set;
+    let cursor = hashA;
+    while (cursor) {
+      ancestorsA.add(cursor);
+      const op = this.getOpByHash(cursor);
+      cursor = op?.previousHash;
+    }
+    cursor = hashB;
+    while (cursor) {
+      if (ancestorsA.has(cursor)) {
+        return this.getOpByHash(cursor);
+      }
+      const op = this.getOpByHash(cursor);
+      cursor = op?.previousHash;
+    }
+    return;
+  }
+  saveSnapshot(lastOpHash, data) {
+    this._stmts.saveSnapshot.run({
+      $lastOpHash: lastOpHash,
+      $data: JSON.stringify(data)
+    });
+  }
+  loadLatestSnapshot() {
+    const row = this._stmts.loadSnapshot.get();
+    if (!row)
+      return;
+    return {
+      lastOpHash: row.last_op_hash,
+      data: JSON.parse(row.data)
+    };
+  }
+  putBlob(hash, content) {
+    this._stmts.putBlob.run({
+      $hash: hash,
+      $content: Buffer.from(content)
+    });
+  }
+  getBlob(hash) {
+    const row = this._stmts.getBlob.get({ $hash: hash });
+    if (!row)
+      return;
+    return new Uint8Array(row.content);
+  }
+  hasBlob(hash) {
+    return !!this._stmts.hasBlob.get({ $hash: hash });
+  }
+  close() {
+    this.db.close();
+  }
+}
+function rowToOp(row) {
+  const payload = JSON.parse(row.payload);
+  const op = {
+    hash: row.hash,
+    kind: row.kind,
+    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;
+  return op;
+}
+
+export { flatten, jsonEntityFacts, EAVStore, init_eav_store, variable, literal, QueryEngine, TrellisKernel, SqliteKernelBackend };