@eide/sync-client 0.1.0

package/dist/react.js

@@ -0,0 +1,1857 @@
+// src/core/offline-queue.ts
+var queueIdCounter = 0;
+function generateQueueId() {
+  return `q_${Date.now()}_${++queueIdCounter}`;
+}
+var OfflineQueue = class {
+  constructor(storage) {
+    this.storeName = "__pending_mutations";
+    this.storage = storage;
+  }
+  /**
+   * Enqueue a new mutation. Deduplicates by clientId —
+   * if a pending mutation already exists for the same clientId with the same op,
+   * the newer one replaces it (for updates).
+   */
+  async enqueue(mutation) {
+    const pending = {
+      ...mutation,
+      queueId: generateQueueId(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      retryCount: 0
+    };
+    if (mutation.op === "update") {
+      const existing = await this.getAll();
+      const duplicate = existing.find(
+        (m) => m.clientId === mutation.clientId && m.op === "update"
+      );
+      if (duplicate) {
+        await this.remove(duplicate.queueId);
+      }
+    }
+    await this.storage.put(this.storeName, pending.queueId, pending);
+    return pending;
+  }
+  /**
+   * Get all pending mutations in creation order.
+   */
+  async getAll() {
+    const all = await this.storage.getAll(this.storeName);
+    return all.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  /**
+   * Get a batch of mutations for pushing.
+   */
+  async getBatch(limit) {
+    const all = await this.getAll();
+    return all.slice(0, limit);
+  }
+  /**
+   * Remove a mutation after successful push.
+   */
+  async remove(queueId) {
+    await this.storage.delete(this.storeName, queueId);
+  }
+  /**
+   * Remove multiple mutations.
+   */
+  async removeBatch(queueIds) {
+    for (const id of queueIds) {
+      await this.storage.delete(this.storeName, id);
+    }
+  }
+  /**
+   * Increment retry count for a failed mutation.
+   */
+  async incrementRetry(queueId) {
+    const mutation = await this.storage.get(
+      this.storeName,
+      queueId
+    );
+    if (mutation) {
+      mutation.retryCount++;
+      await this.storage.put(this.storeName, queueId, mutation);
+    }
+  }
+  /**
+   * Get count of pending mutations.
+   */
+  async count() {
+    const all = await this.getAll();
+    return all.length;
+  }
+  /**
+   * Clear all pending mutations.
+   */
+  async clear() {
+    await this.storage.clear(this.storeName);
+  }
+};
+
+// src/core/conflict-resolver.ts
+function resolveConflict(local, server, strategy, customResolver) {
+  switch (strategy) {
+    case "server-wins":
+      return serverWins(local, server);
+    case "client-wins":
+      return clientWins(local, server);
+    case "field-lww":
+      return fieldLWW(local, server);
+    case "custom":
+      if (!customResolver) {
+        return serverWins(local, server);
+      }
+      return customResolver(local, server);
+    default:
+      return serverWins(local, server);
+  }
+}
+function serverWins(local, server) {
+  const conflictedFields = findDifferentFields(local, server);
+  return { resolved: { ...server }, conflictedFields };
+}
+function clientWins(local, server) {
+  const conflictedFields = findDifferentFields(local, server);
+  return { resolved: { ...local }, conflictedFields };
+}
+function fieldLWW(local, server) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(server)]);
+  const resolved = {};
+  const conflictedFields = [];
+  for (const key of allKeys) {
+    const localVal = local[key];
+    const serverVal = server[key];
+    if (deepEqual(localVal, serverVal)) {
+      resolved[key] = serverVal;
+    } else if (key in local && key in server) {
+      resolved[key] = serverVal;
+      conflictedFields.push(key);
+    } else if (key in local) {
+      resolved[key] = localVal;
+    } else {
+      resolved[key] = serverVal;
+    }
+  }
+  return { resolved, conflictedFields };
+}
+function findDifferentFields(local, server) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(server)]);
+  const different = [];
+  for (const key of allKeys) {
+    if (!deepEqual(local[key], server[key])) {
+      different.push(key);
+    }
+  }
+  return different;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+  }
+  return false;
+}
+
+// src/core/sync-engine.ts
+var SYNC_PULL_QUERY = `
+  query SyncPull($modelKey: String!, $since: String!, $limit: Int) {
+    syncPull(modelKey: $modelKey, since: $since, limit: $limit) {
+      items {
+        id
+        modelKey
+        naturalKey
+        data
+        metadata
+        syncVersion
+        updatedAt
+        deleted
+      }
+      cursor
+      hasMore
+    }
+  }
+`;
+var SYNC_PUSH_MUTATION = `
+  mutation SyncPush($items: [SyncPushItemInput!]!) {
+    syncPush(items: $items) {
+      items {
+        clientId
+        serverId
+        syncVersion
+        status
+        serverData
+        serverSyncVersion
+        error
+      }
+    }
+  }
+`;
+var RECORD_CHANGED_SUBSCRIPTION = `
+  subscription RecordChanged($modelKey: String!) {
+    recordChanged(modelKey: $modelKey) {
+      type
+      recordId
+      modelKey
+      naturalKey
+      syncVersion
+      data
+      updatedBy
+      timestamp
+    }
+  }
+`;
+var clientIdCounter = 0;
+function generateClientId() {
+  return `c_${Date.now()}_${++clientIdCounter}`;
+}
+var SyncEngine = class {
+  constructor(config, storage) {
+    this.listeners = [];
+    this.syncTimer = null;
+    this.wsCleanup = null;
+    this.running = false;
+    this.syncing = false;
+    this.config = {
+      ...config,
+      pollInterval: config.pollInterval ?? 5e3,
+      pullLimit: config.pullLimit ?? 100,
+      pushBatchSize: config.pushBatchSize ?? 50,
+      conflictStrategy: config.conflictStrategy ?? "server-wins",
+      debug: config.debug ?? false
+    };
+    this.storage = storage;
+    this.queue = new OfflineQueue(storage);
+  }
+  // -------------------------------------------------------------------------
+  // Event System
+  // -------------------------------------------------------------------------
+  on(handler) {
+    this.listeners.push(handler);
+    return () => {
+      this.listeners = this.listeners.filter((h) => h !== handler);
+    };
+  }
+  emit(event) {
+    for (const handler of this.listeners) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[SyncEngine]", ...args);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  /**
+   * Start background sync loop and subscriptions.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.log("Starting sync engine");
+    void this.sync();
+    this.syncTimer = setInterval(() => {
+      if (!this.syncing) {
+        void this.sync();
+      }
+    }, this.config.pollInterval);
+    this.connectSubscriptions();
+  }
+  /**
+   * Stop sync engine, close connections.
+   */
+  stop() {
+    this.running = false;
+    this.log("Stopping sync engine");
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    if (this.wsCleanup) {
+      this.wsCleanup();
+      this.wsCleanup = null;
+    }
+    this.emit({ type: "disconnected" });
+  }
+  /**
+   * Force an immediate sync cycle.
+   */
+  async sync() {
+    if (this.syncing) {
+      return { pulled: 0, pushed: 0, conflicts: 0, errors: 0 };
+    }
+    this.syncing = true;
+    this.emit({ type: "sync-start" });
+    const result = {
+      pulled: 0,
+      pushed: 0,
+      conflicts: 0,
+      errors: 0
+    };
+    try {
+      const pushResult = await this.pushPending();
+      result.pushed = pushResult.pushed;
+      result.conflicts = pushResult.conflicts;
+      result.errors = pushResult.errors;
+      for (const modelKey of this.config.modelKeys) {
+        const pullResult = await this.pullModel(modelKey);
+        result.pulled += pullResult;
+      }
+      this.emit({ type: "sync-complete", result });
+      this.log("Sync complete:", result);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emit({ type: "sync-error", error: err });
+      this.log("Sync error:", err.message);
+    } finally {
+      this.syncing = false;
+    }
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Local Reads (instant, from storage)
+  // -------------------------------------------------------------------------
+  /**
+   * Query records from local storage.
+   */
+  async query(modelKey, opts) {
+    const storeName = this.storeKey(modelKey);
+    let records = await this.storage.getAll(storeName);
+    records = records.filter((r) => !r.deleted);
+    if (opts?.naturalKey) {
+      records = records.filter((r) => r.naturalKey === opts.naturalKey);
+    }
+    if (opts?.filter) {
+      records = records.filter(opts.filter);
+    }
+    if (opts?.sort) {
+      records.sort(opts.sort);
+    }
+    if (opts?.offset) {
+      records = records.slice(opts.offset);
+    }
+    if (opts?.limit) {
+      records = records.slice(0, opts.limit);
+    }
+    return records;
+  }
+  /**
+   * Get a single record by server ID.
+   */
+  async get(modelKey, id) {
+    const record = await this.storage.get(
+      this.storeKey(modelKey),
+      id
+    );
+    if (!record || record.deleted) return null;
+    return record;
+  }
+  /**
+   * Get a record by natural key.
+   */
+  async getByKey(modelKey, naturalKey) {
+    const records = await this.query(modelKey, { naturalKey });
+    return records[0] ?? null;
+  }
+  // -------------------------------------------------------------------------
+  // Local Writes (instant, queued for push)
+  // -------------------------------------------------------------------------
+  /**
+   * Create a record locally and queue for push.
+   */
+  async create(modelKey, data, naturalKey) {
+    const clientId = generateClientId();
+    const record = {
+      id: "",
+      clientId,
+      modelKey,
+      naturalKey: naturalKey ?? null,
+      data,
+      metadata: null,
+      syncVersion: "0",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deleted: false,
+      pending: true
+    };
+    await this.storage.put(this.storeKey(modelKey), clientId, record);
+    await this.queue.enqueue({
+      clientId,
+      op: "create",
+      modelKey,
+      naturalKey,
+      data
+    });
+    const pendingCount = await this.queue.count();
+    this.emit({ type: "pending-changed", count: pendingCount });
+    this.emit({ type: "records-changed", modelKey, recordIds: [clientId] });
+    return record;
+  }
+  /**
+   * Update a record locally and queue for push.
+   */
+  async update(modelKey, id, data) {
+    const storeName = this.storeKey(modelKey);
+    const existing = await this.storage.get(storeName, id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      data: { ...existing.data, ...data },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pending: true
+    };
+    await this.storage.put(storeName, id, updated);
+    await this.queue.enqueue({
+      clientId: id,
+      op: "update",
+      modelKey,
+      data: updated.data,
+      expectedSyncVersion: existing.syncVersion
+    });
+    const pendingCount = await this.queue.count();
+    this.emit({ type: "pending-changed", count: pendingCount });
+    this.emit({ type: "records-changed", modelKey, recordIds: [id] });
+    return updated;
+  }
+  /**
+   * Delete a record locally and queue for push.
+   */
+  async delete(modelKey, id) {
+    const storeName = this.storeKey(modelKey);
+    const existing = await this.storage.get(storeName, id);
+    if (!existing) return;
+    const deleted = {
+      ...existing,
+      deleted: true,
+      pending: true,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.put(storeName, id, deleted);
+    await this.queue.enqueue({
+      clientId: id,
+      op: "delete",
+      modelKey,
+      expectedSyncVersion: existing.syncVersion
+    });
+    const pendingCount = await this.queue.count();
+    this.emit({ type: "pending-changed", count: pendingCount });
+    this.emit({ type: "records-changed", modelKey, recordIds: [id] });
+  }
+  /**
+   * Get count of pending mutations.
+   */
+  async getPendingCount() {
+    return this.queue.count();
+  }
+  // -------------------------------------------------------------------------
+  // Pull — Fetch server changes
+  // -------------------------------------------------------------------------
+  async pullModel(modelKey) {
+    let totalPulled = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const cursorKey = `cursor:${modelKey}`;
+      const cursor = await this.storage.getMeta(cursorKey) ?? "0";
+      const result = await this.graphqlQuery(
+        SYNC_PULL_QUERY,
+        { modelKey, since: cursor, limit: this.config.pullLimit }
+      );
+      const delta = result.syncPull;
+      const storeName = this.storeKey(modelKey);
+      const changedIds = [];
+      for (const item of delta.items) {
+        const record = {
+          id: item.id,
+          clientId: item.id,
+          modelKey: item.modelKey,
+          naturalKey: item.naturalKey,
+          data: item.data ?? {},
+          metadata: item.metadata,
+          syncVersion: item.syncVersion,
+          updatedAt: item.updatedAt,
+          deleted: item.deleted,
+          pending: false
+        };
+        const existing = await this.storage.get(
+          storeName,
+          item.id
+        );
+        if (existing?.pending) {
+          this.log(`Skipping pull for pending record ${item.id}`);
+          continue;
+        }
+        await this.storage.put(storeName, item.id, record);
+        changedIds.push(item.id);
+        totalPulled++;
+      }
+      if (delta.cursor !== "0") {
+        await this.storage.setMeta(cursorKey, delta.cursor);
+      }
+      if (changedIds.length > 0) {
+        this.emit({ type: "records-changed", modelKey, recordIds: changedIds });
+      }
+      hasMore = delta.hasMore;
+    }
+    return totalPulled;
+  }
+  // -------------------------------------------------------------------------
+  // Push — Send local mutations to server
+  // -------------------------------------------------------------------------
+  async pushPending() {
+    let pushed = 0;
+    let conflicts = 0;
+    let errors = 0;
+    while (true) {
+      const batch = await this.queue.getBatch(this.config.pushBatchSize);
+      if (batch.length === 0) break;
+      const items = batch.map((m) => ({
+        clientId: m.clientId,
+        op: m.op,
+        modelKey: m.modelKey,
+        naturalKey: m.naturalKey,
+        data: m.data,
+        expectedSyncVersion: m.expectedSyncVersion
+      }));
+      try {
+        const result = await this.graphqlQuery(SYNC_PUSH_MUTATION, { items });
+        for (const resultItem of result.syncPush.items) {
+          const pendingMutation = batch.find(
+            (m) => m.clientId === resultItem.clientId
+          );
+          if (!pendingMutation) continue;
+          switch (resultItem.status) {
+            case "applied": {
+              await this.queue.remove(pendingMutation.queueId);
+              pushed++;
+              const modelKey = pendingMutation.modelKey;
+              const storeName = this.storeKey(modelKey);
+              if (pendingMutation.op === "create") {
+                const localRecord = await this.storage.get(
+                  storeName,
+                  pendingMutation.clientId
+                );
+                if (localRecord) {
+                  await this.storage.delete(
+                    storeName,
+                    pendingMutation.clientId
+                  );
+                  localRecord.id = resultItem.serverId;
+                  localRecord.clientId = resultItem.serverId;
+                  localRecord.syncVersion = resultItem.syncVersion;
+                  localRecord.pending = false;
+                  await this.storage.put(
+                    storeName,
+                    resultItem.serverId,
+                    localRecord
+                  );
+                  this.emit({
+                    type: "records-changed",
+                    modelKey,
+                    recordIds: [pendingMutation.clientId, resultItem.serverId]
+                  });
+                }
+              } else {
+                const existing = await this.storage.get(
+                  storeName,
+                  pendingMutation.clientId
+                );
+                if (existing) {
+                  existing.syncVersion = resultItem.syncVersion;
+                  existing.pending = false;
+                  await this.storage.put(
+                    storeName,
+                    pendingMutation.clientId,
+                    existing
+                  );
+                  this.emit({
+                    type: "records-changed",
+                    modelKey,
+                    recordIds: [pendingMutation.clientId]
+                  });
+                }
+              }
+              break;
+            }
+            case "conflict": {
+              conflicts++;
+              await this.queue.remove(pendingMutation.queueId);
+              const localData = pendingMutation.data ?? {};
+              const serverData = resultItem.serverData ?? {};
+              const resolution = resolveConflict(
+                localData,
+                serverData,
+                this.config.conflictStrategy,
+                this.config.customResolver
+              );
+              this.emit({
+                type: "conflict",
+                event: {
+                  recordId: resultItem.serverId,
+                  modelKey: pendingMutation.modelKey,
+                  localData,
+                  serverData,
+                  resolvedData: resolution.resolved,
+                  conflictedFields: resolution.conflictedFields,
+                  strategy: this.config.conflictStrategy
+                }
+              });
+              const storeName = this.storeKey(pendingMutation.modelKey);
+              const existing = await this.storage.get(
+                storeName,
+                pendingMutation.clientId
+              );
+              if (existing) {
+                existing.data = resolution.resolved;
+                existing.syncVersion = resultItem.serverSyncVersion ?? existing.syncVersion;
+                existing.pending = false;
+                await this.storage.put(
+                  storeName,
+                  pendingMutation.clientId,
+                  existing
+                );
+              }
+              if (this.config.conflictStrategy !== "server-wins" && JSON.stringify(resolution.resolved) !== JSON.stringify(serverData)) {
+                await this.queue.enqueue({
+                  clientId: resultItem.serverId,
+                  op: "update",
+                  modelKey: pendingMutation.modelKey,
+                  data: resolution.resolved,
+                  expectedSyncVersion: resultItem.serverSyncVersion
+                });
+              }
+              break;
+            }
+            case "error": {
+              errors++;
+              if (pendingMutation.retryCount >= 3) {
+                await this.queue.remove(pendingMutation.queueId);
+                this.log(
+                  `Giving up on mutation ${pendingMutation.queueId}: ${resultItem.error}`
+                );
+              } else {
+                await this.queue.incrementRetry(pendingMutation.queueId);
+              }
+              break;
+            }
+          }
+        }
+      } catch (error) {
+        this.log("Push failed (network):", error);
+        break;
+      }
+    }
+    const pendingCount = await this.queue.count();
+    this.emit({ type: "pending-changed", count: pendingCount });
+    return { pushed, conflicts, errors };
+  }
+  // -------------------------------------------------------------------------
+  // Subscriptions — Real-time updates via WebSocket
+  // -------------------------------------------------------------------------
+  connectSubscriptions() {
+    const wsUrl = this.config.wsUrl;
+    if (!wsUrl) {
+      this.log("No wsUrl configured \u2014 using polling only");
+      return;
+    }
+    try {
+      void this.setupWebSocket(wsUrl);
+    } catch {
+      this.log("WebSocket setup failed \u2014 using polling only");
+    }
+  }
+  async setupWebSocket(wsUrl) {
+    try {
+      const { createClient } = await import("graphql-ws");
+      const connectionParams = {};
+      if (this.config.apiKey) {
+        connectionParams["x-api-key"] = this.config.apiKey;
+      }
+      if (this.config.token) {
+        connectionParams.authorization = `Bearer ${this.config.token}`;
+      }
+      const client = createClient({
+        url: wsUrl,
+        connectionParams,
+        retryAttempts: Infinity,
+        retryWait: async (retryCount) => {
+          const delay = Math.min(1e3 * Math.pow(2, retryCount), 3e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        },
+        on: {
+          connected: () => {
+            this.emit({ type: "connected" });
+            this.log("WebSocket connected");
+          },
+          closed: () => {
+            this.emit({ type: "disconnected" });
+            this.log("WebSocket disconnected");
+          }
+        }
+      });
+      const cleanups = [];
+      for (const modelKey of this.config.modelKeys) {
+        const cleanup = client.subscribe(
+          { query: RECORD_CHANGED_SUBSCRIPTION, variables: { modelKey } },
+          {
+            next: (result) => {
+              if (result.data?.recordChanged) {
+                void this.handleSubscriptionEvent(result.data.recordChanged);
+              }
+            },
+            error: (err) => {
+              this.log("Subscription error:", err);
+            },
+            complete: () => {
+              this.log(`Subscription complete for ${modelKey}`);
+            }
+          }
+        );
+        cleanups.push(cleanup);
+      }
+      this.wsCleanup = () => {
+        for (const cleanup of cleanups) {
+          cleanup();
+        }
+        void client.dispose();
+      };
+    } catch (error) {
+      this.log("WebSocket setup error:", error);
+    }
+  }
+  async handleSubscriptionEvent(event) {
+    const storeName = this.storeKey(event.modelKey);
+    const existing = await this.storage.get(
+      storeName,
+      event.recordId
+    );
+    if (existing?.pending) {
+      this.log(
+        `Skipping subscription event for pending record ${event.recordId}`
+      );
+      return;
+    }
+    if (event.type === "deleted") {
+      const record = {
+        id: event.recordId,
+        clientId: event.recordId,
+        modelKey: event.modelKey,
+        naturalKey: event.naturalKey,
+        data: {},
+        metadata: null,
+        syncVersion: event.syncVersion,
+        updatedAt: new Date(parseInt(event.timestamp)).toISOString(),
+        deleted: true,
+        pending: false
+      };
+      await this.storage.put(storeName, event.recordId, record);
+    } else {
+      const record = {
+        id: event.recordId,
+        clientId: event.recordId,
+        modelKey: event.modelKey,
+        naturalKey: event.naturalKey,
+        data: event.data ?? {},
+        metadata: null,
+        syncVersion: event.syncVersion,
+        updatedAt: new Date(parseInt(event.timestamp)).toISOString(),
+        deleted: false,
+        pending: false
+      };
+      await this.storage.put(storeName, event.recordId, record);
+    }
+    const cursorKey = `cursor:${event.modelKey}`;
+    const currentCursor = await this.storage.getMeta(cursorKey) ?? "0";
+    if (BigInt(event.syncVersion) > BigInt(currentCursor)) {
+      await this.storage.setMeta(cursorKey, event.syncVersion);
+    }
+    this.emit({
+      type: "records-changed",
+      modelKey: event.modelKey,
+      recordIds: [event.recordId]
+    });
+  }
+  // -------------------------------------------------------------------------
+  // GraphQL Transport
+  // -------------------------------------------------------------------------
+  async graphqlQuery(query, variables) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["x-api-key"] = this.config.apiKey;
+    }
+    if (this.config.token) {
+      headers["Authorization"] = `Bearer ${this.config.token}`;
+    }
+    const response = await fetch(this.config.graphqlUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, variables })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `GraphQL request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    if (json.errors?.length) {
+      throw new Error(
+        `GraphQL errors: ${json.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    if (!json.data) {
+      throw new Error("GraphQL response missing data");
+    }
+    return json.data;
+  }
+  // -------------------------------------------------------------------------
+  // Internal Helpers
+  // -------------------------------------------------------------------------
+  storeKey(modelKey) {
+    return `records:${modelKey}`;
+  }
+};
+
+// src/storage/memory-adapter.ts
+var MemoryAdapter = class {
+  constructor() {
+    this.stores = /* @__PURE__ */ new Map();
+    this.meta = /* @__PURE__ */ new Map();
+  }
+  getStore(name) {
+    let store = this.stores.get(name);
+    if (!store) {
+      store = /* @__PURE__ */ new Map();
+      this.stores.set(name, store);
+    }
+    return store;
+  }
+  async get(store, key) {
+    return this.getStore(store).get(key);
+  }
+  async put(store, key, value) {
+    this.getStore(store).set(key, value);
+  }
+  async delete(store, key) {
+    this.getStore(store).delete(key);
+  }
+  async getAll(store) {
+    return Array.from(this.getStore(store).values());
+  }
+  async clear(store) {
+    this.getStore(store).clear();
+  }
+  async getMeta(key) {
+    return this.meta.get(key);
+  }
+  async setMeta(key, value) {
+    this.meta.set(key, value);
+  }
+};
+
+// src/storage/indexeddb-adapter.ts
+var idbModule = null;
+async function getIdb() {
+  if (!idbModule) {
+    idbModule = await import("idb");
+  }
+  return idbModule;
+}
+var META_STORE = "__meta";
+var IndexedDBAdapter = class {
+  constructor(dbName = "eide-sync") {
+    this.db = null;
+    this.knownStores = /* @__PURE__ */ new Set([META_STORE]);
+    this.version = 1;
+    this.dbName = dbName;
+  }
+  async ensureStore(storeName) {
+    if (this.db && this.knownStores.has(storeName)) {
+      return this.db;
+    }
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.knownStores.add(storeName);
+    this.version++;
+    const { openDB } = await getIdb();
+    const storeNames = [...this.knownStores];
+    this.db = await openDB(this.dbName, this.version, {
+      upgrade(db) {
+        for (const name of storeNames) {
+          if (!db.objectStoreNames.contains(name)) {
+            db.createObjectStore(name);
+          }
+        }
+      }
+    });
+    return this.db;
+  }
+  async get(store, key) {
+    const db = await this.ensureStore(store);
+    return db.get(store, key);
+  }
+  async put(store, key, value) {
+    const db = await this.ensureStore(store);
+    await db.put(store, value, key);
+  }
+  async delete(store, key) {
+    const db = await this.ensureStore(store);
+    await db.delete(store, key);
+  }
+  async getAll(store) {
+    const db = await this.ensureStore(store);
+    return db.getAll(store);
+  }
+  async clear(store) {
+    const db = await this.ensureStore(store);
+    await db.clear(store);
+  }
+  async getMeta(key) {
+    return this.get(META_STORE, key);
+  }
+  async setMeta(key, value) {
+    await this.put(META_STORE, key, value);
+  }
+};
+
+// src/collab/presence.ts
+var COLORS = [
+  "#ef4444",
+  // red
+  "#f97316",
+  // orange
+  "#eab308",
+  // yellow
+  "#22c55e",
+  // green
+  "#14b8a6",
+  // teal
+  "#3b82f6",
+  // blue
+  "#8b5cf6",
+  // purple
+  "#ec4899"
+  // pink
+];
+function getUserColor(userId) {
+  let hash = 0;
+  for (let i = 0; i < userId.length; i++) {
+    hash = userId.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  return COLORS[Math.abs(hash) % COLORS.length];
+}
+
+// src/collab/collab-session.ts
+var roomSuppressionMap = /* @__PURE__ */ new Map();
+var CollabSession = class {
+  constructor(options) {
+    // Yjs primitives
+    this._ydoc = null;
+    this._content = null;
+    this._changesLog = null;
+    this._undoManager = null;
+    this._awareness = null;
+    // WebSocket provider (y-websocket)
+    this.provider = null;
+    // State
+    this._connected = false;
+    this._synced = false;
+    this._activeUsers = [];
+    this._sessionChanges = [];
+    this._canUndo = false;
+    this._canRedo = false;
+    // Internal tracking
+    this.fieldSessions = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.cleanupFns = [];
+    this.options = options;
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  get ydoc() {
+    return this._ydoc;
+  }
+  get content() {
+    return this._content;
+  }
+  get changesLog() {
+    return this._changesLog;
+  }
+  get undoManager() {
+    return this._undoManager;
+  }
+  get awareness() {
+    return this._awareness;
+  }
+  get connected() {
+    return this._connected;
+  }
+  get synced() {
+    return this._synced;
+  }
+  get activeUsers() {
+    return this._activeUsers;
+  }
+  get sessionChanges() {
+    return this._sessionChanges;
+  }
+  get canUndo() {
+    return this._canUndo;
+  }
+  get canRedo() {
+    return this._canRedo;
+  }
+  get room() {
+    return this.options.room;
+  }
+  // ---------------------------------------------------------------------------
+  // Event System
+  // ---------------------------------------------------------------------------
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return () => {
+      this.listeners.get(event)?.delete(handler);
+    };
+  }
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Connection Lifecycle
+  // ---------------------------------------------------------------------------
+  async connect() {
+    const Y = await import("yjs");
+    const { WebsocketProvider } = await import("y-websocket");
+    this._ydoc = new Y.Doc();
+    this._content = this._ydoc.getMap("content");
+    this._changesLog = this._ydoc.getArray("changesLog");
+    let wsUrl = this.options.wsUrl;
+    const params = new URLSearchParams();
+    if (this.options.auth?.apiKey) {
+      params.set("apiKey", this.options.auth.apiKey);
+    }
+    if (this.options.auth?.token) {
+      params.set("token", this.options.auth.token);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      wsUrl = `${wsUrl}${wsUrl.includes("?") ? "&" : "?"}${queryString}`;
+    }
+    this.provider = new WebsocketProvider(wsUrl, this.options.room, this._ydoc);
+    this._awareness = this.provider.awareness;
+    const handleStatus = ({ status }) => {
+      const wasConnected = this._connected;
+      this._connected = status === "connected";
+      if (this._connected && !wasConnected) {
+        this.emit("connected", void 0);
+      } else if (!this._connected && wasConnected) {
+        this.emit("disconnected", void 0);
+      }
+    };
+    const handleSync = (isSynced) => {
+      this._synced = isSynced;
+      if (isSynced) {
+        this.emit("synced", void 0);
+      }
+    };
+    this.provider.on("status", handleStatus);
+    this.provider.on("sync", handleSync);
+    this.cleanupFns.push(() => {
+      this.provider.off("status", handleStatus);
+      this.provider.off("sync", handleSync);
+    });
+    this.setupPresence();
+    this.setupContentObservation(Y);
+  }
+  disconnect() {
+    for (const session of this.fieldSessions.values()) {
+      if (session.debounceTimer) clearTimeout(session.debounceTimer);
+    }
+    this.fieldSessions.clear();
+    for (const fn of this.cleanupFns) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.cleanupFns = [];
+    if (this._undoManager) {
+      this._undoManager.destroy();
+      this._undoManager = null;
+    }
+    if (this.provider) {
+      this.provider.disconnect();
+      this.provider = null;
+    }
+    if (this._ydoc) {
+      this._ydoc.destroy();
+      this._ydoc = null;
+    }
+    this._content = null;
+    this._changesLog = null;
+    this._awareness = null;
+    this._connected = false;
+    this._synced = false;
+    this._activeUsers = [];
+    this._sessionChanges = [];
+    this._canUndo = false;
+    this._canRedo = false;
+    this.emit("disconnected", void 0);
+  }
+  // ---------------------------------------------------------------------------
+  // Presence
+  // ---------------------------------------------------------------------------
+  setupPresence() {
+    if (!this._awareness || !this.options.user) return;
+    const user = this.options.user;
+    const color = user.color || getUserColor(user.id);
+    this._awareness.setLocalState({
+      user: { id: user.id, name: user.name, color }
+    });
+    const handleAwarenessChange = () => {
+      if (!this._awareness) return;
+      const states = this._awareness.getStates();
+      const users = [];
+      states.forEach((state, clientId) => {
+        if (state?.user && clientId !== this._awareness.clientID) {
+          users.push({
+            userId: state.user.id,
+            userName: state.user.name,
+            color: state.user.color,
+            joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      });
+      this._activeUsers = users;
+      this.emit("presence-changed", users);
+    };
+    this._awareness.on("change", handleAwarenessChange);
+    this.cleanupFns.push(
+      () => this._awareness?.off("change", handleAwarenessChange)
+    );
+    handleAwarenessChange();
+  }
+  setUser(user) {
+    this.options.user = user;
+    if (this._awareness) {
+      this._awareness.setLocalState({
+        user: {
+          id: user.id,
+          name: user.name,
+          color: user.color || getUserColor(user.id)
+        }
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Content Observation + UndoManager
+  // ---------------------------------------------------------------------------
+  setupContentObservation(Y) {
+    if (!this._ydoc || !this._content || !this._changesLog) return;
+    const content = this._content;
+    const changesLog = this._changesLog;
+    const um = new Y.UndoManager(content, {
+      trackedOrigins: /* @__PURE__ */ new Set(["user-edit"]),
+      captureTimeout: 2e3
+    });
+    this._undoManager = um;
+    const updateUndoState = () => {
+      const hasChanges = changesLog.length > 0;
+      this._canUndo = hasChanges;
+      this._canRedo = um.canRedo();
+      this.emit("can-undo-changed", {
+        canUndo: this._canUndo,
+        canRedo: this._canRedo
+      });
+    };
+    changesLog.observe(updateUndoState);
+    um.on("stack-item-added", updateUndoState);
+    um.on("stack-item-popped", updateUndoState);
+    um.on("stack-item-updated", updateUndoState);
+    this.cleanupFns.push(() => {
+      changesLog.unobserve(updateUndoState);
+      um.off("stack-item-added", updateUndoState);
+      um.off("stack-item-popped", updateUndoState);
+      um.off("stack-item-updated", updateUndoState);
+    });
+    const existing = changesLog.toArray();
+    if (existing.length > 0) {
+      this._sessionChanges = existing;
+      this.emit("changelog-changed", existing);
+    }
+    const handleChangesLogUpdate = () => {
+      this._sessionChanges = changesLog.toArray();
+      this.emit("changelog-changed", this._sessionChanges);
+    };
+    changesLog.observe(handleChangesLogUpdate);
+    this.cleanupFns.push(() => changesLog.unobserve(handleChangesLogUpdate));
+    const handleChange = (event, transaction) => {
+      if (transaction.origin === "initialize" || transaction.origin === "changes-log") {
+        return;
+      }
+      const isRevert = transaction.origin === "revert";
+      const isUndoRedo = transaction.origin === um;
+      const isRemoteChange = !transaction.local && transaction.origin !== um;
+      if (isUndoRedo || isRevert || isRemoteChange) {
+        event.changes.keys.forEach((_change, key) => {
+          const newValue = content.get(key);
+          const origin = isUndoRedo ? "undo" : isRevert ? "revert" : "remote";
+          this.emit("field-updated", { path: key, value: newValue, origin });
+        });
+      }
+    };
+    content.observe(handleChange);
+    this.cleanupFns.push(() => content.unobserve(handleChange));
+  }
+  // ---------------------------------------------------------------------------
+  // Content Operations
+  // ---------------------------------------------------------------------------
+  updateField(fieldPath, value) {
+    if (!this._ydoc || !this._content || !this._changesLog) return;
+    const content = this._content;
+    const changesLog = this._changesLog;
+    const ydoc = this._ydoc;
+    let session = this.fieldSessions.get(fieldPath);
+    if (!session) {
+      session = { initialValue: content.get(fieldPath), debounceTimer: null };
+      this.fieldSessions.set(fieldPath, session);
+    }
+    ydoc.transact(() => {
+      content.set(fieldPath, value);
+    }, "user-edit");
+    if (session.debounceTimer) clearTimeout(session.debounceTimer);
+    const currentSession = session;
+    const capturedRoom = this.options.room;
+    const userId = this.options.user?.id || "unknown";
+    const userName = this.options.user?.name || "Unknown";
+    session.debounceTimer = setTimeout(() => {
+      const suppressUntil = roomSuppressionMap.get(capturedRoom) || 0;
+      if (Date.now() < suppressUntil) {
+        this.fieldSessions.delete(fieldPath);
+        return;
+      }
+      const finalValue = content.get(fieldPath);
+      if (JSON.stringify(finalValue) !== JSON.stringify(currentSession.initialValue)) {
+        const change = {
+          id: `${Date.now()}-${fieldPath}`,
+          fieldPath,
+          fieldValue: finalValue,
+          previousValue: currentSession.initialValue,
+          userId,
+          userName,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        ydoc.transact(() => {
+          changesLog.push([change]);
+        }, "changes-log");
+      }
+      this.fieldSessions.delete(fieldPath);
+    }, 1e3);
+  }
+  initializeContent(values, versionId) {
+    if (!this._ydoc || !this._content) return;
+    const content = this._content;
+    if (content.size === 0) {
+      this._ydoc.transact(() => {
+        if (versionId) content.set("__versionId__", versionId);
+        for (const [key, value] of Object.entries(values)) {
+          content.set(key, value);
+        }
+      }, "initialize");
+    }
+  }
+  getContent() {
+    if (!this._content) return {};
+    const result = {};
+    this._content.forEach((value, key) => {
+      if (key !== "__versionId__") {
+        result[key] = value;
+      }
+    });
+    return result;
+  }
+  getContentStatus() {
+    if (!this._content) return { hasContent: false, versionId: null };
+    const content = this._content;
+    const hasActualContent = content.size > 0 && (content.size > 1 || !content.has("__versionId__"));
+    if (!hasActualContent) return { hasContent: false, versionId: null };
+    const storedVersionId = content.get("__versionId__");
+    return { hasContent: true, versionId: storedVersionId || null };
+  }
+  loadContentIntoForm() {
+    if (!this._content) return false;
+    const content = this._content;
+    const hasActualContent = content.size > 0 && (content.size > 1 || !content.has("__versionId__"));
+    if (!hasActualContent) return false;
+    content.forEach((value, key) => {
+      if (key !== "__versionId__") {
+        this.emit("field-updated", { path: key, value, origin: "restore" });
+      }
+    });
+    return true;
+  }
+  // ---------------------------------------------------------------------------
+  // Undo / Redo / Revert
+  // ---------------------------------------------------------------------------
+  undo() {
+    if (!this._ydoc || !this._changesLog) return;
+    const changesLog = this._changesLog;
+    const changes = changesLog.toArray();
+    if (changes.length === 0) return;
+    const lastChange = changes[changes.length - 1];
+    if (!lastChange) return;
+    this._ydoc.transact(() => {
+      changesLog.delete(changes.length - 1, 1);
+    }, "undo-cleanup");
+    if (lastChange.previousValue !== void 0 && this._content) {
+      this._ydoc.transact(() => {
+        this._content.set(lastChange.fieldPath, lastChange.previousValue);
+      }, "revert");
+    }
+  }
+  redo() {
+    if (this._undoManager?.canRedo()) {
+      this._undoManager.redo();
+    }
+  }
+  revertField(fieldPath, previousValue, changeId) {
+    if (!this._ydoc || !this._content || !this._changesLog) return;
+    if (changeId) {
+      const changes = this._changesLog.toArray();
+      const idx = changes.findIndex((c) => c.id === changeId);
+      if (idx !== -1) {
+        this._ydoc.transact(() => {
+          this._changesLog.delete(idx, 1);
+        }, "revert-cleanup");
+      }
+    }
+    if (previousValue !== void 0) {
+      this._ydoc.transact(() => {
+        this._content.set(fieldPath, previousValue);
+      }, "revert");
+    }
+  }
+  revertAll() {
+    if (!this._undoManager) return;
+    while (this._undoManager.canUndo()) {
+      this._undoManager.undo();
+    }
+    this._sessionChanges = [];
+    for (const session of this.fieldSessions.values()) {
+      if (session.debounceTimer) clearTimeout(session.debounceTimer);
+    }
+    this.fieldSessions.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Session Management
+  // ---------------------------------------------------------------------------
+  async clearSession() {
+    if (!this._ydoc) return;
+    const room = this.options.room;
+    roomSuppressionMap.set(room, Date.now() + 2e3);
+    if (this._changesLog) {
+      this._ydoc.transact(() => {
+        this._changesLog.delete(0, this._changesLog.length);
+      }, "clear-session");
+    }
+    if (this._content) {
+      this._ydoc.transact(() => {
+        this._content.clear();
+      }, "clear-session");
+    }
+    this._sessionChanges = [];
+    for (const session of this.fieldSessions.values()) {
+      if (session.debounceTimer) clearTimeout(session.debounceTimer);
+    }
+    this.fieldSessions.clear();
+    if (this._undoManager) this._undoManager.clear();
+    if (this.options.apiUrl) {
+      try {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        const fetchOpts = {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ room })
+        };
+        if (this.options.auth?.sessionCookie) {
+          fetchOpts.credentials = "include";
+        }
+        if (this.options.auth?.apiKey) {
+          headers["x-api-key"] = this.options.auth.apiKey;
+        }
+        if (this.options.auth?.token) {
+          headers["Authorization"] = `Bearer ${this.options.auth.token}`;
+        }
+        await fetch(`${this.options.apiUrl}/api/yjs/clear-session`, fetchOpts);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Suppress changes for a duration (ms). Used to prevent phantom
+   * change entries after save/clear.
+   */
+  suppressChanges(durationMs) {
+    roomSuppressionMap.set(this.options.room, Date.now() + durationMs);
+  }
+  clearContent() {
+    if (!this._ydoc || !this._content || !this._changesLog) return;
+    this._ydoc.transact(() => {
+      this._content.clear();
+      this._changesLog.delete(0, this._changesLog.length);
+    }, "clear-stale");
+    this._sessionChanges = [];
+    this.emit("changelog-changed", []);
+  }
+};
+
+// src/react/SyncProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var SyncContext = createContext(null);
+function SyncProvider({
+  config,
+  storage,
+  children,
+  autoStart = true
+}) {
+  const engineRef = useRef(null);
+  const [connected, setConnected] = useState(false);
+  const [pendingCount, setPendingCount] = useState(0);
+  const [lastSyncError, setLastSyncError] = useState(null);
+  if (!engineRef.current) {
+    engineRef.current = new SyncEngine(config, storage);
+  }
+  const engine = engineRef.current;
+  useEffect(() => {
+    const handler = (event) => {
+      switch (event.type) {
+        case "connected":
+          setConnected(true);
+          break;
+        case "disconnected":
+          setConnected(false);
+          break;
+        case "pending-changed":
+          setPendingCount(event.count);
+          break;
+        case "sync-error":
+          setLastSyncError(event.error);
+          break;
+        case "sync-complete":
+          setLastSyncError(null);
+          break;
+      }
+    };
+    const unsubscribe = engine.on(handler);
+    if (autoStart) {
+      engine.start();
+    }
+    return () => {
+      unsubscribe();
+      engine.stop();
+    };
+  }, [engine, autoStart]);
+  return /* @__PURE__ */ jsx(
+    SyncContext.Provider,
+    {
+      value: { engine, connected, pendingCount, lastSyncError },
+      children
+    }
+  );
+}
+function useSyncContext() {
+  const ctx = useContext(SyncContext);
+  if (!ctx) {
+    throw new Error("useSyncContext must be used within a <SyncProvider>");
+  }
+  return ctx;
+}
+
+// src/react/useSyncQuery.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+function useSyncQuery(modelKey, options) {
+  const { engine } = useSyncContext();
+  const [data, setData] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const optionsRef = useRef2(options);
+  optionsRef.current = options;
+  const fetchData = useCallback(async () => {
+    try {
+      const records = await engine.query(modelKey, optionsRef.current);
+      setData(records);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [engine, modelKey]);
+  useEffect2(() => {
+    void fetchData();
+  }, [fetchData]);
+  useEffect2(() => {
+    const handler = (event) => {
+      if (event.type === "records-changed" && event.modelKey === modelKey) {
+        void fetchData();
+      }
+      if (event.type === "sync-complete") {
+        void fetchData();
+      }
+    };
+    return engine.on(handler);
+  }, [engine, modelKey, fetchData]);
+  return { data, loading, error, refetch: fetchData };
+}
+function useSyncRecord(modelKey, id) {
+  const { engine } = useSyncContext();
+  const [data, setData] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const fetchData = useCallback(async () => {
+    if (!id) {
+      setData(null);
+      setLoading(false);
+      return;
+    }
+    try {
+      const record = await engine.get(modelKey, id);
+      setData(record);
+    } finally {
+      setLoading(false);
+    }
+  }, [engine, modelKey, id]);
+  useEffect2(() => {
+    void fetchData();
+  }, [fetchData]);
+  useEffect2(() => {
+    const handler = (event) => {
+      if (event.type === "records-changed" && event.modelKey === modelKey && id && event.recordIds.includes(id)) {
+        void fetchData();
+      }
+    };
+    return engine.on(handler);
+  }, [engine, modelKey, id, fetchData]);
+  return { data, loading };
+}
+
+// src/react/useSyncMutation.ts
+import { useCallback as useCallback2 } from "react";
+function useSyncMutation() {
+  const { engine, pendingCount } = useSyncContext();
+  const create = useCallback2(
+    async (modelKey, data, naturalKey) => {
+      return engine.create(modelKey, data, naturalKey);
+    },
+    [engine]
+  );
+  const update = useCallback2(
+    async (modelKey, id, data) => {
+      return engine.update(modelKey, id, data);
+    },
+    [engine]
+  );
+  const remove = useCallback2(
+    async (modelKey, id) => {
+      return engine.delete(modelKey, id);
+    },
+    [engine]
+  );
+  const sync = useCallback2(async () => {
+    await engine.sync();
+  }, [engine]);
+  return { create, update, remove, sync, pendingCount };
+}
+
+// src/react/useCollaborativeSession.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+function useCollaborativeSession(options) {
+  const sessionRef = useRef3(null);
+  const [connected, setConnected] = useState3(false);
+  const [synced, setSynced] = useState3(false);
+  const [activeUsers, setActiveUsers] = useState3([]);
+  const [changelog, setChangelog] = useState3([]);
+  const [canUndo, setCanUndo] = useState3(false);
+  const [canRedo, setCanRedo] = useState3(false);
+  const onFieldUpdateRef = useRef3(options.onFieldUpdate);
+  onFieldUpdateRef.current = options.onFieldUpdate;
+  const enabled = options.enabled ?? true;
+  const room = options.room;
+  useEffect3(() => {
+    if (!enabled || !room) return;
+    const session = new CollabSession({
+      wsUrl: options.wsUrl,
+      room: options.room,
+      user: options.user,
+      apiUrl: options.apiUrl,
+      auth: options.auth
+    });
+    sessionRef.current = session;
+    const unsubs = [];
+    unsubs.push(session.on("connected", () => setConnected(true)));
+    unsubs.push(session.on("disconnected", () => setConnected(false)));
+    unsubs.push(session.on("synced", () => setSynced(true)));
+    unsubs.push(
+      session.on("presence-changed", (users) => setActiveUsers(users))
+    );
+    unsubs.push(
+      session.on("changelog-changed", (changes) => setChangelog(changes))
+    );
+    unsubs.push(
+      session.on("can-undo-changed", (state) => {
+        setCanUndo(state.canUndo);
+        setCanRedo(state.canRedo);
+      })
+    );
+    unsubs.push(
+      session.on("field-updated", (event) => {
+        onFieldUpdateRef.current?.(event.path, event.value, event.origin);
+      })
+    );
+    void session.connect();
+    return () => {
+      for (const unsub of unsubs) unsub();
+      session.disconnect();
+      sessionRef.current = null;
+      setConnected(false);
+      setSynced(false);
+      setActiveUsers([]);
+      setChangelog([]);
+      setCanUndo(false);
+      setCanRedo(false);
+    };
+  }, [room, enabled]);
+  const updateField = useCallback3(
+    (fieldPath, value) => sessionRef.current?.updateField(fieldPath, value),
+    []
+  );
+  const undo = useCallback3(() => sessionRef.current?.undo(), []);
+  const redo = useCallback3(() => sessionRef.current?.redo(), []);
+  const revertField = useCallback3(
+    (fieldPath, previousValue, changeId) => sessionRef.current?.revertField(fieldPath, previousValue, changeId),
+    []
+  );
+  const revertAll = useCallback3(() => sessionRef.current?.revertAll(), []);
+  const getContent = useCallback3(
+    () => sessionRef.current?.getContent() ?? {},
+    []
+  );
+  const getContentStatus = useCallback3(
+    () => sessionRef.current?.getContentStatus() ?? {
+      hasContent: false,
+      versionId: null
+    },
+    []
+  );
+  const initializeContent = useCallback3(
+    (values, versionId) => sessionRef.current?.initializeContent(values, versionId),
+    []
+  );
+  const loadContentIntoForm = useCallback3(
+    () => sessionRef.current?.loadContentIntoForm() ?? false,
+    []
+  );
+  const clearSession = useCallback3(async () => {
+    await sessionRef.current?.clearSession();
+  }, []);
+  const clearContent = useCallback3(
+    () => sessionRef.current?.clearContent(),
+    []
+  );
+  return {
+    session: sessionRef.current,
+    connected,
+    synced,
+    activeUsers,
+    changelog,
+    canUndo,
+    canRedo,
+    updateField,
+    undo,
+    redo,
+    revertField,
+    revertAll,
+    getContent,
+    getContentStatus,
+    initializeContent,
+    loadContentIntoForm,
+    clearSession,
+    clearContent
+  };
+}
+
+// src/bridge/bridge.ts
+var AUTO_SAVE_DEBOUNCE_MS = 2e3;
+var SyncBridge = class {
+  constructor(engine, session, options) {
+    this.cleanupFns = [];
+    this.autoSaveTimer = null;
+    /** Tracks our own writes to prevent re-applying them from subscription */
+    this.selfWriteVersions = /* @__PURE__ */ new Set();
+    this.engine = engine;
+    this.session = session;
+    this.options = { autoSave: true, ...options };
+    this.setup();
+  }
+  setup() {
+    if (this.options.autoSave) {
+      const handleFieldUpdate = (event) => {
+        if (event.origin !== "user-edit") return;
+        if (this.autoSaveTimer) clearTimeout(this.autoSaveTimer);
+        this.autoSaveTimer = setTimeout(() => {
+          this.autoSaveTimer = null;
+          void this.autoSave();
+        }, AUTO_SAVE_DEBOUNCE_MS);
+      };
+      if (this.session.ydoc) {
+        const content = this.session.ydoc.getMap("content");
+        const observer = (_event, transaction) => {
+          if (transaction.origin === "user-edit") {
+            handleFieldUpdate({ path: "", value: null, origin: "user-edit" });
+          }
+        };
+        content.observe(observer);
+        this.cleanupFns.push(() => content.unobserve(observer));
+      }
+    }
+    const handleSyncEvent = (event) => {
+      if (event.type !== "records-changed") return;
+      if (event.modelKey !== this.options.modelKey) return;
+      if (!event.recordIds.includes(this.options.recordId)) return;
+      void this.applyRemoteChanges();
+    };
+    const unsubSync = this.engine.on(handleSyncEvent);
+    this.cleanupFns.push(unsubSync);
+  }
+  /**
+   * Auto-save: read content from CollabSession Y.Doc, push via SyncEngine.
+   */
+  async autoSave() {
+    const data = this.session.getContent();
+    if (Object.keys(data).length === 0) return;
+    try {
+      const result = await this.engine.update(
+        this.options.modelKey,
+        this.options.recordId,
+        data
+      );
+      if (result) {
+        this.selfWriteVersions.add(result.syncVersion);
+        if (this.selfWriteVersions.size > 20) {
+          const first = this.selfWriteVersions.values().next().value;
+          if (first) this.selfWriteVersions.delete(first);
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Apply remote changes from SyncEngine to CollabSession Y.Doc.
+   * Uses 'remote-sync' origin to prevent re-pushing.
+   */
+  async applyRemoteChanges() {
+    const record = await this.engine.get(
+      this.options.modelKey,
+      this.options.recordId
+    );
+    if (!record) return;
+    if (this.selfWriteVersions.has(record.syncVersion)) {
+      this.selfWriteVersions.delete(record.syncVersion);
+      return;
+    }
+    if (this.session.ydoc) {
+      const content = this.session.ydoc.getMap("content");
+      this.session.ydoc.transact(() => {
+        for (const [key, value] of Object.entries(record.data)) {
+          const currentValue = content.get(key);
+          if (JSON.stringify(currentValue) !== JSON.stringify(value)) {
+            content.set(key, value);
+          }
+        }
+      }, "remote-sync");
+    }
+  }
+  /**
+   * Manual save: used for "version save" mode (admin clicks Save button).
+   * Reads content from CollabSession, pushes immediately, then clears session.
+   */
+  async saveVersion() {
+    const data = this.session.getContent();
+    await this.engine.update(
+      this.options.modelKey,
+      this.options.recordId,
+      data
+    );
+    await this.engine.sync();
+    await this.session.clearSession();
+    return data;
+  }
+  /**
+   * Destroy the bridge and clean up all subscriptions.
+   */
+  destroy() {
+    if (this.autoSaveTimer) {
+      clearTimeout(this.autoSaveTimer);
+      this.autoSaveTimer = null;
+    }
+    for (const fn of this.cleanupFns) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.cleanupFns = [];
+    this.selfWriteVersions.clear();
+  }
+};
+export {
+  CollabSession,
+  IndexedDBAdapter,
+  MemoryAdapter,
+  SyncBridge,
+  SyncEngine,
+  SyncProvider,
+  getUserColor,
+  useCollaborativeSession,
+  useSyncContext,
+  useSyncMutation,
+  useSyncQuery,
+  useSyncRecord
+};