trellis 3.1.35 → 3.2.0

package/dist/chunk-MBNBTJCR.js

@@ -0,0 +1,394 @@
+import {
+  TrellisVcsEngine,
+  init_engine
+} from "./chunk-YY3GF7DH.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
+import {
+  JsonOpLog,
+  init_op_log
+} from "./chunk-B3ZIFA2O.js";
+import {
+  PartyKitRoomTransport,
+  TrellisVcsSyncPeer
+} from "./chunk-RSWUFTO2.js";
+import {
+  Signal
+} from "./chunk-UBGUDMUV.js";
+
+// src/client/vcs-client.ts
+init_engine();
+init_op_log();
+var DEFAULT_SYNC_STATUS = {
+  connected: false,
+  pending: 0,
+  synced: false,
+  lastSyncAt: null,
+  lastError: null
+};
+var MemoryOpLog = class {
+  ops = [];
+  hashes = /* @__PURE__ */ new Set();
+  load() {
+  }
+  append(op) {
+    if (this.hashes.has(op.hash)) return;
+    this.ops.push(op);
+    this.hashes.add(op.hash);
+  }
+  readAll() {
+    return [...this.ops];
+  }
+  getLastOp() {
+    return this.ops[this.ops.length - 1];
+  }
+  count() {
+    return this.ops.length;
+  }
+};
+var TrellisClient = class _TrellisClient {
+  _engine;
+  _syncPeer;
+  _peerId = "";
+  _opLog;
+  _roomId = "room";
+  _pushDebounceMs = 200;
+  _snapshotMaxOps = 500;
+  _pushTimer;
+  _closed = false;
+  /** Raw causal log. Updated on every local or remote op. */
+  _ops = new Signal([]);
+  /** Sync connection state. */
+  _syncStatus = new Signal({ ...DEFAULT_SYNC_STATUS });
+  _opHandlers = [];
+  _topicSubs = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  /** Factory — opens the repo, loads ops, and optionally connects to sync. */
+  static async open(opts) {
+    const client = new _TrellisClient();
+    client._peerId = opts.agentId ?? `client:${crypto.randomUUID()}`;
+    client._opLog = client._createOpLog(opts);
+    if ("load" in client._opLog && typeof client._opLog.load === "function") {
+      const maybePromise = client._opLog.load();
+      if (maybePromise instanceof Promise) await maybePromise;
+    }
+    client._engine = new TrellisVcsEngine({
+      rootPath: opts.repo,
+      agentId: client._peerId,
+      opLog: client._opLog
+    });
+    client._engine.open();
+    client._refreshState();
+    if (opts.sync) {
+      client._roomId = opts.sync.roomId ?? "room";
+      client._pushDebounceMs = opts.sync.pushDebounceMs ?? 200;
+      client._snapshotMaxOps = opts.sync.snapshotMaxOps ?? 500;
+      const transport = client._createTransport(opts.sync, client);
+      client._syncPeer = new TrellisVcsSyncPeer({
+        peerId: client._peerId,
+        engine: client._engine,
+        transport,
+        onIntegrate: () => {
+          client._refreshState();
+          client._setSyncStatus({ synced: true, lastError: null });
+        }
+      });
+      if (opts.sync.connectOnOpen !== false) {
+        try {
+          await client._connectAndCatchUp();
+        } catch {
+        }
+      }
+    }
+    return client;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /** Subscribe to reactive topics. Callback receives current value immediately. */
+  subscribe(topic, callback) {
+    if (!this._topicSubs.has(topic)) {
+      this._topicSubs.set(topic, /* @__PURE__ */ new Set());
+    }
+    const subs = this._topicSubs.get(topic);
+    subs.add(callback);
+    const current = this._getTopicValue(topic);
+    if (current !== void 0) {
+      try {
+        callback(current);
+      } catch {
+      }
+    }
+    return () => {
+      subs.delete(callback);
+    };
+  }
+  /** Listen for raw op events (local or remote). */
+  on(event, handler) {
+    this._opHandlers.push(handler);
+    return () => {
+      const idx = this._opHandlers.indexOf(handler);
+      if (idx >= 0) this._opHandlers.splice(idx, 1);
+    };
+  }
+  /** Create an issue and emit reactive updates. */
+  async createIssue(title, opts) {
+    const createOpts = { ...opts };
+    if (opts?.lane) {
+      createOpts.laneId = opts.lane;
+    }
+    const op = await this._engine.createIssue(title, createOpts);
+    this._refreshState();
+    this._schedulePush();
+    return op;
+  }
+  /** Force a push/pull sync with the room. */
+  async sync() {
+    if (!this._syncPeer) {
+      throw new Error(
+        "No sync configured. Pass sync.url to TrellisClient.open() to enable multiplayer sync."
+      );
+    }
+    await this._connectAndCatchUp();
+  }
+  /** Close (complete) an issue. */
+  async closeIssue(id, opts) {
+    const result = await this._engine.closeIssue(id, opts);
+    if (result.op) {
+      this._refreshState();
+      this._schedulePush();
+    }
+    return result.op ?? null;
+  }
+  /** Reopen a closed issue. */
+  async reopenIssue(id) {
+    const op = await this._engine.reopenIssue(id);
+    this._refreshState();
+    this._schedulePush();
+    return op;
+  }
+  /** Read current ops without subscribing. */
+  getOps() {
+    return this._engine.getOps();
+  }
+  /** Read current issues without subscribing. */
+  listIssues() {
+    return this._engine.listIssues();
+  }
+  /** Clean up resources. */
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+      this._pushTimer = void 0;
+    }
+    this._syncPeer?.close();
+    if ("close" in this._opLog && typeof this._opLog.close === "function") {
+      void this._opLog.close();
+    }
+    this._engine.stop();
+    this._setSyncStatus({ connected: false });
+  }
+  // -------------------------------------------------------------------------
+  // Reactive accessors (for framework adapters)
+  // -------------------------------------------------------------------------
+  /** Signal exposing the full causal op log. */
+  get opsSignal() {
+    return this._ops;
+  }
+  /** Signal exposing sync connection status. */
+  get syncStatusSignal() {
+    return this._syncStatus;
+  }
+  /** Underlying VCS engine (for advanced sync wiring and queries). */
+  get engine() {
+    return this._engine;
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _createTransport(sync, client) {
+    if (sync.transport) return sync.transport;
+    if (!sync.url) {
+      throw new Error(
+        "sync.transport or sync.url is required when sync is configured."
+      );
+    }
+    return new PartyKitRoomTransport({
+      peerId: this._peerId,
+      roomUrl: sync.url,
+      auth: sync.auth,
+      roomId: sync.roomId,
+      reconnect: sync.reconnect !== false,
+      onReconnect: () => client._onTransportReconnect(),
+      onDisconnect: () => client._setSyncStatus({ connected: false })
+    });
+  }
+  _createOpLog(opts) {
+    switch (opts.persist) {
+      case "indexeddb":
+        return new IdbOpLog({ dbName: opts.repo });
+      case "memory":
+        return new MemoryOpLog();
+      case "opfs":
+        throw new Error(
+          'OPFS persistence not yet implemented. Use "indexeddb" or "memory".'
+        );
+      default:
+        if (typeof globalThis !== "undefined" && "indexedDB" in globalThis) {
+          return new IdbOpLog({ dbName: opts.repo });
+        }
+        return new JsonOpLog(`${opts.repo}/.trellis/ops.json`);
+    }
+  }
+  async _connectTransport() {
+    const transport = this._syncPeer?.getTransport();
+    if (transport && "connect" in transport && typeof transport.connect === "function") {
+      await transport.connect();
+      this._setSyncStatus({ connected: true, lastError: null });
+    } else if (transport) {
+      this._setSyncStatus({ connected: true, lastError: null });
+    }
+  }
+  async _connectAndCatchUp() {
+    if (!this._syncPeer) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      await this._requestSnapshot();
+      const result = await this._syncPeer.syncWith(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.rejected === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.rejected > 0 ? `${result.rejected} op(s) rejected during sync` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+      throw err;
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  async _onTransportReconnect() {
+    if (this._closed || !this._syncPeer) return;
+    try {
+      await this._connectAndCatchUp();
+    } catch {
+    }
+  }
+  async _requestSnapshot() {
+    if (!this._syncPeer || this._snapshotMaxOps <= 0) return;
+    await this._syncPeer.requestSnapshot(this._roomId, this._snapshotMaxOps);
+    await new Promise((resolve) => {
+      queueMicrotask(() => resolve());
+    });
+  }
+  _schedulePush() {
+    if (!this._syncPeer || this._pushDebounceMs <= 0 || this._closed) return;
+    if (this._pushTimer !== void 0) {
+      clearTimeout(this._pushTimer);
+    }
+    this._pushTimer = setTimeout(() => {
+      this._pushTimer = void 0;
+      void this._pushToRoom();
+    }, this._pushDebounceMs);
+  }
+  async _pushToRoom() {
+    if (!this._syncPeer || this._closed) return;
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._connectTransport();
+      const result = await this._syncPeer.pushTo(this._roomId);
+      this._setSyncStatus({
+        connected: true,
+        synced: result.remoteRejected.length === 0,
+        lastSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastError: result.remoteRejected.length > 0 ? `${result.remoteRejected.length} op(s) rejected by room` : null
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this._setSyncStatus({
+        connected: false,
+        synced: false,
+        lastError: message
+      });
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1)
+      });
+    }
+  }
+  _refreshState() {
+    const ops = this._engine.getOps();
+    const previousHashes = new Set(this._ops.value.map((o) => o.hash));
+    this._ops.value = ops;
+    for (const op of ops) {
+      if (!previousHashes.has(op.hash)) {
+        this._emitOp(op);
+      }
+    }
+    this._broadcastTopic("ops", ops);
+    this._broadcastTopic("issues", this._engine.listIssues());
+    this._broadcastTopic("milestones", this._engine.listMilestones());
+    this._broadcastTopic("branches", this._engine.listBranches());
+  }
+  _emitOp(op) {
+    for (const h of this._opHandlers) {
+      try {
+        h(op);
+      } catch {
+      }
+    }
+  }
+  _broadcastTopic(topic, data) {
+    const subs = this._topicSubs.get(topic);
+    if (!subs) return;
+    for (const fn of subs) {
+      try {
+        fn(data);
+      } catch {
+      }
+    }
+  }
+  _getTopicValue(topic) {
+    switch (topic) {
+      case "ops":
+        return this._ops.value;
+      case "syncStatus":
+        return this._syncStatus.value;
+      case "issues":
+        return this._engine.listIssues();
+      case "milestones":
+        return this._engine.listMilestones();
+      case "branches":
+        return this._engine.listBranches();
+      default:
+        return void 0;
+    }
+  }
+  _setSyncStatus(partial) {
+    this._syncStatus.value = { ...this._syncStatus.value, ...partial };
+    this._broadcastTopic("syncStatus", this._syncStatus.value);
+  }
+};
+
+export {
+  TrellisClient
+};

package/dist/chunk-MCKGQKYU.js

@@ -0,0 +1,15 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};

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
+};