trellis 3.2.0 → 3.2.2

package/dist/chunk-5FGLQGMF.js

@@ -1,1676 +0,0 @@
-import {
-  EAVStore
-} from "./chunk-IXU4RMQM.js";
-import {
-  QueryEngine
-} from "./chunk-6CTA6MCE.js";
-import {
-  __require
-} from "./chunk-SIAA4J6H.js";
-
-// src/server/tenancy.ts
-import { existsSync, mkdirSync } from "fs";
-import { join, resolve } from "path";
-
-// 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}`;
-}
-var TrellisKernel = class {
-  store;
-  backend;
-  middleware;
-  agentId;
-  snapshotThreshold;
-  opsSinceSnapshot = 0;
-  _booted = false;
-  ontologies = /* @__PURE__ */ 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);
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-  /**
-   * Initialize the backend and replay persisted state.
-   * Loads latest snapshot if available, then replays ops after it.
-   */
-  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 the backend connection.
-   */
-  close() {
-    this.backend.close?.();
-    this._booted = false;
-  }
-  isBooted() {
-    return this._booted;
-  }
-  // -------------------------------------------------------------------------
-  // Mutations
-  // -------------------------------------------------------------------------
-  /**
-   * Apply a mutation to the graph. Creates an op, runs it through middleware,
-   * decomposes into EAV primitives, persists, and returns the result.
-   */
-  async mutate(kind, payload, ctx) {
-    const timestamp = (/* @__PURE__ */ 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] : void 0,
-      deleteLinks: payload.deleteLinks?.length ? [...payload.deleteLinks] : void 0
-    };
-    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 }
-    };
-  }
-  /**
-   * Create a snapshot of the current store state.
-   */
-  checkpoint() {
-    const lastOp = this.backend.getLastOp();
-    if (!lastOp) return;
-    this.backend.saveSnapshot(lastOp.hash, this.store.snapshot());
-    this.opsSinceSnapshot = 0;
-  }
-  // -------------------------------------------------------------------------
-  // Queries
-  // -------------------------------------------------------------------------
-  /**
-   * Get the underlying EAV store for direct queries.
-   */
-  getStore() {
-    return this.store;
-  }
-  /**
-   * Get the persistence backend.
-   */
-  getBackend() {
-    return this.backend;
-  }
-  /**
-   * Get the agent ID.
-   */
-  getAgentId() {
-    return this.agentId;
-  }
-  /**
-   * Read all persisted ops.
-   */
-  readAllOps() {
-    return this.backend.readAll();
-  }
-  /**
-   * Get the last persisted op.
-   */
-  getLastOp() {
-    return this.backend.getLastOp();
-  }
-  /**
-   * Create a QueryEngine bound to this kernel's store.
-   */
-  createQueryEngine() {
-    return new QueryEngine(this.store);
-  }
-  /**
-   * Execute an EQL-S query, routing through middleware handleQuery hooks.
-   * If no middleware intercepts, the query runs directly against the store.
-   */
-  async query(q) {
-    const engine = new QueryEngine(this.store);
-    const ctx = {
-      agentId: this.agentId,
-      store: this.store
-    };
-    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;
-  }
-  /**
-   * Time-travel: reconstruct the store state at a specific op hash.
-   * Returns a new EAVStore with state replayed up to (and including) that op.
-   */
-  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;
-  }
-  // -------------------------------------------------------------------------
-  // Entity CRUD (high-level graph operations)
-  // -------------------------------------------------------------------------
-  /**
-   * Create a new entity with the given type and attributes.
-   * Returns the entity ID.
-   */
-  async createEntity(entityId, type, attributes = {}, links) {
-    const facts = [
-      { e: entityId, a: "type", v: type },
-      { e: entityId, a: "createdAt", v: (/* @__PURE__ */ 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 : void 0
-    });
-  }
-  /**
-   * Get an entity by ID, returning all its facts and links.
-   */
-  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)
-    };
-  }
-  /**
-   * Update an entity's attributes. Deletes old values and adds new ones.
-   */
-  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: (/* @__PURE__ */ new Date()).toISOString() });
-    return this.mutate("addFacts", {
-      facts: addFacts,
-      deleteFacts
-    });
-  }
-  /**
-   * Delete an entity and all its facts and links.
-   */
-  async deleteEntity(entityId) {
-    const facts = this.store.getFactsByEntity(entityId);
-    const links = this.store.getLinksByEntity(entityId);
-    return this.mutate("deleteFacts", {
-      deleteFacts: facts,
-      deleteLinks: links
-    });
-  }
-  /**
-   * List entities by type, with optional attribute filters.
-   */
-  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);
-  }
-  /**
-   * Add a link between two entities.
-   */
-  async addLink(sourceId, attribute, targetId) {
-    return this.mutate("addLinks", {
-      links: [{ e1: sourceId, a: attribute, e2: targetId }]
-    });
-  }
-  /**
-   * Remove a link between two entities.
-   */
-  async removeLink(sourceId, attribute, targetId) {
-    return this.mutate("deleteLinks", {
-      deleteLinks: [{ e1: sourceId, a: attribute, e2: targetId }]
-    });
-  }
-  /**
-   * Add a fact to an entity.
-   */
-  async addFact(entityId, attribute, value) {
-    return this.mutate("addFacts", {
-      facts: [{ e: entityId, a: attribute, v: value }]
-    });
-  }
-  /**
-   * Remove a fact from an entity.
-   */
-  async removeFact(entityId, attribute, value) {
-    return this.mutate("deleteFacts", {
-      deleteFacts: [{ e: entityId, a: attribute, v: value }]
-    });
-  }
-  // -------------------------------------------------------------------------
-  // Ontology CRUD
-  // -------------------------------------------------------------------------
-  /**
-   * Get an ontology schema by ID.
-   */
-  getOntology(id) {
-    return this.ontologies.get(id);
-  }
-  /**
-   * List all ontologies.
-   */
-  listOntologies() {
-    return Array.from(this.ontologies.values());
-  }
-  /**
-   * Create a new ontology schema.
-   */
-  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]);
-  }
-  /**
-   * Update an existing ontology schema.
-   */
-  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);
-  }
-  /**
-   * Delete an ontology schema.
-   */
-  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);
-  }
-  // -------------------------------------------------------------------------
-  // Workspace
-  // -------------------------------------------------------------------------
-  /**
-   * Boot the kernel with a workspace configuration.
-   * Loads ontologies, projections, and seed data.
-   */
-  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();
-  }
-  /**
-   * Export the current workspace configuration.
-   */
-  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 : void 0,
-        graph: { nodes, edges },
-        projections: this.workspaceConfig?.workspace.projections,
-        routes: this.workspaceConfig?.workspace.routes,
-        app: this.workspaceConfig?.workspace.app
-      }
-    };
-  }
-  // -------------------------------------------------------------------------
-  // TQL Compatibility Aliases
-  // -------------------------------------------------------------------------
-  /**
-   * Create a node (alias for createEntity with schema validation).
-   */
-  async createNode(id, data, type, _ctx) {
-    return this.createEntity(id, type, data);
-  }
-  /**
-   * Update a node (alias for updateEntity with schema validation).
-   */
-  async updateNode(id, data, type, _ctx) {
-    return this.updateEntity(id, data);
-  }
-  /**
-   * Delete a node (alias for deleteEntity).
-   */
-  async deleteNode(id, _ctx) {
-    return this.deleteEntity(id);
-  }
-  /**
-   * Link two nodes (alias for addLink).
-   */
-  async link(e1, a, e2, _ctx) {
-    return this.addLink(e1, a, e2);
-  }
-  /**
-   * Unlink two nodes (alias for removeLink).
-   */
-  async unlink(e1, a, e2, _ctx) {
-    return this.removeLink(e1, a, e2);
-  }
-  // -------------------------------------------------------------------------
-  // Middleware
-  // -------------------------------------------------------------------------
-  addMiddleware(mw) {
-    this.middleware.push(mw);
-  }
-  removeMiddleware(name) {
-    this.middleware = this.middleware.filter((m) => m.name !== name);
-  }
-  // -------------------------------------------------------------------------
-  // Internal
-  // -------------------------------------------------------------------------
-  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/computation/expr-evaluator.ts
-var ExprEvaluator = class {
-  functions;
-  constructor() {
-    this.functions = /* @__PURE__ */ new Map([
-      ["$if", this.if.bind(this)],
-      ["$round", this.round.bind(this)],
-      ["$concat", this.concat.bind(this)],
-      ["$len", this.len.bind(this)],
-      ["$lower", this.lower.bind(this)],
-      ["$upper", this.upper.bind(this)],
-      ["$trim", this.trim.bind(this)],
-      ["$now", this.now.bind(this)],
-      ["$uuid", this.uuid.bind(this)],
-      ["$add", this.add.bind(this)],
-      ["$sub", this.sub.bind(this)],
-      ["$mul", this.mul.bind(this)],
-      ["$div", this.div.bind(this)],
-      ["$mod", this.mod.bind(this)],
-      ["$eq", this.eq.bind(this)],
-      ["$ne", this.ne.bind(this)],
-      ["$gt", this.gt.bind(this)],
-      ["$gte", this.gte.bind(this)],
-      ["$lt", this.lt.bind(this)],
-      ["$lte", this.lte.bind(this)],
-      ["$and", this.and.bind(this)],
-      ["$or", this.or.bind(this)],
-      ["$not", this.not.bind(this)],
-      ["$coalesce", this.coalesce.bind(this)],
-      ["$contains", this.contains.bind(this)],
-      ["$startsWith", this.startsWith.bind(this)],
-      ["$endsWith", this.endsWith.bind(this)]
-    ]);
-  }
-  /**
-   * Evaluate an expression string against a context.
-   */
-  eval(expr, context) {
-    const trimmed = expr.trim();
-    const fnMatch = trimmed.match(/^(\$\w+)\((.*)\)$/s);
-    if (fnMatch) {
-      const fnName = fnMatch[1];
-      const argsStr = fnMatch[2];
-      const fn = this.functions.get(fnName);
-      if (!fn) {
-        throw new Error(`Unknown function: ${fnName}`);
-      }
-      return this.evalFunction(fn, argsStr, context);
-    }
-    if (trimmed.startsWith("$")) {
-      const field = trimmed.slice(1);
-      return context[field];
-    }
-    if (trimmed === "true") return true;
-    if (trimmed === "false") return false;
-    if (trimmed === "null") return null;
-    const num = Number(trimmed);
-    if (!isNaN(num) && trimmed !== "") return num;
-    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-      return trimmed.slice(1, -1);
-    }
-    return trimmed;
-  }
-  evalFunction(fn, argsStr, context) {
-    const args = this.parseArgs(argsStr, context);
-    return fn(...args);
-  }
-  parseArgs(argsStr, context) {
-    const args = [];
-    let depth = 0;
-    let current = "";
-    for (let i = 0; i < argsStr.length; i++) {
-      const char = argsStr[i];
-      if (char === "(" || char === "[" || char === "{") depth++;
-      else if (char === ")" || char === "]" || char === "}") depth--;
-      else if (char === "," && depth === 0) {
-        args.push(this.eval(current.trim(), context));
-        current = "";
-        continue;
-      }
-      current += char;
-    }
-    if (current.trim()) {
-      args.push(this.eval(current.trim(), context));
-    }
-    return args;
-  }
-  // Built-in functions
-  if(cond, trueVal, falseVal) {
-    return cond ? trueVal : falseVal;
-  }
-  round(value, decimals = 0) {
-    const n = Number(value);
-    const factor = Math.pow(10, Number(decimals));
-    return Math.round(n * factor) / factor;
-  }
-  concat(...args) {
-    return args.map((a) => String(a ?? "")).join("");
-  }
-  len(value) {
-    if (typeof value === "string") return value.length;
-    if (Array.isArray(value)) return value.length;
-    return 0;
-  }
-  lower(value) {
-    return String(value ?? "").toLowerCase();
-  }
-  upper(value) {
-    return String(value ?? "").toUpperCase();
-  }
-  trim(value) {
-    return String(value ?? "").trim();
-  }
-  now() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  uuid() {
-    return crypto.randomUUID();
-  }
-  add(...args) {
-    return args.reduce((sum, a) => sum + Number(a), 0);
-  }
-  sub(a, b) {
-    return Number(a) - Number(b);
-  }
-  mul(...args) {
-    return args.reduce((prod, a) => prod * Number(a), 1);
-  }
-  div(a, b) {
-    return Number(a) / Number(b);
-  }
-  mod(a, b) {
-    return Number(a) % Number(b);
-  }
-  eq(a, b) {
-    return a === b;
-  }
-  ne(a, b) {
-    return a !== b;
-  }
-  gt(a, b) {
-    return Number(a) > Number(b);
-  }
-  gte(a, b) {
-    return Number(a) >= Number(b);
-  }
-  lt(a, b) {
-    return Number(a) < Number(b);
-  }
-  lte(a, b) {
-    return Number(a) <= Number(b);
-  }
-  and(...args) {
-    return args.every(Boolean);
-  }
-  or(...args) {
-    return args.some(Boolean);
-  }
-  not(value) {
-    return !value;
-  }
-  coalesce(...args) {
-    for (const arg of args) {
-      if (arg !== null && arg !== void 0) return arg;
-    }
-    return null;
-  }
-  contains(haystack, needle) {
-    return String(haystack ?? "").includes(String(needle ?? ""));
-  }
-  startsWith(str, prefix) {
-    return String(str ?? "").startsWith(String(prefix ?? ""));
-  }
-  endsWith(str, suffix) {
-    return String(str ?? "").endsWith(String(suffix ?? ""));
-  }
-};
-function evalExpr(expr, context) {
-  const result = new ExprEvaluator().eval(expr, context);
-  if (result === null || result === void 0) return "";
-  if (typeof result === "boolean") return result ? "true" : "false";
-  if (typeof result === "number") return result;
-  if (typeof result === "string") return result;
-  if (typeof result === "object") return JSON.stringify(result);
-  return String(result);
-}
-
-// src/core/computation/rollup.ts
-function collectRollupRelatedIds(rollup, ctx) {
-  if (rollup.joinEntity) {
-    const { type, foreignKey } = rollup.joinEntity;
-    const facts = ctx.store.getFactsByAttribute(foreignKey);
-    const ids = [];
-    for (const fact of facts) {
-      if (fact.v !== ctx.entityId) continue;
-      const typeFacts = ctx.store.getFactsByEntity(fact.e);
-      const entityType = typeFacts.find((f2) => f2.a === "type")?.v;
-      if (entityType === type) ids.push(fact.e);
-    }
-    return ids;
-  }
-  const linkAttr = resolveLinkAttribute(rollup.relationProperty, ctx.schema);
-  const links = ctx.store.getLinksByEntityAndAttribute(ctx.entityId, linkAttr);
-  if (links.length > 0) return links.map((l) => l.e2);
-  return [];
-}
-function resolveLinkAttribute(relationProperty, schema) {
-  const field = schema?.fields.find((f2) => f2.name === relationProperty);
-  if (field?.valueType === "relation") return relationProperty;
-  return relationProperty;
-}
-function readTargetValue(store, entityId, targetProperty) {
-  if (targetProperty === "id") return entityId;
-  const facts = store.getFactsByEntity(entityId);
-  return facts.find((f2) => f2.a === targetProperty)?.v;
-}
-function toNumbers(values) {
-  const nums = [];
-  for (const v of values) {
-    if (typeof v === "number" && Number.isFinite(v)) nums.push(v);
-  }
-  return nums;
-}
-function evaluateRollup(rollup, ctx) {
-  const related = collectRollupRelatedIds(rollup, ctx);
-  if (rollup.aggregation === "count") {
-    return related.length;
-  }
-  const values = related.map((id) => readTargetValue(ctx.store, id, rollup.targetProperty)).filter((v) => v !== void 0);
-  const nums = toNumbers(values);
-  if (nums.length === 0) return 0;
-  switch (rollup.aggregation) {
-    case "sum":
-      return nums.reduce((a, b) => a + b, 0);
-    case "avg":
-      return nums.reduce((a, b) => a + b, 0) / nums.length;
-    case "min":
-      return Math.min(...nums);
-    case "max":
-      return Math.max(...nums);
-    case "median": {
-      const sorted = [...nums].sort((a, b) => a - b);
-      const mid = Math.floor(sorted.length / 2);
-      return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-    }
-    case "mode": {
-      const freq = /* @__PURE__ */ new Map();
-      for (const n of nums) freq.set(n, (freq.get(n) ?? 0) + 1);
-      let best = nums[0];
-      let bestCount = 0;
-      for (const [n, c] of freq) {
-        if (c > bestCount) {
-          best = n;
-          bestCount = c;
-        }
-      }
-      return best;
-    }
-    default:
-      return 0;
-  }
-}
-function projectRelationFields(binding, schema, store, entityId) {
-  for (const field of schema.fields) {
-    if (field.valueType !== "relation" || field.name in binding) continue;
-    const links = store.getLinksByEntityAndAttribute(entityId, field.name);
-    if (links.length === 0) continue;
-    const cardinality = field.relation?.cardinality ?? "many";
-    if (cardinality === "one") {
-      binding[field.name] = links[0].e2;
-    } else {
-      binding[field.name] = links.map((l) => l.e2).join(",");
-    }
-  }
-}
-
-// src/core/kernel/logic-middleware.ts
-function createLogicMiddleware(config) {
-  return {
-    name: "logic-computation",
-    handleQuery(query, ctx, next) {
-      const result = next(query);
-      if (result && Array.isArray(result.bindings)) {
-        const store = resolveStore(config, ctx);
-        for (const binding of result.bindings) {
-          enrichBinding(binding, config, store);
-        }
-      }
-      return result;
-    }
-  };
-}
-function resolveStore(config, ctx) {
-  if (config.getStore) return config.getStore();
-  return ctx.store;
-}
-function enrichBinding(binding, config, store) {
-  const row = binding;
-  const type = resolveEntityType(binding, config);
-  if (!type) return;
-  const schema = config.ontologies.get(type);
-  if (!schema) return;
-  const entityId = findEntityId(binding);
-  if (store && entityId) {
-    projectRelationFields(binding, schema, store, entityId);
-  }
-  for (const field of schema.fields) {
-    if (!(field.computed || field.formula || field.rollup || field.aiGenerated))
-      continue;
-    const fieldName = field.name;
-    if (fieldName in binding) continue;
-    if (field.formula) {
-      binding[fieldName] = evalExpr(field.formula, row);
-    }
-    if (field.rollup && store && entityId) {
-      binding[fieldName] = evaluateRollup(field.rollup, {
-        store,
-        entityId,
-        schema,
-        getEntityType: config.getEntityType
-      });
-    }
-    if (field.aiGenerated && config.generateAiField) {
-      const prompt = field.aiGenerated.prompt.replace(
-        /\{\{(\w+)\}\}/g,
-        (_, key) => String(row[key] ?? "")
-      );
-      config.generateAiField(prompt, row).then((value) => {
-        binding[fieldName] = value;
-      }).catch(() => {
-        binding[fieldName] = "";
-      });
-    }
-  }
-}
-function resolveEntityType(binding, config) {
-  const explicit = binding.type;
-  if (typeof explicit === "string" && explicit.length > 0) return explicit;
-  const entityId = findEntityId(binding);
-  if (entityId && config.getEntityType) {
-    return config.getEntityType(entityId);
-  }
-  return void 0;
-}
-function findEntityId(binding) {
-  for (const value of Object.values(binding)) {
-    if (typeof value === "string" && value.includes(":")) return value;
-  }
-  return void 0;
-}
-
-// src/core/kernel/boot-middleware.ts
-function buildOntologyIndex(schemas) {
-  const map = /* @__PURE__ */ new Map();
-  for (const schema of schemas) {
-    map.set(schema["@id"], schema);
-    const short = schema["@id"].includes(":") ? schema["@id"].split(":").pop() : schema["@id"];
-    if (short) {
-      map.set(short, schema);
-      map.set(short.toLowerCase(), schema);
-    }
-    if (schema.label) {
-      map.set(schema.label, schema);
-      map.set(schema.label.toLowerCase(), schema);
-    }
-  }
-  return map;
-}
-function attachStandardMiddleware(kernel) {
-  kernel.removeMiddleware("logic-computation");
-  const ontologies = buildOntologyIndex(kernel.listOntologies());
-  kernel.addMiddleware(
-    createLogicMiddleware({
-      ontologies,
-      getStore: () => kernel.getStore(),
-      getEntityType: (entityId) => kernel.getEntity(entityId)?.type
-    })
-  );
-}
-
-// src/core/persist/sqlite-backend.ts
-var _DatabaseCtor = null;
-function loadDatabaseCtor() {
-  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."
-    );
-  }
-}
-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);
-`;
-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;");
-    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
-      `)
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Op operations
-  // -------------------------------------------------------------------------
-  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) : void 0;
-  }
-  getByHash(hash) {
-    return this.getOpByHash(hash);
-  }
-  getOpCount() {
-    return this.count();
-  }
-  getOpByHash(hash) {
-    const row = this._stmts.getByHash.get({ $hash: hash });
-    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 = /* @__PURE__ */ 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 void 0;
-  }
-  // -------------------------------------------------------------------------
-  // Snapshot operations
-  // -------------------------------------------------------------------------
-  saveSnapshot(lastOpHash, data) {
-    this._stmts.saveSnapshot.run({
-      $lastOpHash: lastOpHash,
-      $data: JSON.stringify(data)
-    });
-  }
-  loadLatestSnapshot() {
-    const row = this._stmts.loadSnapshot.get();
-    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,
-      $content: Buffer.from(content)
-    });
-  }
-  getBlob(hash) {
-    const row = this._stmts.getBlob.get({ $hash: hash });
-    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 = {
-    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;
-}
-
-// src/server/tenancy.ts
-var DEFAULT_TENANT = "default";
-var TENANTS_DIR = "tenants";
-var TenantPool = class {
-  pool = /* @__PURE__ */ new Map();
-  dbPath;
-  agentId;
-  backendOpts;
-  constructor(dbPath, agentIdOrOpts = "trellis-db") {
-    this.dbPath = resolve(dbPath);
-    if (typeof agentIdOrOpts === "string") {
-      this.agentId = agentIdOrOpts;
-      this.backendOpts = void 0;
-    } else {
-      this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
-      this.backendOpts = agentIdOrOpts.backend;
-    }
-    this._ensureDirs();
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  /**
-   * Get (or create) the kernel for a tenant.
-   * Pass `null` or `undefined` to get the default tenant.
-   *
-   * Uses the synchronous bun:sqlite backend. To use an async backend
-   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
-   * `get()` calls will return the preloaded kernel from the pool.
-   */
-  get(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    if (!this.pool.has(id)) {
-      this.pool.set(id, this._createKernelSync(id));
-    }
-    return this.pool.get(id);
-  }
-  /**
-   * Pre-create a tenant's kernel using the runtime-selected backend.
-   * Required when running with an async-only backend (sql.js / WebContainer
-   * / browser). Idempotent — safe to call multiple times.
-   *
-   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
-   * synchronously from the pool.
-   */
-  async preload(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    const cached = this.pool.get(id);
-    if (cached) return cached;
-    const kernel = await this._createKernelAsync(id);
-    this.pool.set(id, kernel);
-    return kernel;
-  }
-  /**
-   * Check whether a tenant has been initialized (kernel created).
-   */
-  has(tenantId) {
-    return this.pool.has(tenantId);
-  }
-  /**
-   * List all active tenant IDs (those with open kernels).
-   */
-  activeTenants() {
-    return Array.from(this.pool.keys());
-  }
-  /**
-   * Close a specific tenant's kernel and remove it from the pool.
-   */
-  close(tenantId) {
-    const kernel = this.pool.get(tenantId);
-    if (kernel) {
-      kernel.close();
-      this.pool.delete(tenantId);
-    }
-  }
-  /**
-   * Close all kernels and clear the pool.
-   */
-  closeAll() {
-    for (const kernel of this.pool.values()) {
-      kernel.close();
-    }
-    this.pool.clear();
-  }
-  /**
-   * Return the SQLite file path for a given tenant.
-   */
-  dbFilePath(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    if (id === DEFAULT_TENANT) {
-      return join(this.dbPath, "default.sqlite");
-    }
-    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _createKernelSync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const backend = new SqliteKernelBackend(sqlitePath);
-    return this._wrapKernel(backend);
-  }
-  async _createKernelAsync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const { createKernelBackend } = await import("./factory-YP4ZZK5K.js");
-    const backend = await createKernelBackend(sqlitePath, this.backendOpts);
-    return this._wrapKernel(backend);
-  }
-  _wrapKernel(backend) {
-    const kernel = new TrellisKernel({
-      backend,
-      agentId: this.agentId,
-      snapshotThreshold: 1e3
-    });
-    kernel.boot();
-    attachStandardMiddleware(kernel);
-    return kernel;
-  }
-  _ensureDirs() {
-    if (!existsSync(this.dbPath)) {
-      mkdirSync(this.dbPath, { recursive: true });
-    }
-    const tenantsPath = join(this.dbPath, TENANTS_DIR);
-    if (!existsSync(tenantsPath)) {
-      mkdirSync(tenantsPath, { recursive: true });
-    }
-  }
-};
-
-export {
-  DEFAULT_TENANT,
-  TenantPool
-};