trellis 2.1.7 → 3.0.2

package/dist/index-0zk3fx2s.js

@@ -0,0 +1,1004 @@
+// @bun
+import {
+  EAVStore,
+  init_eav_store
+} from "./index-yhwjgfvj.js";
+import {
+  QueryEngine
+} from "./index-yp88he8n.js";
+
+// src/core/kernel/trellis-kernel.ts
+init_eav_store();
+
+// src/core/ontology/core-ontology.ts
+var VERSION = "1.0.0";
+function f(name, valueType, opts) {
+  return { name, valueType, ...opts };
+}
+var thing = {
+  "@id": "core:Thing",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  label: "Thing",
+  icon: "lucide:box",
+  fields: [
+    f("id", "title", { required: true }),
+    f("createdAt", "date"),
+    f("updatedAt", "date"),
+    f("createdBy", "relation", {
+      relation: { targetSchema: "core:Member", cardinality: "one" }
+    }),
+    f("tags", "multi_select")
+  ]
+};
+var record = {
+  "@id": "core:Record",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Record",
+  icon: "lucide:file",
+  fields: [
+    f("title", "title", { required: true }),
+    f("description", "rich_text"),
+    f("status", "select"),
+    f("tags", "multi_select")
+  ]
+};
+var document = {
+  "@id": "core:Document",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Record",
+  label: "Document",
+  icon: "lucide:file-text",
+  fields: [
+    f("content", "rich_text"),
+    f("mimeType", "rich_text"),
+    f("fileUrl", "url")
+  ]
+};
+var event = {
+  "@id": "core:Event",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Record",
+  label: "Event",
+  icon: "lucide:calendar",
+  fields: [
+    f("startDate", "date"),
+    f("endDate", "date"),
+    f("location", "rich_text"),
+    f("allDay", "checkbox")
+  ]
+};
+var collection = {
+  "@id": "core:Collection",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Collection",
+  icon: "lucide:database",
+  fields: [
+    f("title", "title", { required: true }),
+    f("description", "rich_text"),
+    f("icon", "rich_text"),
+    f("schema", "rich_text"),
+    f("recordType", "relation", {
+      relation: { targetSchema: "core:Record", cardinality: "one" }
+    })
+  ]
+};
+var tag = {
+  "@id": "core:Tag",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Tag",
+  icon: "lucide:tag",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("color", "rich_text"),
+    f("icon", "rich_text"),
+    f("parentTag", "relation", {
+      relation: { targetSchema: "core:Tag", cardinality: "one" }
+    })
+  ]
+};
+var workspace = {
+  "@id": "core:Workspace",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Workspace",
+  icon: "lucide:building-2",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("avatar", "files"),
+    f("plan", "select")
+  ]
+};
+var app = {
+  "@id": "core:App",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "App",
+  icon: "lucide:layout-grid",
+  fields: [
+    f("name", "title", { required: true }),
+    f("slug", "rich_text"),
+    f("icon", "rich_text"),
+    f("color", "rich_text"),
+    f("description", "rich_text"),
+    f("ontologies", "multi_select")
+  ]
+};
+var member = {
+  "@id": "core:Member",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Member",
+  icon: "lucide:user",
+  fields: [
+    f("name", "title", { required: true }),
+    f("email", "email"),
+    f("avatar", "files"),
+    f("role", "select", {
+      required: true,
+      selectOptions: ["owner", "admin", "member", "guest"],
+      defaultValue: "member"
+    }),
+    f("status", "select", {
+      required: true,
+      selectOptions: ["pending", "active", "suspended"],
+      defaultValue: "pending"
+    }),
+    f("orgId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("userId", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("invitedAt", "date"),
+    f("joinedAt", "date")
+  ]
+};
+var notification = {
+  "@id": "core:Notification",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Notification",
+  icon: "lucide:bell",
+  fields: [
+    f("recipientId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("orgId", "relation", {
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("orgName", "rich_text"),
+    f("type", "select", {
+      required: true,
+      selectOptions: [
+        "invite_accepted",
+        "invite_sent",
+        "member_joined",
+        "member_removed",
+        "role_changed",
+        "mention",
+        "comment",
+        "entity_updated",
+        "system"
+      ]
+    }),
+    f("title", "title", { required: true }),
+    f("message", "rich_text", { required: true }),
+    f("actionUrl", "url"),
+    f("icon", "rich_text"),
+    f("variant", "select", {
+      selectOptions: ["default", "success", "warning", "destructive", "info"]
+    }),
+    f("isRead", "checkbox", { defaultValue: false }),
+    f("actorId", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("actorName", "rich_text"),
+    f("metadata", "rich_text"),
+    f("createdAt", "date", { required: true })
+  ]
+};
+var share = {
+  "@id": "core:Share",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Share",
+  icon: "lucide:share-2",
+  fields: [
+    f("entityId", "relation", { required: true }),
+    f("entityType", "select", { selectOptions: ["entity", "collection"] }),
+    f("userId", "relation", {
+      required: true,
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("orgId", "relation", {
+      relation: { targetSchema: "core:Workspace", cardinality: "one" }
+    }),
+    f("permission", "select", {
+      required: true,
+      selectOptions: ["view", "comment", "edit"],
+      defaultValue: "view"
+    }),
+    f("sharedBy", "relation", {
+      relation: { targetSchema: "core:Person", cardinality: "one" }
+    }),
+    f("createdAt", "date", { required: true })
+  ]
+};
+var person = {
+  "@id": "core:Person",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Person",
+  icon: "lucide:user",
+  fields: [f("name", "title", { required: true })]
+};
+var workflow = {
+  "@id": "core:Workflow",
+  "@type": "trellis:Schema",
+  version: VERSION,
+  tier: "core",
+  subClassOf: "core:Thing",
+  label: "Workflow",
+  icon: "lucide:git-branch",
+  fields: [
+    f("name", "title", { required: true }),
+    f("trigger", "rich_text"),
+    f("steps", "multi_select"),
+    f("active", "checkbox")
+  ]
+};
+var CORE_ONTOLOGY = [
+  thing,
+  record,
+  document,
+  event,
+  collection,
+  tag,
+  workspace,
+  app,
+  member,
+  notification,
+  share,
+  person,
+  workflow
+];
+
+// src/core/kernel/trellis-kernel.ts
+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;
+  ontologies = new Map;
+  workspaceConfig = null;
+  autoReplay = true;
+  constructor(config) {
+    this.store = new EAVStore;
+    this.backend = config.backend;
+    this.agentId = config.agentId;
+    this.middleware = config.middleware ?? [];
+    this.snapshotThreshold = config.snapshotThreshold ?? 0;
+    this.autoReplay = config.autoReplay ?? true;
+    for (const schema of CORE_ONTOLOGY) {
+      this.ontologies.set(schema["@id"], schema);
+    }
+  }
+  boot() {
+    this.backend.init();
+    if (!this.autoReplay) {
+      this._booted = true;
+      return { opsReplayed: 0, fromSnapshot: false };
+    }
+    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((f2) => f2.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((f2) => f2.a === attr);
+      deleteFacts.push(...existing);
+      addFacts.push({ e: entityId, a: attr, v: newValue });
+    }
+    const updatedAtFacts = existingFacts.filter((f2) => f2.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((f2) => f2.e));
+    } else {
+      const allTypeFacts = this.store.getFactsByAttribute("type");
+      entityIds = new Set(allTypeFacts.map((f2) => f2.e));
+    }
+    if (filters) {
+      for (const [attr, value] of Object.entries(filters)) {
+        const matchingFacts = this.store.getFactsByValue(attr, value);
+        const matchingEntities = new Set(matchingFacts.map((f2) => f2.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 }]
+    });
+  }
+  getOntology(id) {
+    return this.ontologies.get(id);
+  }
+  listOntologies() {
+    return Array.from(this.ontologies.values());
+  }
+  createOntology(schema) {
+    const tier = schema.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot modify core ontologies");
+    }
+    if (this.ontologies.has(schema["@id"])) {
+      throw new Error(`Ontology ${schema["@id"]} already exists`);
+    }
+    this.ontologies.set(schema["@id"], schema);
+    const fact = {
+      e: schema["@id"],
+      a: "schema",
+      v: JSON.stringify(schema)
+    };
+    this.store.addFacts([fact]);
+  }
+  updateOntology(id, updates) {
+    const existing = this.ontologies.get(id);
+    if (!existing) {
+      throw new Error(`Ontology ${id} not found`);
+    }
+    const tier = existing.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot modify core ontologies");
+    }
+    const updated = { ...existing, ...updates };
+    this.ontologies.set(id, updated);
+    const existingFacts = this.store.getFactsByEntity(id);
+    const schemaFacts = existingFacts.filter((f2) => f2.a === "schema");
+    const deleteFacts = [...schemaFacts];
+    const addFacts = [
+      {
+        e: id,
+        a: "schema",
+        v: JSON.stringify(updated)
+      }
+    ];
+    this.store.deleteFacts(deleteFacts);
+    this.store.addFacts(addFacts);
+  }
+  deleteOntology(id) {
+    const existing = this.ontologies.get(id);
+    if (!existing) {
+      throw new Error(`Ontology ${id} not found`);
+    }
+    const tier = existing.tier ?? "user";
+    if (tier === "core") {
+      throw new Error("Cannot delete core ontologies");
+    }
+    this.ontologies.delete(id);
+    const facts = this.store.getFactsByEntity(id);
+    this.store.deleteFacts(facts);
+  }
+  bootWorkspace(config) {
+    this.workspaceConfig = config;
+    if (config.workspace.ontologies) {
+      for (const [id, schema] of Object.entries(config.workspace.ontologies)) {
+        if (!this.ontologies.has(id)) {
+          this.ontologies.set(id, schema);
+        }
+      }
+    }
+    if (config.workspace.graph?.nodes) {
+      for (const node of config.workspace.graph.nodes) {
+        const n = node;
+        if (n.id && n.type) {
+          const facts = [
+            { e: String(n.id), a: "type", v: String(n.type) }
+          ];
+          for (const [key, value] of Object.entries(n)) {
+            if (key !== "id" && key !== "type") {
+              facts.push({ e: String(n.id), a: key, v: value });
+            }
+          }
+          this.store.addFacts(facts);
+        }
+      }
+    }
+    if (config.workspace.graph?.edges) {
+      for (const edge of config.workspace.graph.edges) {
+        const e = edge;
+        if (e.source && e.target && e.relation) {
+          this.store.addLinks([
+            {
+              e1: String(e.source),
+              a: String(e.relation),
+              e2: String(e.target)
+            }
+          ]);
+        }
+      }
+    }
+    this.boot();
+  }
+  exportWorkspace() {
+    const ontologies = {};
+    for (const [id, schema] of this.ontologies) {
+      if (schema.tier !== "core") {
+        ontologies[id] = schema;
+      }
+    }
+    const allFacts = this.store.getAllFacts();
+    const nodes = [];
+    const entityIds = new Set(allFacts.map((f2) => f2.e));
+    for (const id of entityIds) {
+      const facts = this.store.getFactsByEntity(id);
+      const typeFact = facts.find((f2) => f2.a === "type");
+      const node = { id };
+      if (typeFact) {
+        node.type = typeFact.v;
+      }
+      for (const fact of facts) {
+        if (fact.a !== "type") {
+          node[fact.a] = fact.v;
+        }
+      }
+      nodes.push(node);
+    }
+    const allLinks = this.store.getAllLinks();
+    const edges = allLinks.map((l) => ({
+      source: l.e1,
+      relation: l.a,
+      target: l.e2
+    }));
+    return {
+      workspace: {
+        name: this.workspaceConfig?.workspace.name,
+        description: this.workspaceConfig?.workspace.description,
+        ontologies: Object.keys(ontologies).length > 0 ? ontologies : undefined,
+        graph: { nodes, edges },
+        projections: this.workspaceConfig?.workspace.projections,
+        routes: this.workspaceConfig?.workspace.routes,
+        app: this.workspaceConfig?.workspace.app
+      }
+    };
+  }
+  async createNode(id, data, type, _ctx) {
+    return this.createEntity(id, type, data);
+  }
+  async updateNode(id, data, type, _ctx) {
+    return this.updateEntity(id, data);
+  }
+  async deleteNode(id, _ctx) {
+    return this.deleteEntity(id);
+  }
+  async link(e1, a, e2, _ctx) {
+    return this.addLink(e1, a, e2);
+  }
+  async unlink(e1, a, e2, _ctx) {
+    return this.removeLink(e1, a, e2);
+  }
+  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;
+  }
+  getByHash(hash) {
+    return this.getOpByHash(hash);
+  }
+  getOpCount() {
+    return this.count();
+  }
+  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 { TrellisKernel, SqliteKernelBackend };