trellis 3.1.35 → 3.2.0

package/dist/chunk-CYQ2OVD2.js

@@ -0,0 +1,35 @@
+import {
+  __require
+} from "./chunk-KFQGP6VL.js";
+
+// src/core/persist/factory.ts
+async function createKernelBackend(dbPath, opts = {}) {
+  const choice = opts.backend ?? detectBackend();
+  if (choice === "better-sqlite") {
+    const { BetterSqliteKernelBackend } = await import("./better-sqlite-backend-PII64VE6.js");
+    const backend2 = new BetterSqliteKernelBackend(dbPath);
+    backend2.init();
+    return backend2;
+  }
+  const { SqlJsKernelBackend } = await import("./core/persist/sqljs-backend.js");
+  const backend = await SqlJsKernelBackend.create({
+    dbPath,
+    autoFlushEvery: opts.sqljs?.autoFlushEvery
+  });
+  backend.init();
+  return backend;
+}
+function detectBackend() {
+  try {
+    const { createRequire } = __require("module");
+    const req = createRequire(import.meta.url);
+    req("better-sqlite3");
+    return "better-sqlite";
+  } catch {
+    return "sqljs";
+  }
+}
+
+export {
+  createKernelBackend
+};

package/dist/chunk-DDAK7YOE.js

@@ -0,0 +1,299 @@
+import {
+  TrellisVcsEngine,
+  init_engine
+} from "./chunk-ZMN5LUB7.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
+import {
+  JsonOpLog,
+  init_op_log
+} from "./chunk-XEN3OEYY.js";
+import {
+  PartyKitRoomTransport,
+  TrellisVcsSyncPeer
+} from "./chunk-BJ5EKCJ5.js";
+
+// src/client/vcs-client.ts
+init_engine();
+init_op_log();
+
+// src/client/reactive.ts
+var Signal = class {
+  _value;
+  _subs = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    if (Object.is(this._value, v)) return;
+    this._value = v;
+    for (const fn of this._subs) {
+      try {
+        fn(v);
+      } catch {
+      }
+    }
+  }
+  /** Subscribe to changes. Immediately called with current value. */
+  subscribe(fn) {
+    this._subs.add(fn);
+    try {
+      fn(this._value);
+    } catch {
+    }
+    return () => {
+      this._subs.delete(fn);
+    };
+  }
+  /** Read without tracking. */
+  peek() {
+    return this._value;
+  }
+};
+var BatchSignal = class extends Signal {
+  _raf = null;
+  constructor(initial) {
+    super(initial);
+  }
+  set value(v) {
+    if (Object.is(this.peek(), v)) return;
+    if (this._raf !== null) cancelAnimationFrame(this._raf);
+    this._raf = requestAnimationFrame(() => {
+      this._raf = null;
+      super.value = v;
+    });
+  }
+};
+
+// src/client/vcs-client.ts
+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;
+  /** Raw causal log. Updated on every local or remote op. */
+  _ops = new Signal([]);
+  /** Sync connection state. */
+  _syncStatus = new Signal({ pending: 0, synced: true });
+  _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) {
+      const transport = new PartyKitRoomTransport({
+        peerId: client._peerId,
+        roomUrl: opts.sync.url
+      });
+      client._syncPeer = new TrellisVcsSyncPeer({
+        peerId: client._peerId,
+        engine: client._engine,
+        transport,
+        onIntegrate: () => {
+          client._refreshState();
+          client._setSyncStatus({ synced: true });
+        }
+      });
+    }
+    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();
+    return op;
+  }
+  /** Force a push/pull sync with the PartyKit room. */
+  async sync() {
+    if (!this._syncPeer) {
+      throw new Error(
+        "No sync configured. Pass sync.url to TrellisClient.open() to enable multiplayer sync."
+      );
+    }
+    this._setSyncStatus({
+      pending: this._syncStatus.value.pending + 1,
+      synced: false
+    });
+    try {
+      await this._syncPeer.syncWith("room");
+    } finally {
+      this._setSyncStatus({
+        pending: Math.max(0, this._syncStatus.value.pending - 1),
+        synced: true
+      });
+    }
+  }
+  /** Read current ops without subscribing. */
+  getOps() {
+    return this._engine.getOps();
+  }
+  /** Read current issues without subscribing. */
+  listIssues() {
+    return this._engine.listIssues();
+  }
+  /** Clean up resources. */
+  close() {
+    this._engine.stop();
+  }
+  // -------------------------------------------------------------------------
+  // 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;
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  _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`);
+    }
+  }
+  _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 {
+  Signal,
+  BatchSignal,
+  TrellisClient
+};