trellis 3.2.0 → 3.2.2

package/dist/chunk-OQNDWRDE.js

@@ -1,145 +0,0 @@
-import {
-  attachStandardMiddleware
-} from "./chunk-SPSPV5BC.js";
-import {
-  SqliteKernelBackend
-} from "./chunk-XMQ7G77X.js";
-import {
-  TrellisKernel
-} from "./chunk-7KJ7T4D3.js";
-
-// src/server/tenancy.ts
-import { existsSync, mkdirSync } from "fs";
-import { join, resolve } from "path";
-var DEFAULT_TENANT = "default";
-var TENANTS_DIR = "tenants";
-var TenantPool = class {
-  pool = /* @__PURE__ */ new Map();
-  dbPath;
-  agentId;
-  backendOpts;
-  constructor(dbPath, agentIdOrOpts = "trellis-db") {
-    this.dbPath = resolve(dbPath);
-    if (typeof agentIdOrOpts === "string") {
-      this.agentId = agentIdOrOpts;
-      this.backendOpts = void 0;
-    } else {
-      this.agentId = agentIdOrOpts.agentId ?? "trellis-db";
-      this.backendOpts = agentIdOrOpts.backend;
-    }
-    this._ensureDirs();
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  /**
-   * Get (or create) the kernel for a tenant.
-   * Pass `null` or `undefined` to get the default tenant.
-   *
-   * Uses the synchronous bun:sqlite backend. To use an async backend
-   * (better-sqlite3, sql.js) call `preload(tenantId)` first; subsequent
-   * `get()` calls will return the preloaded kernel from the pool.
-   */
-  get(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    if (!this.pool.has(id)) {
-      this.pool.set(id, this._createKernelSync(id));
-    }
-    return this.pool.get(id);
-  }
-  /**
-   * Pre-create a tenant's kernel using the runtime-selected backend.
-   * Required when running with an async-only backend (sql.js / WebContainer
-   * / browser). Idempotent — safe to call multiple times.
-   *
-   * After `preload()`, subsequent `get(tenantId)` returns the same kernel
-   * synchronously from the pool.
-   */
-  async preload(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    const cached = this.pool.get(id);
-    if (cached) return cached;
-    const kernel = await this._createKernelAsync(id);
-    this.pool.set(id, kernel);
-    return kernel;
-  }
-  /**
-   * Check whether a tenant has been initialized (kernel created).
-   */
-  has(tenantId) {
-    return this.pool.has(tenantId);
-  }
-  /**
-   * List all active tenant IDs (those with open kernels).
-   */
-  activeTenants() {
-    return Array.from(this.pool.keys());
-  }
-  /**
-   * Close a specific tenant's kernel and remove it from the pool.
-   */
-  close(tenantId) {
-    const kernel = this.pool.get(tenantId);
-    if (kernel) {
-      kernel.close();
-      this.pool.delete(tenantId);
-    }
-  }
-  /**
-   * Close all kernels and clear the pool.
-   */
-  closeAll() {
-    for (const kernel of this.pool.values()) {
-      kernel.close();
-    }
-    this.pool.clear();
-  }
-  /**
-   * Return the SQLite file path for a given tenant.
-   */
-  dbFilePath(tenantId) {
-    const id = tenantId ?? DEFAULT_TENANT;
-    if (id === DEFAULT_TENANT) {
-      return join(this.dbPath, "default.sqlite");
-    }
-    return join(this.dbPath, TENANTS_DIR, `${id}.sqlite`);
-  }
-  // -------------------------------------------------------------------------
-  // Private
-  // -------------------------------------------------------------------------
-  _createKernelSync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const backend = new SqliteKernelBackend(sqlitePath);
-    return this._wrapKernel(backend);
-  }
-  async _createKernelAsync(tenantId) {
-    const sqlitePath = this.dbFilePath(tenantId);
-    const { createKernelBackend } = await import("./core/persist/factory.js");
-    const backend = await createKernelBackend(sqlitePath, this.backendOpts);
-    return this._wrapKernel(backend);
-  }
-  _wrapKernel(backend) {
-    const kernel = new TrellisKernel({
-      backend,
-      agentId: this.agentId,
-      snapshotThreshold: 1e3
-    });
-    kernel.boot();
-    attachStandardMiddleware(kernel);
-    return kernel;
-  }
-  _ensureDirs() {
-    if (!existsSync(this.dbPath)) {
-      mkdirSync(this.dbPath, { recursive: true });
-    }
-    const tenantsPath = join(this.dbPath, TENANTS_DIR);
-    if (!existsSync(tenantsPath)) {
-      mkdirSync(tenantsPath, { recursive: true });
-    }
-  }
-};
-
-export {
-  DEFAULT_TENANT,
-  TenantPool
-};

package/dist/chunk-OVWAJMB6.js

@@ -1,394 +0,0 @@
-import {
-  TrellisVcsEngine,
-  init_engine
-} from "./chunk-7WQGTFVJ.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-PDHLBTTD.js

@@ -1,45 +0,0 @@
-import {
-  TrellisDb
-} from "./chunk-UPKPURVY.js";
-
-// src/react/provider.tsx
-import {
-  createContext,
-  useContext,
-  useMemo,
-  useEffect
-} from "react";
-var TrellisContext = createContext(null);
-function TrellisProvider({
-  url,
-  apiKey,
-  tenantId,
-  children
-}) {
-  const client = useMemo(() => {
-    const opts = { url };
-    if (apiKey) opts.apiKey = apiKey;
-    if (tenantId) opts.tenantId = tenantId;
-    return new TrellisDb(opts);
-  }, [url, apiKey, tenantId]);
-  useEffect(() => {
-    return () => {
-      client.disconnect();
-    };
-  }, [client]);
-  return /* @__PURE__ */ React.createElement(TrellisContext.Provider, { value: client }, children);
-}
-function useTrellis() {
-  const client = useContext(TrellisContext);
-  if (!client) {
-    throw new Error(
-      'useTrellis() must be used within a <TrellisProvider>. Wrap your app with <TrellisProvider url="...">.'
-    );
-  }
-  return client;
-}
-
-export {
-  TrellisProvider,
-  useTrellis
-};