trellis 3.1.35 → 3.2.0

package/dist/chunk-S5PHSN5K.js

@@ -0,0 +1,907 @@
+import {
+  QueryEngine
+} from "./chunk-6CTA6MCE.js";
+import {
+  EAVStore,
+  init_eav_store
+} from "./chunk-4XIVMVHC.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}`;
+}
+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 };
+    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);
+    }
+  }
+};
+
+export {
+  TrellisKernel
+};