trellis 3.1.35 → 3.2.2

package/dist/{index-h9e2efx4.js → chunk-LNUIGRDZ.js}

@@ -1,7 +1,6 @@
-// @bun
 import {
   __require
-} from "./index-a76rekgs.js";
+} from "./chunk-KFQGP6VL.js";
 
 // src/core/persist/sqljs-backend.ts
 var SCHEMA_SQL = `
@@ -29,20 +28,23 @@ CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
 CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
 CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
 `;
-
-class SqlJsKernelBackend {
-  opts;
+var SqlJsKernelBackend = class _SqlJsKernelBackend {
+  constructor(opts) {
+    this.opts = opts;
+    this.flushEvery = opts.autoFlushEvery ?? 50;
+  }
   db;
   stmts;
   writes = 0;
   flushEvery;
   initialized = false;
-  constructor(opts) {
-    this.opts = opts;
-    this.flushEvery = opts.autoFlushEvery ?? 50;
-  }
+  /**
+   * Async factory — sql.js WASM init is async, but the resulting backend
+   * exposes the synchronous KernelBackend surface, so it slots into the
+   * existing kernel without interface changes.
+   */
   static async create(opts) {
-    const backend = new SqlJsKernelBackend(opts);
+    const backend = new _SqlJsKernelBackend(opts);
     await backend.bootstrap();
     return backend;
   }
@@ -52,7 +54,9 @@ class SqlJsKernelBackend {
       const mod = await import("sql.js");
       initSqlJs = mod.default ?? mod;
     } catch (e) {
-      throw new Error('SqlJsKernelBackend requires the optional dependency "sql.js". Install it: npm install sql.js');
+      throw new Error(
+        'SqlJsKernelBackend requires the optional dependency "sql.js". Install it: npm install sql.js'
+      );
     }
     let sqljsDistDir = null;
     if (typeof window === "undefined") {
@@ -68,31 +72,26 @@ class SqlJsKernelBackend {
     }
     const SQL = await initSqlJs({
       locateFile: (file) => {
-        if (typeof window !== "undefined")
-          return `/sql-wasm/${file}`;
-        if (sqljsDistDir)
-          return `${sqljsDistDir}/${file}`;
+        if (typeof window !== "undefined") return `/sql-wasm/${file}`;
+        if (sqljsDistDir) return `${sqljsDistDir}/${file}`;
         return file;
       }
     });
     const existing = this.loadFromDisk();
-    this.db = existing ? new SQL.Database(existing) : new SQL.Database;
+    this.db = existing ? new SQL.Database(existing) : new SQL.Database();
   }
   loadFromDisk() {
-    if (this.opts.dbPath === ":memory:")
-      return null;
+    if (this.opts.dbPath === ":memory:") return null;
     try {
       const fs = __require("fs");
-      if (!fs.existsSync(this.opts.dbPath))
-        return null;
+      if (!fs.existsSync(this.opts.dbPath)) return null;
       return new Uint8Array(fs.readFileSync(this.opts.dbPath));
     } catch {
       return null;
     }
   }
   flushToDisk() {
-    if (this.opts.dbPath === ":memory:")
-      return;
+    if (this.opts.dbPath === ":memory:") return;
     try {
       const fs = __require("fs");
       const path = __require("path");
@@ -101,34 +100,50 @@ class SqlJsKernelBackend {
       const tmp = `${this.opts.dbPath}.tmp`;
       fs.writeFileSync(tmp, Buffer.from(data));
       fs.renameSync(tmp, this.opts.dbPath);
-    } catch {}
+    } catch {
+    }
   }
   init() {
-    if (this.initialized)
-      return;
+    if (this.initialized) return;
     this.db.exec(SCHEMA_SQL);
     this.prepareStatements();
     this.initialized = true;
   }
   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
+      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
+         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`),
+         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`)
+      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`
+      )
     };
   }
   append(op) {
@@ -161,8 +176,10 @@ class SqlJsKernelBackend {
     return this.runAll(this.stmts.readAfter, { $hash: hash });
   }
   readUntilTimestamp(iso) {
-    const stmt = this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-       FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`);
+    const stmt = this.db.prepare(
+      `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+       FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`
+    );
     const rows = this.runAll(stmt, { $ts: iso });
     stmt.free();
     return rows;
