trellis 3.1.35 → 3.2.0

package/dist/chunk-IX4BBOIT.js

@@ -0,0 +1,394 @@
+import {
+  TrellisVcsEngine,
+  init_engine
+} from "./chunk-OBKU74FU.js";
+import {
+  IdbOpLog
+} from "./chunk-MPXUVGT3.js";
+import {
+  JsonOpLog,
+  init_op_log
+} from "./chunk-XEN3OEYY.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/{index-yhwjgfvj.js → chunk-IXU4RMQM.js}

@@ -1,8 +1,3 @@
-// @bun
-import {
-  __esm
-} from "./index-a76rekgs.js";
-
 // src/core/store/eav-store.ts
 function* flatten(obj, base = "") {
   if (Array.isArray(obj)) {
@@ -20,32 +15,38 @@ function* flatten(obj, base = "") {
 function jsonEntityFacts(entityId, root, type) {
   const facts = [{ e: entityId, a: "type", v: type }];
   for (const [a, v] of flatten(root)) {
-    if (v === undefined || v === null)
-      continue;
+    if (v === void 0 || v === null) continue;
     if (Array.isArray(v)) {
       for (const el of v) {
         facts.push({ e: entityId, a, v: el });
       }
-    } else if (typeof v === "object") {} else {
+    } else if (typeof v === "object") {
+    } else {
       facts.push({ e: entityId, a, v });
     }
   }
   return facts;
 }
-
-class EAVStore {
+var EAVStore = class {
   facts = [];
   links = [];
-  catalog = new Map;
-  eavIndex = new Map;
-  aevIndex = new Map;
-  aveIndex = new Map;
-  linkIndex = new Map;
-  linkReverseIndex = new Map;
-  linkAttrIndex = new Map;
-  distinct = new Map;
+  catalog = /* @__PURE__ */ new Map();
+  // Indexes for fast lookups
+  eavIndex = /* @__PURE__ */ new Map();
+  aevIndex = /* @__PURE__ */ new Map();
+  aveIndex = /* @__PURE__ */ new Map();
+  // Link indexes for graph queries
+  linkIndex = /* @__PURE__ */ new Map();
+  // e1 -> a -> e2s
+  linkReverseIndex = /* @__PURE__ */ new Map();
+  // e2 -> a -> e1s
+  linkAttrIndex = /* @__PURE__ */ new Map();
+  // a -> [(e1, e2)]
+  // Distinct value tracking
+  distinct = /* @__PURE__ */ new Map();
+  // attr -> set of valueKey
   addFacts(facts) {
-    for (let i = 0;i < facts.length; i++) {
+    for (let i = 0; i < facts.length; i++) {
       const fact = facts[i];
       if (fact) {
         if (this.hasFact(fact.e, fact.a, fact.v)) {
@@ -57,11 +58,13 @@ class EAVStore {
       }
     }
   }
+  /**
+   * Check if a fact already exists in the store.
+   */
   hasFact(entity, attribute, value) {
     const valueKey = this.valueKey(value);
     const indices = this.aveIndex.get(attribute)?.get(valueKey);
-    if (!indices)
-      return false;
+    if (!indices) return false;
     for (const idx of indices) {
       const fact = this.facts[idx];
       if (fact && fact.e === entity && fact.a === attribute) {
@@ -80,8 +83,7 @@ class EAVStore {
     for (const fact of factsToDelete) {
       const valueKey = this.valueKey(fact.v);
       const indices = this.aveIndex.get(fact.a)?.get(valueKey);
-      if (!indices)
-        continue;
+      if (!indices) continue;
       let foundIdx = -1;
       for (const idx of indices) {
         const storedFact = this.facts[idx];
@@ -91,19 +93,22 @@ class EAVStore {
         }
       }
       if (foundIdx !== -1) {
-        this.facts[foundIdx] = undefined;
+        this.facts[foundIdx] = void 0;
         this.eavIndex.get(fact.e)?.get(fact.a)?.delete(foundIdx);
         this.aevIndex.get(fact.a)?.get(fact.e)?.delete(foundIdx);
         this.aveIndex.get(fact.a)?.get(valueKey)?.delete(foundIdx);
         const entry = this.catalog.get(fact.a);
-        if (entry) {}
+        if (entry) {
+        }
       }
     }
   }
   deleteLinks(linksToDelete) {
     for (const link of linksToDelete) {
       const initialLen = this.links.length;
-      this.links = this.links.filter((l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2));
+      this.links = this.links.filter(
+        (l) => !(l.e1 === link.e1 && l.a === link.a && l.e2 === link.e2)
+      );
       if (this.links.length < initialLen) {
         this.linkIndex.get(link.e1)?.get(link.a)?.delete(link.e2);
         this.linkReverseIndex.get(link.e2)?.get(link.a)?.delete(link.e1);
@@ -121,53 +126,52 @@ class EAVStore {
   }
   updateIndexes(fact, index) {
     if (!this.eavIndex.has(fact.e)) {
-      this.eavIndex.set(fact.e, new Map);
+      this.eavIndex.set(fact.e, /* @__PURE__ */ new Map());
     }
     if (!this.eavIndex.get(fact.e).has(fact.a)) {
-      this.eavIndex.get(fact.e).set(fact.a, new Set);
+      this.eavIndex.get(fact.e).set(fact.a, /* @__PURE__ */ new Set());
     }
     this.eavIndex.get(fact.e).get(fact.a).add(index);
     if (!this.aevIndex.has(fact.a)) {
-      this.aevIndex.set(fact.a, new Map);
+      this.aevIndex.set(fact.a, /* @__PURE__ */ new Map());
     }
     if (!this.aevIndex.get(fact.a).has(fact.e)) {
-      this.aevIndex.get(fact.a).set(fact.e, new Set);
+      this.aevIndex.get(fact.a).set(fact.e, /* @__PURE__ */ new Set());
     }
     this.aevIndex.get(fact.a).get(fact.e).add(index);
     if (!this.aveIndex.has(fact.a)) {
-      this.aveIndex.set(fact.a, new Map);
+      this.aveIndex.set(fact.a, /* @__PURE__ */ new Map());
     }
     const valueKey = this.valueKey(fact.v);
     if (!this.aveIndex.get(fact.a).has(valueKey)) {
-      this.aveIndex.get(fact.a).set(valueKey, new Set);
+      this.aveIndex.get(fact.a).set(valueKey, /* @__PURE__ */ new Set());
     }
     this.aveIndex.get(fact.a).get(valueKey).add(index);
   }
   updateLinkIndexes(link) {
     if (!this.linkIndex.has(link.e1)) {
-      this.linkIndex.set(link.e1, new Map);
+      this.linkIndex.set(link.e1, /* @__PURE__ */ new Map());
     }
     const e1Attrs = this.linkIndex.get(link.e1);
     if (!e1Attrs.has(link.a)) {
-      e1Attrs.set(link.a, new Set);
+      e1Attrs.set(link.a, /* @__PURE__ */ new Set());
     }
     e1Attrs.get(link.a).add(link.e2);
     if (!this.linkReverseIndex.has(link.e2)) {
-      this.linkReverseIndex.set(link.e2, new Map);
+      this.linkReverseIndex.set(link.e2, /* @__PURE__ */ new Map());
     }
     const e2Attrs = this.linkReverseIndex.get(link.e2);
     if (!e2Attrs.has(link.a)) {
-      e2Attrs.set(link.a, new Set);
+      e2Attrs.set(link.a, /* @__PURE__ */ new Set());
     }
     e2Attrs.get(link.a).add(link.e1);
     if (!this.linkAttrIndex.has(link.a)) {
-      this.linkAttrIndex.set(link.a, new Set);
+      this.linkAttrIndex.set(link.a, /* @__PURE__ */ new Set());
     }
     this.linkAttrIndex.get(link.a).add([link.e1, link.e2]);
   }
   valueKey(v) {
-    if (v instanceof Date)
-      return `date:${v.toISOString()}`;
+    if (v instanceof Date) return `date:${v.toISOString()}`;
     return `${typeof v}:${v}`;
   }
   updateCatalog(fact) {
@@ -187,7 +191,7 @@ class EAVStore {
       entry.cardinality = "many";
     }
     const k = this.valueKey(fact.v);
-    const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, new Set), this.distinct.get(fact.a));
+    const s = this.distinct.get(fact.a) || (this.distinct.set(fact.a, /* @__PURE__ */ new Set()), this.distinct.get(fact.a));
     s.add(k);
     entry.distinctCount = s.size;
     if (entry.examples.length < 5 && !entry.examples.includes(fact.v)) {
@@ -200,20 +204,16 @@ class EAVStore {
     this.catalog.set(fact.a, entry);
   }
   inferType(v) {
-    if (typeof v === "string")
-      return "string";
-    if (typeof v === "number")
-      return "number";
-    if (typeof v === "boolean")
-      return "boolean";
-    if (v instanceof Date)
-      return "date";
+    if (typeof v === "string") return "string";
+    if (typeof v === "number") return "number";
+    if (typeof v === "boolean") return "boolean";
+    if (v instanceof Date) return "date";
     return "mixed";
   }
+  // Query methods
   getFactsByEntity(entity) {
     const indices = this.eavIndex.get(entity);
-    if (!indices)
-      return [];
+    if (!indices) return [];
     const result = [];
     for (const attrIndices of indices.values()) {
       for (const idx of attrIndices) {
@@ -227,8 +227,7 @@ class EAVStore {
   }
   getFactsByAttribute(attribute) {
     const indices = this.aevIndex.get(attribute);
-    if (!indices)
-      return [];
+    if (!indices) return [];
     const result = [];
     for (const entityIndices of indices.values()) {
       for (const idx of entityIndices) {
@@ -242,9 +241,8 @@ class EAVStore {
   }
   getFactsByValue(attribute, value) {
     const indices = this.aveIndex.get(attribute)?.get(this.valueKey(value));
-    if (!indices)
-      return [];
-    return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== undefined);
+    if (!indices) return [];
+    return Array.from(indices).map((idx) => this.facts[idx]).filter((fact) => fact !== void 0);
   }
   getCatalog() {
     return Array.from(this.catalog.values());
@@ -252,8 +250,9 @@ class EAVStore {
   getCatalogEntry(attribute) {
     return this.catalog.get(attribute);
   }
+  // Statistics
   getAllFacts() {
-    return this.facts.filter((f) => f !== undefined);
+    return this.facts.filter((f) => f !== void 0);
   }
   getAllLinks() {
     return [...this.links];
@@ -310,13 +309,19 @@ class EAVStore {
       catalogEntries: this.catalog.size
     };
   }
+  /**
+   * Creates a serializable snapshot of the current store state.
+   */
   snapshot() {
     return {
-      facts: this.facts.filter((f) => f !== undefined),
+      facts: this.facts.filter((f) => f !== void 0),
       links: [...this.links],
       catalog: this.getCatalog()
     };
   }
+  /**
+   * Restores the store state from a snapshot and rebuilds all indexes.
+   */
   restore(snapshot) {
     this.facts = [];
     this.links = [];
@@ -336,7 +341,9 @@ class EAVStore {
       }
     }
   }
-}
-var init_eav_store = () => {};
+};
 
-export { flatten, jsonEntityFacts, EAVStore, init_eav_store };
+export {
+  jsonEntityFacts,
+  EAVStore
+};