trellis 3.1.35 → 3.2.2

package/dist/{index-4wxa8xz4.js → chunk-KQ4A2D2P.js}

@@ -1,11 +1,10 @@
-// @bun
 import {
   QueryEngine
-} from "./index-yp88he8n.js";
+} from "./chunk-6CTA6MCE.js";
 import {
   EAVStore,
   init_eav_store
-} from "./index-yhwjgfvj.js";
+} from "./chunk-4XIVMVHC.js";
 
 // src/core/kernel/trellis-kernel.ts
 init_eav_store();
@@ -302,8 +301,7 @@ async function hashOp(kind, timestamp, agentId, previousHash, payload) {
   const hex = Array.from(new Uint8Array(hashBuf)).map((b) => b.toString(16).padStart(2, "0")).join("");
   return `trellis:op:${hex}`;
 }
-
-class TrellisKernel {
+var TrellisKernel = class {
   store;
   backend;
   middleware;
@@ -311,11 +309,11 @@ class TrellisKernel {
   snapshotThreshold;
   opsSinceSnapshot = 0;
   _booted = false;
-  ontologies = new Map;
+  ontologies = /* @__PURE__ */ new Map();
   workspaceConfig = null;
   autoReplay = true;
   constructor(config) {
-    this.store = new EAVStore;
+    this.store = new EAVStore();
     this.backend = config.backend;
     this.agentId = config.agentId;
     this.middleware = config.middleware ?? [];
@@ -325,6 +323,13 @@ class TrellisKernel {
       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) {
@@ -352,6 +357,9 @@ class TrellisKernel {
     this._booted = true;
     return { opsReplayed, fromSnapshot };
   }
+  /**
+   * Close the backend connection.
+   */
   close() {
     this.backend.close?.();
     this._booted = false;
@@ -359,12 +367,25 @@ class TrellisKernel {
   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 = new Date().toISOString();
+    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 hash = await hashOp(
+      kind,
+      timestamp,
+      agentId,
+      lastOp?.hash,
+      payloadStr
+    );
     const op = {
       hash,
       kind,
@@ -373,8 +394,8 @@ class TrellisKernel {
       previousHash: lastOp?.hash,
       facts: [...payload.facts ?? []],
       links: [...payload.links ?? []],
-      deleteFacts: payload.deleteFacts?.length ? [...payload.deleteFacts] : undefined,
-      deleteLinks: payload.deleteLinks?.length ? [...payload.deleteLinks] : undefined
+      deleteFacts: payload.deleteFacts?.length ? [...payload.deleteFacts] : void 0,
+      deleteLinks: payload.deleteLinks?.length ? [...payload.deleteLinks] : void 0
     };
     const extOp = op;
     if (payload.meta) {
@@ -415,34 +436,64 @@ class TrellisKernel {
       linksDelta: { added: linksAdded, deleted: linksDeleted }
     };
   }
+  /**
+   * Create a snapshot of the current store state.
+   */
   checkpoint() {
     const lastOp = this.backend.getLastOp();
-    if (!lastOp)
-      return;
+    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 ctx = {
+      agentId: this.agentId,
+      store: this.store
+    };
     const chain = this.middleware.filter((m) => m.handleQuery);
     if (chain.length === 0) {
       return engine.execute(q);
@@ -460,9 +511,13 @@ class TrellisKernel {
     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;
+    const snapshot = new EAVStore();
     for (const op of ops) {
       if (op.deleteFacts && op.deleteFacts.length > 0) {
         snapshot.deleteFacts(op.deleteFacts);
@@ -479,10 +534,17 @@ class TrellisKernel {
     }
     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: new Date().toISOString() }
+      { 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 });
@@ -494,13 +556,15 @@ class TrellisKernel {
     }));
     return this.mutate("addFacts", {
       facts,
-      links: linkRecords.length > 0 ? linkRecords : undefined
+      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;
+    if (facts.length === 0) return null;
     const typeFact = facts.find((f2) => f2.a === "type");
     return {
       id: entityId,
@@ -509,6 +573,9 @@ class TrellisKernel {
       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 = [];
@@ -520,12 +587,15 @@ class TrellisKernel {
     }
     const updatedAtFacts = existingFacts.filter((f2) => f2.a === "updatedAt");
     deleteFacts.push(...updatedAtFacts);
-    addFacts.push({ e: entityId, a: "updatedAt", v: new Date().toISOString() });
+    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);
@@ -534,6 +604,9 @@ class TrellisKernel {
       deleteLinks: links
     });
   }
+  /**
+   * List entities by type, with optional attribute filters.
+   */
   listEntities(type, filters) {
     let entityIds;
     if (type) {
@@ -556,32 +629,56 @@ class TrellisKernel {
     }
     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") {
@@ -598,6 +695,9 @@ class TrellisKernel {
     };
     this.store.addFacts([fact]);
   }
+  /**
+   * Update an existing ontology schema.
+   */
   updateOntology(id, updates) {
     const existing = this.ontologies.get(id);
     if (!existing) {
@@ -622,6 +722,9 @@ class TrellisKernel {
     this.store.deleteFacts(deleteFacts);
     this.store.addFacts(addFacts);
   }
+  /**
+   * Delete an ontology schema.
+   */
   deleteOntology(id) {
     const existing = this.ontologies.get(id);
     if (!existing) {
@@ -635,6 +738,13 @@ class TrellisKernel {
     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) {
@@ -676,6 +786,9 @@ class TrellisKernel {
     }
     this.boot();
   }
+  /**
+   * Export the current workspace configuration.
+   */
   exportWorkspace() {
     const ontologies = {};
     for (const [id, schema] of this.ontologies) {
@@ -710,7 +823,7 @@ class TrellisKernel {
       workspace: {
         name: this.workspaceConfig?.workspace.name,
         description: this.workspaceConfig?.workspace.description,
-        ontologies: Object.keys(ontologies).length > 0 ? ontologies : undefined,
+        ontologies: Object.keys(ontologies).length > 0 ? ontologies : void 0,
         graph: { nodes, edges },
         projections: this.workspaceConfig?.workspace.projections,
         routes: this.workspaceConfig?.workspace.routes,
@@ -718,27 +831,51 @@ class TrellisKernel {
       }
     };
   }
+  // -------------------------------------------------------------------------
+  // 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;
@@ -766,6 +903,8 @@ class TrellisKernel {
       this.store.addLinks(op.links);
     }
   }
-}
+};
 
-export { TrellisKernel };
+export {
+  TrellisKernel
+};