@@ -193,7 +210,7 @@ class SqlJsKernelBackend {
     const has = this.stmts.loadSnapshot.step();
     if (!has) {
       this.stmts.loadSnapshot.reset();
-      return;
+      return void 0;
     }
     const row = this.stmts.loadSnapshot.getAsObject();
     this.stmts.loadSnapshot.reset();
@@ -203,36 +220,33 @@ class SqlJsKernelBackend {
     try {
       this.flushToDisk();
     } finally {
-      for (const s of Object.values(this.stmts ?? {}))
-        s?.free?.();
+      for (const s of Object.values(this.stmts ?? {})) s?.free?.();
       this.db?.close?.();
     }
   }
+  /** Force a write of the in-memory DB image to disk. */
   flush() {
     this.flushToDisk();
   }
   runAll(stmt, params = {}) {
     stmt.bind(params);
     const rows = [];
-    while (stmt.step())
-      rows.push(rowToOp(stmt.getAsObject()));
+    while (stmt.step()) rows.push(rowToOp(stmt.getAsObject()));
     stmt.reset();
     return rows;
   }
   runOne(stmt, params = {}) {
     stmt.bind(params);
     const has = stmt.step();
-    const row = has ? stmt.getAsObject() : undefined;
+    const row = has ? stmt.getAsObject() : void 0;
     stmt.reset();
-    return row ? rowToOp(row) : undefined;
+    return row ? rowToOp(row) : void 0;
   }
   tickFlush() {
-    if (this.flushEvery === 0)
-      return;
-    if (++this.writes % this.flushEvery === 0)
-      this.flushToDisk();
+    if (this.flushEvery === 0) return;
+    if (++this.writes % this.flushEvery === 0) this.flushToDisk();
   }
-}
+};
 function rowToOp(row) {
   const payload = JSON.parse(row.payload);
   return {
@@ -240,7 +254,7 @@ function rowToOp(row) {
     kind: row.kind,
     timestamp: row.timestamp,
     agentId: row.agent_id,
-    previousHash: row.previous_hash ?? undefined,
+    previousHash: row.previous_hash ?? void 0,
     facts: payload.facts,
     links: payload.links,
     deleteFacts: payload.deleteFacts,
@@ -248,4 +262,6 @@ function rowToOp(row) {
   };
 }
 
-export { SqlJsKernelBackend };
+export {
+  SqlJsKernelBackend
+};

package/dist/{index-skhn0agf.js → chunk-MLC5BUYO.js}

@@ -1,11 +1,7 @@
-// @bun
 import {
   init_eav_store,
   jsonEntityFacts
-} from "./index-yhwjgfvj.js";
-import {
-  __require
-} from "./index-a76rekgs.js";
+} from "./chunk-4XIVMVHC.js";
 
 // src/server/import.ts
 init_eav_store();
@@ -25,7 +21,9 @@ async function importFile(kernel, filePath, opts) {
     case ".parquet":
       return importParquet(kernel, filePath, opts);
     default:
-      throw new Error(`Unsupported file format: ${ext}. Supported: .json, .ndjson, .jsonl, .csv, .tsv, .parquet`);
+      throw new Error(
+        `Unsupported file format: ${ext}. Supported: .json, .ndjson, .jsonl, .csv, .tsv, .parquet`
+      );
   }
 }
 async function importRecords(kernel, records, opts) {
@@ -39,8 +37,7 @@ async function importJson(kernel, filePath, opts) {
 }
 async function importNdjson(kernel, filePath, opts) {
   const raw = readFileSync(filePath, "utf8");
-  const rows = raw.split(`
-`).map((l) => l.trim()).filter(Boolean).map((line, i) => {
+  const rows = raw.split("\n").map((l) => l.trim()).filter(Boolean).map((line, i) => {
     try {
       return JSON.parse(line);
     } catch {
@@ -51,20 +48,18 @@ async function importNdjson(kernel, filePath, opts) {
 }
 async function importCsv(kernel, filePath, opts) {
   const raw = readFileSync(filePath, "utf8");
-  const sep = filePath.endsWith(".tsv") ? "\t" : ",";
+  const sep = filePath.endsWith(".tsv") ? "	" : ",";
   const rows = parseCsv(raw, sep);
   return _ingestRows(kernel, rows, opts);
 }
 function parseCsv(raw, sep = ",") {
   const lines = raw.split(/\r?\n/);
-  if (lines.length < 2)
-    return [];
+  if (lines.length < 2) return [];
   const headers = splitCsvLine(lines[0], sep);
   const result = [];
-  for (let i = 1;i < lines.length; i++) {
+  for (let i = 1; i < lines.length; i++) {
     const line = lines[i];
-    if (!line || line.trim() === "")
-      continue;
+    if (!line || line.trim() === "") continue;
     const values = splitCsvLine(line, sep);
     const row = {};
     headers.forEach((h, idx) => {
@@ -78,7 +73,7 @@ function splitCsvLine(line, sep) {
   const result = [];
   let current = "";
   let inQuotes = false;
-  for (let i = 0;i < line.length; i++) {
+  for (let i = 0; i < line.length; i++) {
     const ch = line[i];
     if (ch === '"') {
       if (inQuotes && line[i + 1] === '"') {
@@ -105,7 +100,9 @@ async function importParquet(kernel, filePath, opts) {
     try {
       parquet = await import("@dsnp/parquetjs");
     } catch {
-      throw new Error("Parquet support requires `parquetjs` or `@dsnp/parquetjs`.\nRun: bun add parquetjs");
+      throw new Error(
+        "Parquet support requires `parquetjs` or `@dsnp/parquetjs`.\nRun: bun add parquetjs"
+      );
     }
   }
   const reader = await parquet.ParquetReader.openFile(filePath);
@@ -127,9 +124,8 @@ async function _ingestRows(kernel, rows, opts) {
   };
   const limit = opts.limit ?? Infinity;
   let count = 0;
-  for (let i = 0;i < rows.length; i++) {
-    if (count >= limit)
-      break;
+  for (let i = 0; i < rows.length; i++) {
+    if (count >= limit) break;
     const row = rows[i];
     if (!row || opts.skipEmpty && Object.keys(row).length === 0) {
       result.skipped++;
@@ -152,4 +148,7 @@ async function _ingestRows(kernel, rows, opts) {
   return result;
 }
 
-export { importFile, importRecords };
+export {
+  importFile,
+  importRecords
+};

package/dist/chunk-MPXUVGT3.js

@@ -0,0 +1,104 @@
+// src/vcs/idb-op-log.ts
+var IdbOpLog = class {
+  ops = [];
+  hashes = /* @__PURE__ */ new Set();
+  db = null;
+  nextSeq = 0;
+  pendingWrites = Promise.resolve();
+  dbName;
+  storeName;
+  factory;
+  constructor(opts) {
+    this.dbName = opts.dbName;
+    this.storeName = opts.storeName ?? "ops";
+    const factory = opts.indexedDB ?? globalThis.indexedDB;
+    if (!factory) {
+      throw new Error(
+        "IdbOpLog requires IndexedDB. Pass `indexedDB` in options for non-browser hosts."
+      );
+    }
+    this.factory = factory;
+  }
+  async load() {
+    this.db = await this.openDb();
+    const records = await this.readAllRecords();
+    records.sort((a, b) => a.seq - b.seq);
+    this.ops = records.map((r) => r.op);
+    this.hashes = new Set(this.ops.map((op) => op.hash));
+    this.nextSeq = records.length > 0 ? records[records.length - 1].seq + 1 : 0;
+  }
+  append(op) {
+    if (this.hashes.has(op.hash)) return;
+    if (!this.db) {
+      throw new Error("IdbOpLog.append() called before load(). Await load() first.");
+    }
+    this.ops.push(op);
+    this.hashes.add(op.hash);
+    const seq = this.nextSeq++;
+    const record = { hash: op.hash, seq, op };
+    this.pendingWrites = this.pendingWrites.then(() => this.putRecord(record));
+  }
+  readAll() {
+    return [...this.ops];
+  }
+  getLastOp() {
+    return this.ops.length > 0 ? this.ops[this.ops.length - 1] : void 0;
+  }
+  count() {
+    return this.ops.length;
+  }
+  async flush() {
+    await this.pendingWrites;
+  }
+  async close() {
+    await this.flush();
+    this.db?.close();
+    this.db = null;
+  }
+  // --- private ---------------------------------------------------------------
+  openDb() {
+    return new Promise((resolve, reject) => {
+      const request = this.factory.open(this.dbName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          const store = db.createObjectStore(this.storeName, { keyPath: "hash" });
+          store.createIndex("seq", "seq", { unique: true });
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB open failed."));
+      request.onblocked = () => reject(new Error(`IDB open blocked for database '${this.dbName}'.`));
+    });
+  }
+  readAllRecords() {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error("IdbOpLog: database not open."));
+        return;
+      }
+      const tx = this.db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.getAll();
+      request.onsuccess = () => resolve(request.result ?? []);
+      request.onerror = () => reject(request.error ?? new Error("IdbOpLog.getAll() failed."));
+    });
+  }
+  putRecord(record) {
+    return new Promise((resolve, reject) => {
+      if (!this.db) {
+        reject(new Error("IdbOpLog: database not open."));
+        return;
+      }
+      const tx = this.db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const request = store.put(record);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error ?? new Error("IdbOpLog.put() failed."));
+    });
+  }
+};
+
+export {
+  IdbOpLog
+};

package/dist/chunk-N6MYZT4O.js

@@ -0,0 +1,68 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/vcs/types.ts
+function fileEntityId(path) {
+  return `file:${path}`;
+}
+function dirEntityId(path) {
+  return `dir:${path}`;
+}
+function branchEntityId(name) {
+  return `branch:${name}`;
+}
+function milestoneEntityId(hash) {
+  return `milestone:${hash}`;
+}
+function checkpointEntityId(hash) {
+  return `checkpoint:${hash}`;
+}
+function issueEntityId(id) {
+  return id.startsWith("issue:") ? id : `issue:${id}`;
+}
+function criterionEntityId(issueId, index) {
+  const bare = issueId.replace(/^issue:/, "");
+  return `criterion:${bare}:ac-${index}`;
+}
+function decisionEntityId(id) {
+  return id.startsWith("decision:") ? id : `decision:${id}`;
+}
+function laneEntityId(id) {
+  return id.startsWith("lane:") ? id : `lane:${id}`;
+}
+var DEFAULT_CONFIG;
+var init_types = __esm({
+  "src/vcs/types.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      ignorePatterns: [
+        "node_modules",
+        ".git",
+        ".trellis",
+        "dist",
+        "build",
+        ".DS_Store",
+        "*.log"
+      ],
+      debounceMs: 300,
+      defaultBranch: "main",
+      dbPath: ".trellis/trellis.db",
+      indexWorkspace: true
+    };
+  }
+});
+
+export {
+  fileEntityId,
+  dirEntityId,
+  branchEntityId,
+  milestoneEntityId,
+  checkpointEntityId,
+  issueEntityId,
+  criterionEntityId,
+  decisionEntityId,
+  laneEntityId,
+  DEFAULT_CONFIG,
+  init_types
+};

package/dist/chunk-O2AV5WMN.js

@@ -0,0 +1,48 @@
+// src/react/realtime.ts
+import { useEffect, useState, useSyncExternalStore } from "react";
+function useSignal(signal) {
+  return useSyncExternalStore(
+    (onStoreChange) => signal.subscribe(() => onStoreChange()),
+    () => signal.peek(),
+    () => signal.peek()
+  );
+}
+function useRoom(create, deps = []) {
+  const [room, setRoom] = useState(null);
+  const [presence, setPresence] = useState([]);
+  useEffect(() => {
+    const r = create();
+    setRoom(r);
+    const unsub = r.presenceSignal.subscribe(setPresence);
+    return () => {
+      unsub();
+      r.leave();
+      setRoom(null);
+      setPresence([]);
+    };
+  }, deps);
+  return {
+    room,
+    presence,
+    others: presence.filter((p) => !p.self)
+  };
+}
+function usePresence(room) {
+  const [presence, setPresence] = useState(
+    () => room?.getPresence() ?? []
+  );
+  useEffect(() => {
+    if (!room) {
+      setPresence([]);
+      return;
+    }
+    return room.presenceSignal.subscribe(setPresence);
+  }, [room]);
+  return presence;
+}
+
+export {
+  useSignal,
+  useRoom,
+  usePresence
+};