trellis 3.1.35 → 3.2.0

package/dist/chunk-XMQ7G77X.js

@@ -0,0 +1,260 @@
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// 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;
+}
+
+export {
+  SqliteKernelBackend
+};

package/dist/chunk-XZQ66K7A.js

@@ -0,0 +1,124 @@
+import {
+  entitiesQuery,
+  resolveRelations
+} from "./chunk-FOWKR5TW.js";
+import {
+  bindingEntityId,
+  bindingToEntity,
+  isSparseBinding
+} from "./chunk-5CINODKT.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/live.ts
+function liveQuery(client, eql) {
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(eql, (rows) => {
+          signal.value = { data: rows, loading: false, error: null };
+        });
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+function normalizeLiveEntitiesOpts(whereOrOpts) {
+  if (!whereOrOpts) return {};
+  if ("resolve" in whereOrOpts || "where" in whereOrOpts) {
+    return whereOrOpts;
+  }
+  return { where: whereOrOpts };
+}
+function liveEntities(client, typeOrSchema, whereOrOpts) {
+  const schema = typeof typeOrSchema === "string" ? void 0 : typeOrSchema;
+  const type = typeof typeOrSchema === "string" ? typeOrSchema : typeOrSchema.type;
+  const { where, resolve } = normalizeLiveEntitiesOpts(whereOrOpts);
+  const signal = new Signal({
+    data: [],
+    loading: true,
+    error: null
+  });
+  let sub = null;
+  let token = 0;
+  return {
+    signal,
+    start() {
+      if (sub) return () => stop();
+      try {
+        sub = client.subscribe(
+          entitiesQuery(type, where),
+          (rows) => {
+            const turn = ++token;
+            const hydrate = async () => {
+              if (rows.length === 0) return [];
+              if (rows.some((r) => isSparseBinding(r))) {
+                const ids = rows.map((r) => bindingEntityId(r)).filter((id) => Boolean(id));
+                const loaded = await Promise.all(ids.map((id) => client.read(id)));
+                return loaded.filter((e) => e != null);
+              }
+              return rows.map((r) => bindingToEntity(r));
+            };
+            hydrate().then(async (entities) => {
+              if (turn !== token) return;
+              let data = entities;
+              if (schema && resolve && Object.keys(resolve).length > 0) {
+                data = await resolveRelations(
+                  client,
+                  schema,
+                  data,
+                  resolve
+                );
+              }
+              if (turn !== token) return;
+              signal.value = { data, loading: false, error: null };
+            }).catch((err) => {
+              if (turn !== token) return;
+              signal.value = {
+                data: signal.peek().data,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err))
+              };
+            });
+          }
+        );
+      } catch (err) {
+        signal.value = {
+          data: [],
+          loading: false,
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+      return () => stop();
+    }
+  };
+  function stop() {
+    token++;
+    sub?.unsubscribe();
+    sub = null;
+  }
+}
+
+export {
+  liveQuery,
+  liveEntities
+};

package/dist/{index-w7ng765c.js → chunk-YCM7ZYEZ.js}

@@ -1,21 +1,30 @@
-// @bun
 // src/core/ontology/registry.ts
-class OntologyRegistry {
-  schemas = new Map;
-  resolvedEntities = new Map;
-  resolvedRelations = new Map;
+var OntologyRegistry = class {
+  schemas = /* @__PURE__ */ new Map();
+  /** Resolved entity defs (with inherited attributes merged). */
+  resolvedEntities = /* @__PURE__ */ new Map();
+  /** Resolved relation defs. */
+  resolvedRelations = /* @__PURE__ */ new Map();
+  /**
+   * Register an ontology schema.
+   * Throws if an ontology with the same ID is already registered at the same version.
+   */
   register(schema) {
     const existing = this.schemas.get(schema.id);
     if (existing && existing.version === schema.version) {
-      throw new Error(`Ontology "${schema.id}" v${schema.version} is already registered.`);
+      throw new Error(
+        `Ontology "${schema.id}" v${schema.version} is already registered.`
+      );
     }
     this.schemas.set(schema.id, schema);
     this._resolve(schema);
   }
+  /**
+   * Unregister an ontology by ID.
+   */
   unregister(id) {
     const schema = this.schemas.get(id);
-    if (!schema)
-      return;
+    if (!schema) return;
     for (const [name, entry] of this.resolvedEntities) {
       if (entry.ontologyId === id) {
         this.resolvedEntities.delete(name);
@@ -31,21 +40,41 @@ class OntologyRegistry {
     }
     this.schemas.delete(id);
   }
+  /**
+   * Get a registered ontology schema by ID.
+   */
   get(id) {
     return this.schemas.get(id);
   }
+  /**
+   * List all registered ontology schemas.
+   */
   list() {
     return [...this.schemas.values()];
   }
+  /**
+   * Get the resolved entity definition for an entity type name.
+   * Returns the entity def with inherited attributes merged in.
+   */
   getEntityDef(typeName) {
     return this.resolvedEntities.get(typeName)?.def;
   }
+  /**
+   * Get the ontology ID that defines a given entity type.
+   */
   getEntityOntology(typeName) {
     return this.resolvedEntities.get(typeName)?.ontologyId;
   }
+  /**
+   * List all known entity type names.
+   */
   listEntityTypes() {
     return [...this.resolvedEntities.keys()];
   }
+  /**
+   * Get all relation definitions involving a given entity type
+   * (either as source or target).
+   */
   getRelationsForType(typeName) {
     const results = [];
     for (const [, entries] of this.resolvedRelations) {
@@ -57,22 +86,36 @@ class OntologyRegistry {
     }
     return results;
   }
+  /**
+   * Get a specific relation definition by name.
+   */
   getRelationDef(name) {
     const entries = this.resolvedRelations.get(name);
     return entries?.[0]?.def;
   }
+  /**
+   * List all known relation names.
+   */
   listRelationNames() {
     return [...this.resolvedRelations.keys()];
   }
+  /**
+   * Check if an entity type is known to any registered ontology.
+   */
   hasEntityType(typeName) {
     return this.resolvedEntities.has(typeName);
   }
+  /**
+   * Get the required attributes for an entity type.
+   */
   getRequiredAttributes(typeName) {
     const def = this.getEntityDef(typeName);
-    if (!def)
-      return [];
+    if (!def) return [];
     return def.attributes.filter((a) => a.required);
   }
+  // -------------------------------------------------------------------------
+  // Resolution (inheritance)
+  // -------------------------------------------------------------------------
   _resolve(schema) {
     for (const entity of schema.entities) {
       const resolved = this._resolveEntity(entity, schema);
@@ -88,15 +131,16 @@ class OntologyRegistry {
     }
   }
   _resolveEntity(entity, schema) {
-    if (!entity.extends)
-      return entity;
+    if (!entity.extends) return entity;
     let parent = schema.entities.find((e) => e.name === entity.extends);
     if (!parent) {
       const resolved = this.resolvedEntities.get(entity.extends);
       parent = resolved?.def;
     }
     if (!parent) {
-      throw new Error(`Entity "${entity.name}" extends "${entity.extends}" which is not defined.`);
+      throw new Error(
+        `Entity "${entity.name}" extends "${entity.extends}" which is not defined.`
+      );
     }
     const resolvedParent = this._resolveEntity(parent, schema);
     const childAttrNames = new Set(entity.attributes.map((a) => a.name));
@@ -109,7 +153,7 @@ class OntologyRegistry {
       attributes: mergedAttrs
     };
   }
-}
+};
 
 // src/core/ontology/builtins.ts
 var projectOntology = {
@@ -386,8 +430,7 @@ function validateEntity(entityId, store, registry) {
     }
   }
   for (const fact of facts) {
-    if (fact.a === "type" || fact.a === "createdAt" || fact.a === "updatedAt")
-      continue;
+    if (fact.a === "type" || fact.a === "createdAt" || fact.a === "updatedAt") continue;
     const attrDef = def.attributes.find((a) => a.name === fact.a);
     if (!attrDef) {
       warnings.push({
@@ -429,7 +472,7 @@ function validateEntity(entityId, store, registry) {
         });
       }
     }
-    if (attrDef.min !== undefined) {
+    if (attrDef.min !== void 0) {
       if (typeof fact.v === "number" && fact.v < attrDef.min) {
         errors.push({
           entityId,
@@ -449,7 +492,7 @@ function validateEntity(entityId, store, registry) {
         });
       }
     }
-    if (attrDef.max !== undefined) {
+    if (attrDef.max !== void 0) {
       if (typeof fact.v === "number" && fact.v > attrDef.max) {
         errors.push({
           entityId,
@@ -472,11 +515,9 @@ function validateEntity(entityId, store, registry) {
   }
   const links = store.getLinksByEntity(entityId);
   for (const link of links) {
-    if (link.e1 !== entityId)
-      continue;
+    if (link.e1 !== entityId) continue;
     const relDef = registry.getRelationDef(link.a);
-    if (!relDef)
-      continue;
+    if (!relDef) continue;
     if (!relDef.sourceTypes.includes(entityType)) {
       errors.push({
         entityId,
@@ -521,32 +562,26 @@ function validateStore(store, registry) {
   };
 }
 function validateAttrType(value, def) {
-  if (def.type === "any")
-    return null;
+  if (def.type === "any") return null;
   switch (def.type) {
     case "string":
-      if (typeof value !== "string")
-        return `Expected string, got ${typeof value}.`;
+      if (typeof value !== "string") return `Expected string, got ${typeof value}.`;
       break;
     case "number":
-      if (typeof value !== "number")
-        return `Expected number, got ${typeof value}.`;
+      if (typeof value !== "number") return `Expected number, got ${typeof value}.`;
       break;
     case "boolean":
-      if (typeof value !== "boolean")
-        return `Expected boolean, got ${typeof value}.`;
+      if (typeof value !== "boolean") return `Expected boolean, got ${typeof value}.`;
       break;
     case "date":
       if (typeof value === "string") {
-        if (isNaN(Date.parse(value)))
-          return `Expected ISO date string, got "${value}".`;
+        if (isNaN(Date.parse(value))) return `Expected ISO date string, got "${value}".`;
       } else if (!(value instanceof Date)) {
         return `Expected date, got ${typeof value}.`;
       }
       break;
     case "ref":
-      if (typeof value !== "string")
-        return `Expected entity reference (string), got ${typeof value}.`;
+      if (typeof value !== "string") return `Expected entity reference (string), got ${typeof value}.`;
       break;
   }
   return null;
@@ -558,45 +593,53 @@ function createValidationMiddleware(registry, options) {
     handleOp: (op, ctx, next) => {
       if (op.facts && op.facts.length > 0) {
         for (const fact of op.facts) {
-          if (fact.a === "type")
-            continue;
-          if (fact.a === "createdAt" || fact.a === "updatedAt")
-            continue;
+          if (fact.a === "type") continue;
+          if (fact.a === "createdAt" || fact.a === "updatedAt") continue;
           const typeFact = op.facts.find((f) => f.e === fact.e && f.a === "type");
-          if (!typeFact)
-            continue;
+          if (!typeFact) continue;
           const entityType = String(typeFact.v);
           const def = registry.getEntityDef(entityType);
           if (!def) {
             if (strict) {
-              throw new Error(`[ontology-validator] Unknown entity type "${entityType}" for entity "${fact.e}".`);
+              throw new Error(
+                `[ontology-validator] Unknown entity type "${entityType}" for entity "${fact.e}".`
+              );
             }
             continue;
           }
           const attrDef = def.attributes.find((a) => a.name === fact.a);
           if (!attrDef) {
             if (strict) {
-              throw new Error(`[ontology-validator] Unknown attribute "${fact.a}" for type "${entityType}".`);
+              throw new Error(
+                `[ontology-validator] Unknown attribute "${fact.a}" for type "${entityType}".`
+              );
             }
             continue;
           }
           const typeErr = validateAttrType(fact.v, attrDef);
           if (typeErr) {
-            throw new Error(`[ontology-validator] Entity "${fact.e}" attribute "${fact.a}": ${typeErr}`);
+            throw new Error(
+              `[ontology-validator] Entity "${fact.e}" attribute "${fact.a}": ${typeErr}`
+            );
           }
           if (attrDef.enum && !attrDef.enum.includes(fact.v)) {
-            throw new Error(`[ontology-validator] Entity "${fact.e}" attribute "${fact.a}": value "${fact.v}" not in [${attrDef.enum.join(", ")}].`);
+            throw new Error(
+              `[ontology-validator] Entity "${fact.e}" attribute "${fact.a}": value "${fact.v}" not in [${attrDef.enum.join(", ")}].`
+            );
           }
         }
       }
       if (op.links && op.links.length > 0) {
         for (const link of op.links) {
           const relDef = registry.getRelationDef(link.a);
-          if (!relDef)
-            continue;
-          const sourceTypeFact = op.facts?.find((f) => f.e === link.e1 && f.a === "type");
+          if (!relDef) continue;
+          const sourceTypeFact = op.facts?.find(
+            (f) => f.e === link.e1 && f.a === "type"
+          );
           if (sourceTypeFact && !relDef.sourceTypes.includes(String(sourceTypeFact.v))) {
-            throw new Error(`[ontology-validator] Relation "${link.a}": source type "${sourceTypeFact.v}" not allowed (expected: ${relDef.sourceTypes.join(", ")}).`);
+            throw new Error(
+              `[ontology-validator] Relation "${link.a}": source type "${sourceTypeFact.v}" not allowed (expected: ${relDef.sourceTypes.join(", ")}).`
+            );
           }
         }
       }
@@ -604,4 +647,14 @@ function createValidationMiddleware(registry, options) {
     }
   };
 }
-export { OntologyRegistry, projectOntology, teamOntology, agentOntology, builtinOntologies, validateEntity, validateStore, createValidationMiddleware };
+
+export {
+  OntologyRegistry,
+  projectOntology,
+  teamOntology,
+  agentOntology,
+  builtinOntologies,
+  validateEntity,
+  validateStore,
+  createValidationMiddleware
+};