edmaxlabs-core 2.5.6 → 2.6.7

package/dist/index.cjs

@@ -391,20 +391,6 @@ var DocumentSnapshot = class _DocumentSnapshot {
   }
 };
 
-// src/utils/documentNomalizer.ts
-function normalizePayload(payload) {
-  const raw = payload?.document ?? payload?.data ?? payload;
-  if (!raw)
-    return null;
-  const doc = { ...raw };
-  doc.id = payload.id ?? payload._id;
-  delete doc._id;
-  return {
-    change: payload?.change ?? raw?.change ?? null,
-    data: doc
-  };
-}
-
 // src/database/DocumentRef.ts
 function validateDocumentData(data, operation) {
   if (data === null || data === void 0) {
@@ -430,40 +416,22 @@ var DocumentRef = class {
     this.syncEngine = app.offline().syncEngine;
     this.localStore = app.offline().localStore;
   }
-  // ====================== GET ======================
   async get() {
     if (this.persistence) {
       try {
         const localSnap = await this.persistence.getDocSnapshot(this.collection, this.id);
+        if (typeof navigator === "undefined" || navigator.onLine) {
+          this.refreshFromRemote().catch(() => {
+          });
+        }
         if (localSnap)
           return localSnap;
       } catch (error) {
         console.error("[EdmaxLabs] Cache read error:", error);
       }
     }
-    try {
-      const res = await new HttpsRequest({
-        method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/db/read`,
-        headers: {
-          authorization: this.app.getConfig().token,
-          "x-project": this.app.getConfig().project
-        },
-        body: {
-          collection: this.collection,
-          id: this.id,
-          single: true
-        }
-      }).sendRequest();
-      if (!res?.success || !res.document)
-        return null;
-      return DocumentSnapshot.fromMap(res.document);
-    } catch (error) {
-      console.error(`[DocumentRef] get(${this.collection}/${this.id}) failed:`, error);
-      return null;
-    }
+    return this.fetchRemoteSnapshot();
   }
-  // ====================== UPDATE ======================
   async update(data) {
     if (this._isUpdating) {
       console.warn(`[DocumentRef] update recursion blocked on ${this.collection}/${this.id}`);
@@ -509,15 +477,13 @@ var DocumentRef = class {
         baseRevision: old.revision
       });
       const snap = DocumentSnapshot.fromMap(updated.data);
-      this.localStore?.emitDocument(this.collection, this.id, snap, "update");
-      this.localStore?.notifyCollectionChanged(this.collection, this.id, "update");
+      this.app.offline().realtimeBridge?.publishLocalChange(this.collection, this.id, "update").catch(console.error);
       this.syncEngine?.flush().catch(console.error);
       return snap;
     } finally {
       this._isUpdating = false;
     }
   }
-  // ====================== SET ======================
   async set(data) {
     validateDocumentData(data, "DocumentRef.set");
     if (!this.persistence) {
@@ -532,6 +498,8 @@ var DocumentRef = class {
       }).sendRequest();
       return res?.success ? DocumentSnapshot.fromMap({ ...data, id: this.id }) : null;
     }
+    const existing = await this.persistence.getDoc(this.collection, this.id);
+    const mutationType = existing?.exists && !existing.deleted ? "update" : "insert";
     const updated = await this.persistence.upsertDoc({
       collection: this.collection,
       id: this.id,
@@ -540,22 +508,27 @@ var DocumentRef = class {
       deleted: false,
       pending: 1,
       localOnly: false,
-      status: "pending"
+      status: "pending",
+      revision: existing?.revision,
+      lastSyncedAt: existing?.lastSyncedAt
     });
     await this.persistence.enqueueMutation({
       mutationId: this.persistence.createMutationId(),
       collection: this.collection,
       documentId: this.id,
-      type: "insert",
-      payload: data
+      type: mutationType,
+      payload: data,
+      baseRevision: existing?.revision
     });
     const snap = DocumentSnapshot.fromMap(updated.data);
-    this.localStore?.emitDocument(this.collection, this.id, snap, "update");
-    this.localStore?.notifyCollectionChanged(this.collection, this.id, "update");
+    this.app.offline().realtimeBridge?.publishLocalChange(
+      this.collection,
+      this.id,
+      mutationType === "insert" ? "insert" : "update"
+    ).catch(console.error);
     this.syncEngine?.flush().catch(console.error);
     return snap;
   }
-  // ====================== DELETE ======================
   async delete() {
     if (this.persistence) {
       await this.persistence.markDeleted(this.collection, this.id, 1);
@@ -566,8 +539,7 @@ var DocumentRef = class {
         type: "delete",
         payload: null
       });
-      this.localStore?.emitDocument(this.collection, this.id, null, "empty");
-      this.localStore?.notifyCollectionChanged(this.collection, this.id, "delete");
+      this.app.offline().realtimeBridge?.publishLocalChange(this.collection, this.id, "delete").catch(console.error);
       this.syncEngine?.flush().catch(console.error);
       return true;
     }
@@ -582,20 +554,135 @@ var DocumentRef = class {
     }).sendRequest();
     return !!res?.success;
   }
-  // ====================== SNAPSHOT ======================
   onSnapshot(callback) {
-    if (this.persistence && this.localStore && this.app.offline().realtimeBridge) {
-      this.app.offline().realtimeBridge?.watchDocument(this.collection, this.id);
-      return this.localStore.subscribeToDocument(this.collection, this.id, callback) || (() => {
-      });
+    const realtimeBridge = this.app.offline().realtimeBridge;
+    if (this.persistence && this.localStore && realtimeBridge) {
+      const localUnsub = this.localStore.subscribeToDocument(this.collection, this.id, callback);
+      const remoteUnsub = realtimeBridge.watchDocument(this.collection, this.id);
+      this.persistence.getDocSnapshot(this.collection, this.id).then((snapshot) => callback(snapshot, "initial")).catch(console.error);
+      return () => {
+        localUnsub();
+        remoteUnsub();
+      };
     }
-    return this.app.rtdb().subscribeToDocumentRaw(this.collection, this.id, (snapshot, change) => {
-      const res = normalizePayload(snapshot);
-      callback(DocumentSnapshot.fromMap(res?.data), change);
+    this.fetchRemoteSnapshot().then((snapshot) => callback(snapshot, "initial")).catch(console.error);
+    return this.app.rtdb().subscribeToDocumentRaw(this.collection, this.id, (payload, change) => {
+      if (change === "delete") {
+        callback(null, "delete");
+        return;
+      }
+      callback(DocumentSnapshot.fromMap(payload), change);
     });
   }
+  async fetchRemoteSnapshot() {
+    try {
+      const res = await new HttpsRequest({
+        method: "POST" /* POST */,
+        endpoint: `${this.app.getBaseUrl()}/db/read`,
+        headers: {
+          authorization: this.app.getConfig().token,
+          "x-project": this.app.getConfig().project
+        },
+        body: {
+          collection: this.collection,
+          id: this.id,
+          single: true
+        }
+      }).sendRequest();
+      if (!res?.success || !res.document)
+        return null;
+      const snapshot = DocumentSnapshot.fromMap(res.document);
+      if (this.persistence) {
+        await this.persistence.applyRemoteDoc(this.collection, snapshot.data);
+      }
+      return snapshot;
+    } catch (error) {
+      console.error(`[DocumentRef] get(${this.collection}/${this.id}) failed:`, error);
+      return null;
+    }
+  }
+  async refreshFromRemote() {
+    const snapshot = await this.fetchRemoteSnapshot();
+    if (this.persistence && snapshot) {
+      this.app.offline().realtimeBridge?.publishLocalChange(this.collection, this.id, "update").catch(console.error);
+    }
+    return snapshot;
+  }
 };
 
+// src/database/RealtimeListeners.ts
+function buildTargetKey(collection, filter = {}) {
+  return `${collection}:${stableStringify(filter)}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+  return `{${entries.join(",")}}`;
+}
+function diffSnapshots(previous, next) {
+  const previousById = new Map(previous.map((snapshot, index) => [snapshot.id, { snapshot, index }]));
+  const nextById = new Map(next.map((snapshot, index) => [snapshot.id, { snapshot, index }]));
+  const changes = [];
+  next.forEach((snapshot, index) => {
+    const before = previousById.get(snapshot.id);
+    if (!before) {
+      changes.push({
+        type: "added",
+        doc: snapshot,
+        previousDoc: null,
+        oldIndex: -1,
+        newIndex: index
+      });
+      return;
+    }
+    if (before.index !== index || !areSnapshotsEqual(before.snapshot, snapshot)) {
+      changes.push({
+        type: "modified",
+        doc: snapshot,
+        previousDoc: before.snapshot,
+        oldIndex: before.index,
+        newIndex: index
+      });
+    }
+  });
+  previous.forEach((snapshot, index) => {
+    if (nextById.has(snapshot.id))
+      return;
+    changes.push({
+      type: "removed",
+      doc: snapshot,
+      previousDoc: snapshot,
+      oldIndex: index,
+      newIndex: -1
+    });
+  });
+  return changes;
+}
+function applySnapshotChange(current, incoming, source) {
+  if (!incoming) {
+    return current;
+  }
+  if (source === "delete") {
+    return current.filter((snapshot) => snapshot.id !== incoming.id);
+  }
+  const next = [...current];
+  const index = next.findIndex((snapshot) => snapshot.id === incoming.id);
+  if (index === -1) {
+    next.push(incoming);
+    return next;
+  }
+  next[index] = incoming;
+  return next;
+}
+function areSnapshotsEqual(left, right) {
+  return stableStringify(left.data) === stableStringify(right.data);
+}
+
 // src/database/Query.ts
 var Query = class {
   constructor(app, collection) {
@@ -608,6 +695,84 @@ var Query = class {
     this.filter.push(expression);
     return this;
   }
+  async get() {
+    const persistence = this.app.offline().persistence;
+    if (this.filter.length > 0 && persistence) {
+      const local = await this.getLocalFilteredSnapshots();
+      if (typeof navigator === "undefined" || !navigator.onLine) {
+        return local;
+      }
+      return this.refreshFromRemote();
+    }
+    if (persistence) {
+      const local = await persistence.getCollectionSnapshots(this.collection);
+      if (typeof navigator === "undefined" || navigator.onLine) {
+        this.refreshFromRemote().catch(() => {
+        });
+      }
+      return local;
+    }
+    return this.refreshFromRemote();
+  }
+  async update(data) {
+    const genfilter = this.buildFilter();
+    return new HttpsRequest({
+      method: "POST" /* POST */,
+      endpoint: `${this.app.getBaseUrl()}/db/update`,
+      headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
+      body: {
+        collection: this.collection,
+        filter: genfilter,
+        data
+      }
+    }).sendRequest();
+  }
+  onSnapshot(callback) {
+    const genfilter = this.buildFilter();
+    const persistence = this.app.offline().persistence;
+    const realtimeBridge = this.app.offline().realtimeBridge;
+    if (persistence && this.localStore && realtimeBridge) {
+      const targetKey = buildTargetKey(this.collection, genfilter);
+      const localUnsub = this.localStore.subscribeToCollection(targetKey, callback);
+      const remoteUnsub = realtimeBridge.watchCollection(
+        this.collection,
+        genfilter,
+        () => this.getLocalFilteredSnapshots()
+      );
+      this.getLocalFilteredSnapshots().then((snapshots) => {
+        realtimeBridge.primeCollectionTarget(this.collection, genfilter, snapshots);
+        callback(snapshots, "initial");
+      }).catch(console.error);
+      return () => {
+        localUnsub();
+        remoteUnsub();
+      };
+    }
+    return this.subscribeOnlineSnapshot(callback);
+  }
+  onChildListener(callbacks) {
+    const genfilter = this.buildFilter();
+    const persistence = this.app.offline().persistence;
+    const realtimeBridge = this.app.offline().realtimeBridge;
+    if (persistence && this.localStore && realtimeBridge) {
+      const targetKey = buildTargetKey(this.collection, genfilter);
+      const localUnsub = this.localStore.subscribeToChildEvents(targetKey, callbacks);
+      const remoteUnsub = realtimeBridge.watchCollection(
+        this.collection,
+        genfilter,
+        () => this.getLocalFilteredSnapshots()
+      );
+      this.getLocalFilteredSnapshots().then((snapshots) => {
+        realtimeBridge.primeCollectionTarget(this.collection, genfilter, snapshots);
+        this.emitInitialChildEvents(snapshots, callbacks);
+      }).catch(console.error);
+      return () => {
+        localUnsub();
+        remoteUnsub();
+      };
+    }
+    return this.subscribeOnlineChildListener(callbacks);
+  }
   buildFilter() {
     const mongoFilter = {};
     this.filter.forEach(({ key, op, value }) => {
@@ -678,9 +843,7 @@ var Query = class {
     if (this.filter.length === 0)
       return docs;
     return docs.filter(
-      (snapshot) => this.filter.every(
-        (expression) => this.matchesFilter(snapshot.data, expression)
-      )
+      (snapshot) => this.filter.every((expression) => this.matchesFilter(snapshot.data, expression))
     );
   }
   async getLocalFilteredSnapshots() {
@@ -690,25 +853,6 @@ var Query = class {
     const docs = await persistence.getCollectionSnapshots(this.collection);
     return this.filterDocuments(docs);
   }
-  async get() {
-    const persistence = this.app.offline().persistence;
-    if (this.filter.length > 0 && persistence) {
-      const local = await this.getLocalFilteredSnapshots();
-      if (typeof navigator === "undefined" || !navigator.onLine) {
-        return local;
-      }
-      return this.refreshFromRemote();
-    }
-    if (persistence) {
-      const local = await persistence.getCollectionSnapshots(this.collection);
-      if (typeof navigator === "undefined" || navigator.onLine) {
-        this.refreshFromRemote().catch(() => {
-        });
-      }
-      return local;
-    }
-    return this.refreshFromRemote();
-  }
   async refreshFromRemote() {
     try {
       const genfilter = this.buildFilter();
@@ -724,69 +868,90 @@ var Query = class {
       if (!res?.success || !Array.isArray(res.documents)) {
         return [];
       }
-      return res.documents.map((d) => {
+      const snapshots = res.documents.map((d) => {
         delete d.token;
         d.id = d.id ?? d._id;
         delete d._id;
         return DocumentSnapshot.fromMap(d);
       });
+      const persistence = this.app.offline().persistence;
+      if (!persistence) {
+        return snapshots;
+      }
+      for (const snapshot of snapshots) {
+        await persistence.applyRemoteDoc(this.collection, snapshot.data);
+      }
+      return this.getLocalFilteredSnapshots();
     } catch {
       return [];
     }
   }
-  // Advanced: query-wide update (keep for now, but document it's server-side only)
-  async update(data) {
-    const genfilter = this.buildFilter();
-    const res = await new HttpsRequest({
-      method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/db/update`,
-      headers: { authorization: this.app.getConfig().token, "x-project": this.app.getConfig().project },
-      body: {
-        collection: this.collection,
-        filter: genfilter,
-        data
-      }
-    }).sendRequest();
-    return res;
+  subscribeOnlineSnapshot(callback) {
+    let current = [];
+    this.refreshFromRemote().then((snapshots) => {
+      current = snapshots;
+      callback(current, "initial");
+    }).catch(console.error);
+    return this.app.rtdb().subscribeToCollectionRaw(
+      this.collection,
+      (payload, change) => {
+        const source = change;
+        const incoming = source === "delete" ? DocumentSnapshot.fromMap({ id: payload?.id ?? payload?._id }) : DocumentSnapshot.fromMap(payload);
+        const next = applySnapshotChange(current, incoming, source);
+        current = this.filterDocuments(next);
+        callback(current, source, incoming.id);
+      },
+      this.buildFilter()
+    );
   }
-  onSnapshot(callback) {
-    const genfilter = this.buildFilter();
-    const persistence = this.app.offline().persistence;
-    if (persistence) {
-      const remoteUnsub = this.app.offline().realtimeBridge?.watchCollection(this.collection, genfilter);
-      if (this.filter.length > 0) {
-        const emitFiltered = async (change, changedDocId) => {
-          const docs = await this.getLocalFilteredSnapshots();
-          callback(docs, change, changedDocId);
-        };
-        emitFiltered("insert").catch(console.error);
-        const localUnsub2 = this.localStore?.subscribeToCollection(
-          this.collection,
-          async (snapshots, change, changedDocId) => {
-            if (snapshots.length > 0) {
-              callback(this.filterDocuments(snapshots), change, changedDocId);
-            } else {
-              await emitFiltered(change, changedDocId);
-            }
+  subscribeOnlineChildListener(callbacks) {
+    let current = [];
+    this.refreshFromRemote().then((snapshots) => {
+      current = snapshots;
+      this.emitInitialChildEvents(snapshots, callbacks);
+    }).catch(console.error);
+    return this.app.rtdb().subscribeToCollectionRaw(
+      this.collection,
+      (payload, change) => {
+        const source = change;
+        const incoming = source === "delete" ? DocumentSnapshot.fromMap({ id: payload?.id ?? payload?._id }) : DocumentSnapshot.fromMap(payload);
+        const next = this.filterDocuments(applySnapshotChange(current, incoming, source));
+        const childChanges = diffSnapshots(current, next);
+        current = next;
+        childChanges.forEach((childChange) => {
+          const context = {
+            snapshots: next,
+            source,
+            changedDocId: childChange.doc.id,
+            fromCache: false,
+            oldIndex: childChange.oldIndex,
+            newIndex: childChange.newIndex,
+            previousDoc: childChange.previousDoc
+          };
+          if (childChange.type === "added") {
+            callbacks.onChildAdded?.(childChange.doc, context);
+          } else if (childChange.type === "modified") {
+            callbacks.onChildUpdated?.(childChange.doc, context);
+          } else if (childChange.type === "removed") {
+            callbacks.onChildRemoved?.(childChange.doc, context);
           }
-        ) ?? (() => {
         });
-        return () => {
-          localUnsub2();
-          remoteUnsub?.();
-        };
-      }
-      const localUnsub = this.localStore?.subscribeToCollection(this.collection, callback) ?? (() => {
+      },
+      this.buildFilter()
+    );
+  }
+  emitInitialChildEvents(snapshots, callbacks) {
+    diffSnapshots([], snapshots).forEach((change) => {
+      callbacks.onChildAdded?.(change.doc, {
+        snapshots,
+        source: "initial",
+        changedDocId: change.doc.id,
+        fromCache: true,
+        oldIndex: change.oldIndex,
+        newIndex: change.newIndex,
+        previousDoc: change.previousDoc
       });
-      return () => {
-        localUnsub();
-        remoteUnsub?.();
-      };
-    }
-    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, changes) => {
-      const res = normalizePayload(payload);
-      callback([DocumentSnapshot.fromMap(res?.data)], changes);
-    }, genfilter);
+    });
   }
 };
 
@@ -818,6 +983,89 @@ var CollectionRef = class {
       }
       return local;
     }
+    return this.fetchRemoteSnapshots();
+  }
+  async add(data) {
+    if (this.persistence) {
+      const localId = this.persistence.createLocalId();
+      const docRecord = await this.persistence.upsertDoc({
+        collection: this.collection,
+        id: localId,
+        data: { ...data, id: localId },
+        exists: true,
+        deleted: false,
+        pending: 1,
+        localOnly: true,
+        status: "pending"
+      });
+      await this.persistence.enqueueMutation({
+        mutationId: this.persistence.createMutationId(),
+        collection: this.collection,
+        documentId: localId,
+        type: "insert",
+        payload: docRecord.data
+      });
+      const snap = DocumentSnapshot.fromMap(docRecord.data);
+      this.app.offline().realtimeBridge?.publishLocalChange(this.collection, localId, "insert").catch(console.error);
+      this.syncEngine?.flush().catch(console.error);
+      return snap;
+    }
+    const res = await new HttpsRequest({
+      method: "POST" /* POST */,
+      endpoint: `${this.app.getBaseUrl()}/db/create`,
+      headers: {
+        authorization: this.app.getConfig().token,
+        "x-project": this.app.getConfig().project
+      },
+      body: { collection: this.collection, data: { ...data, id: "" } }
+    }).sendRequest();
+    if (!res?.success || !res.document)
+      return null;
+    return DocumentSnapshot.fromMap(res.document);
+  }
+  onSnapshot(callback) {
+    const realtimeBridge = this.app.offline().realtimeBridge;
+    if (this.persistence && this.localStore && realtimeBridge) {
+      const targetKey = buildTargetKey(this.collection, {});
+      const localUnsub = this.localStore.subscribeToCollection(targetKey, callback);
+      const remoteUnsub = realtimeBridge.watchCollection(
+        this.collection,
+        {},
+        () => this.persistence.getCollectionSnapshots(this.collection)
+      );
+      this.persistence.getCollectionSnapshots(this.collection).then((snapshots) => {
+        realtimeBridge.primeCollectionTarget(this.collection, {}, snapshots);
+        callback(snapshots, "insert");
+      }).catch(console.error);
+      return () => {
+        localUnsub();
+        remoteUnsub();
+      };
+    }
+    return this.subscribeOnlineSnapshot(callback);
+  }
+  onChildListener(callbacks) {
+    const realtimeBridge = this.app.offline().realtimeBridge;
+    if (this.persistence && this.localStore && realtimeBridge) {
+      const targetKey = buildTargetKey(this.collection, {});
+      const localUnsub = this.localStore.subscribeToChildEvents(targetKey, callbacks);
+      const remoteUnsub = realtimeBridge.watchCollection(
+        this.collection,
+        {},
+        () => this.persistence.getCollectionSnapshots(this.collection)
+      );
+      this.persistence.getCollectionSnapshots(this.collection).then((snapshots) => {
+        realtimeBridge.primeCollectionTarget(this.collection, {}, snapshots);
+        this.emitInitialChildEvents(snapshots, callbacks);
+      }).catch(console.error);
+      return () => {
+        localUnsub();
+        remoteUnsub();
+      };
+    }
+    return this.subscribeOnlineChildListener(callbacks);
+  }
+  async refreshFromRemote() {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
@@ -834,18 +1082,25 @@ var CollectionRef = class {
       if (!res?.success || !Array.isArray(res.documents)) {
         return [];
       }
-      return res.documents.map((d) => {
-        delete d.token;
-        d.id = d.id ?? d._id;
-        delete d._id;
-        return DocumentSnapshot.fromMap(d);
+      const normalized = res.documents.map((raw) => {
+        const doc = { ...raw };
+        doc.id = doc.id ?? doc._id;
+        delete doc._id;
+        return doc;
       });
+      if (this.persistence) {
+        await this.persistence.reconcileCollectionFromRemote(this.collection, normalized);
+        const snapshots = await this.persistence.getCollectionSnapshots(this.collection);
+        this.app.offline().realtimeBridge?.primeCollectionTarget(this.collection, {}, snapshots);
+        return snapshots;
+      }
+      return normalized.map((doc) => DocumentSnapshot.fromMap(doc));
     } catch (error) {
-      console.error("[EdmaxLabs] Collection get failed:", error);
+      console.error("[EdmaxLabs] refreshFromRemote failed:", error);
       return [];
     }
   }
-  async refreshFromRemote() {
+  async fetchRemoteSnapshots() {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
@@ -862,17 +1117,6 @@ var CollectionRef = class {
       if (!res?.success || !Array.isArray(res.documents)) {
         return [];
       }
-      for (const raw of res.documents) {
-        const doc = { ...raw };
-        doc.id = doc.id ?? doc._id;
-        delete doc._id;
-        if (this.persistence) {
-          await this.persistence.applyRemoteDoc(this.collection, doc);
-        }
-      }
-      if (this.persistence) {
-        return await this.persistence.getCollectionSnapshots(this.collection);
-      }
       return res.documents.map((d) => {
         delete d.token;
         d.id = d.id ?? d._id;
@@ -880,59 +1124,68 @@ var CollectionRef = class {
         return DocumentSnapshot.fromMap(d);
       });
     } catch (error) {
-      console.error("[EdmaxLabs] refreshFromRemote failed:", error);
+      console.error("[EdmaxLabs] Collection get failed:", error);
       return [];
     }
   }
-  async add(data) {
-    if (this.persistence) {
-      const localId = this.persistence.createLocalId();
-      const docRecord = await this.persistence.upsertDoc({
-        collection: this.collection,
-        id: localId,
-        data: { ...data, id: localId },
-        exists: true,
-        deleted: false,
-        pending: 1,
-        localOnly: true,
-        status: "pending"
-      });
-      await this.persistence.enqueueMutation({
-        mutationId: this.persistence.createMutationId(),
-        collection: this.collection,
-        documentId: localId,
-        type: "insert",
-        payload: docRecord.data
-      });
-      const snap = DocumentSnapshot.fromMap(docRecord.data);
-      this.localStore?.emitDocument(this.collection, localId, snap, "insert");
-      this.localStore?.notifyCollectionChanged(this.collection, localId, "insert");
-      this.syncEngine?.flush().catch(console.error);
-      return snap;
-    }
-    const res = await new HttpsRequest({
-      method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/db/create`,
-      headers: {
-        authorization: this.app.getConfig().token,
-        "x-project": this.app.getConfig().project
-      },
-      body: { collection: this.collection, data: { ...data, id: "" } }
-      // server will generate id
-    }).sendRequest();
-    if (!res?.success || !res.document)
-      return null;
-    return DocumentSnapshot.fromMap(res.document);
+  subscribeOnlineSnapshot(callback) {
+    let current = [];
+    this.fetchRemoteSnapshots().then((snapshots) => {
+      current = snapshots;
+      callback(current, "initial");
+    }).catch(console.error);
+    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, change) => {
+      const source = change;
+      const incoming = source === "delete" ? DocumentSnapshot.fromMap({ id: payload?.id ?? payload?._id }) : DocumentSnapshot.fromMap(payload);
+      current = applySnapshotChange(current, incoming, source);
+      callback(current, source, incoming.id);
+    });
   }
-  onSnapshot(callback) {
-    if (this.persistence && this.localStore && this.app.offline().realtimeBridge) {
-      this.app.offline().realtimeBridge?.watchCollection(this.collection);
-      return this.localStore.subscribeToCollection(this.collection, callback) ?? (() => {
+  subscribeOnlineChildListener(callbacks) {
+    let current = [];
+    this.fetchRemoteSnapshots().then((snapshots) => {
+      current = snapshots;
+      this.emitInitialChildEvents(snapshots, callbacks);
+    }).catch(console.error);
+    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, change) => {
+      const source = change;
+      const incoming = source === "delete" ? DocumentSnapshot.fromMap({ id: payload?.id ?? payload?._id }) : DocumentSnapshot.fromMap(payload);
+      const next = applySnapshotChange(current, incoming, source);
+      const childChanges = diffSnapshots(current, next);
+      current = next;
+      childChanges.forEach((childChange) => {
+        const context = {
+          snapshots: next,
+          source,
+          changedDocId: childChange.doc.id,
+          fromCache: false,
+          oldIndex: childChange.oldIndex,
+          newIndex: childChange.newIndex,
+          previousDoc: childChange.previousDoc
+        };
+        if (childChange.type === "added") {
+          callbacks.onChildAdded?.(childChange.doc, context);
+        } else if (childChange.type === "modified") {
+          callbacks.onChildUpdated?.(childChange.doc, context);
+        } else if (childChange.type === "removed") {
+          callbacks.onChildRemoved?.(childChange.doc, context);
+        }
       });
-    }
-    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, changes) => {
-      const res = normalizePayload(payload);
-      callback([DocumentSnapshot.fromMap(res?.data)], changes);
+    });
+  }
+  emitInitialChildEvents(snapshots, callbacks) {
+    const childChanges = diffSnapshots([], snapshots);
+    childChanges.forEach((change) => {
+      const context = {
+        snapshots,
+        source: "initial",
+        changedDocId: change.doc.id,
+        fromCache: true,
+        oldIndex: change.oldIndex,
+        newIndex: change.newIndex,
+        previousDoc: change.previousDoc
+      };
+      callbacks.onChildAdded?.(change.doc, context);
     });
   }
 };
@@ -982,6 +1235,7 @@ var Batch = class {
     const persistence = this.app.offline().persistence;
     const localStore = this.app.offline().localStore;
     const syncEngine = this.app.offline().syncEngine;
+    const realtimeBridge = this.app.offline().realtimeBridge;
     if (persistence && localStore) {
       const results = [];
       for (const op of this.ops) {
@@ -1010,8 +1264,7 @@ var Batch = class {
               payload: op.data
             });
             const snap = DocumentSnapshot.fromMap(upserted.data);
-            localStore.emitDocument(op.collection, op.id, snap, "insert");
-            localStore.notifyCollectionChanged(op.collection, op.id, "insert");
+            realtimeBridge?.publishLocalChange(op.collection, op.id, "insert").catch(console.error);
             results.push(snap);
           } else if (op.op === "delete") {
             const docRef = new DocumentRef(this.app, op.collection, op.id);
@@ -1111,16 +1364,18 @@ var Database = class {
 // src/database/Realtime.ts
 var import_socket = require("socket.io-client");
 
-// src/utils/uuid.ts
-function generateUUID() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
+// src/utils/documentNomalizer.ts
+function normalizePayload(payload) {
+  const raw = payload?.document ?? payload?.data ?? payload;
+  if (!raw)
+    return null;
+  const doc = { ...raw };
+  doc.id = doc.id ?? raw?.id ?? raw?._id ?? payload?.id ?? payload?._id;
+  delete doc._id;
+  return {
+    change: payload?.change ?? raw?.change ?? null,
+    data: doc
+  };
 }
 
 // src/database/Realtime.ts
@@ -1184,15 +1439,19 @@ var Realtime = class {
    */
   subscribeToCollectionRaw(collection, callback, filter = {}) {
     this.connect();
-    const lid = `col_${collection}_${generateUUID()}`;
+    const lid = collection;
     const handlers = [];
-    this.socket.emit("subscribe", { collection, filter, lid });
+    this.socket.emit("subscribe", { collection, filter });
     this.events.forEach((event) => {
       const channel = `${lid}-${event}`;
       const fn = (payload) => {
         const normalized = normalizePayload(payload);
-        if (!normalized)
+        if (!normalized) {
+          if (event === "delete") {
+            callback(payload, "delete");
+          }
           return;
+        }
         callback(normalized.data, event);
       };
       this.socket.on(channel, fn);
@@ -1206,10 +1465,10 @@ var Realtime = class {
    */
   subscribeToDocumentRaw(collection, id, callback) {
     this.connect();
-    const lid = `doc_${collection}_${id}_${generateUUID()}`;
+    const lid = collection;
     const filter = { _id: id };
     const handlers = [];
-    this.socket.emit("subscribe", { collection, filter, lid });
+    this.socket.emit("subscribe", { collection, filter });
     this.events.forEach((event) => {
       const channel = `${lid}-${event}`;
       const fn = (payload) => {
@@ -1316,11 +1575,11 @@ var LocalStore = class {
   constructor() {
     this.documentListeners = /* @__PURE__ */ new Map();
     this.collectionListeners = /* @__PURE__ */ new Map();
+    this.childListeners = /* @__PURE__ */ new Map();
   }
   docKey(collection, id) {
     return `${collection}:${id}`;
   }
-  // ===================== DOCUMENT LISTENERS =====================
   subscribeToDocument(collection, id, callback) {
     const key = this.docKey(collection, id);
     if (!this.documentListeners.has(key)) {
@@ -1335,24 +1594,33 @@ var LocalStore = class {
       }
     };
   }
-  // ===================== COLLECTION LISTENERS =====================
-  subscribeToCollection(collection, callback) {
-    if (!this.collectionListeners.has(collection)) {
-      this.collectionListeners.set(collection, /* @__PURE__ */ new Set());
+  subscribeToCollection(targetKey, callback) {
+    if (!this.collectionListeners.has(targetKey)) {
+      this.collectionListeners.set(targetKey, /* @__PURE__ */ new Set());
     }
-    const listeners = this.collectionListeners.get(collection);
+    const listeners = this.collectionListeners.get(targetKey);
     listeners.add(callback);
     return () => {
       listeners.delete(callback);
       if (listeners.size === 0) {
-        this.collectionListeners.delete(collection);
+        this.collectionListeners.delete(targetKey);
+        this.childListeners.delete(targetKey);
+      }
+    };
+  }
+  subscribeToChildEvents(targetKey, callbacks) {
+    if (!this.childListeners.has(targetKey)) {
+      this.childListeners.set(targetKey, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.childListeners.get(targetKey);
+    listeners.add(callbacks);
+    return () => {
+      listeners.delete(callbacks);
+      if (listeners.size === 0) {
+        this.childListeners.delete(targetKey);
       }
     };
   }
-  // ===================== EMITTERS =====================
-  /**
-   * Notify all listeners for a specific document
-   */
   emitDocument(collection, id, snapshot, change) {
     const key = this.docKey(collection, id);
     this.documentListeners.get(key)?.forEach((cb) => {
@@ -1363,64 +1631,66 @@ var LocalStore = class {
       }
     });
   }
-  /**
-   * Notify all listeners for a collection.
-   * This is the most important fix — collection listeners now receive the full list.
-   */
-  emitCollection(collection, snapshots, change, changedDocId) {
-    this.collectionListeners.get(collection)?.forEach((cb) => {
+  emitCollection(targetKey, emission) {
+    this.collectionListeners.get(targetKey)?.forEach((cb) => {
       try {
-        cb(snapshots, change, changedDocId);
+        cb(emission.snapshots, emission.source, emission.changedDocId);
       } catch (err) {
-        console.error(`[EdmaxLabs] Error in collection listener for ${collection}:`, err);
+        console.error(`[EdmaxLabs] Error in collection listener for ${targetKey}:`, err);
       }
     });
-  }
-  /**
-   * OPTIMIZED: Notify collection listeners that something changed, without fetching full collection.
-   * Listeners can call getCollectionSnapshots() themselves if they need the full list.
-   * This avoids expensive collection queries after every single mutation.
-   */
-  notifyCollectionChanged(collection, changedDocId, change) {
-    this.collectionListeners.get(collection)?.forEach((cb) => {
-      try {
-        cb([], change, changedDocId);
-      } catch (err) {
-        console.error(`[EdmaxLabs] Error in collection listener for ${collection}:`, err);
-      }
+    const childChanges = emission.childChanges ?? [];
+    if (childChanges.length === 0)
+      return;
+    this.childListeners.get(targetKey)?.forEach((callbacks) => {
+      childChanges.forEach((change) => {
+        this.dispatchChildEvent(callbacks, change, emission);
+      });
     });
   }
-  // ===================== UTILITY =====================
-  /**
-   * Clear all listeners (useful for testing or when persistence is disabled)
-   */
   clearAllListeners() {
     this.documentListeners.clear();
     this.collectionListeners.clear();
+    this.childListeners.clear();
   }
-  /**
-   * Get current listener count (for debugging / dev tools)
-   */
   get listenerCount() {
     let docCount = 0;
     this.documentListeners.forEach((set) => docCount += set.size);
     let collCount = 0;
     this.collectionListeners.forEach((set) => collCount += set.size);
+    this.childListeners.forEach((set) => collCount += set.size);
     return { documents: docCount, collections: collCount };
   }
-  /**
-   * Remove all listeners for a specific collection (useful for cleanup)
-   */
-  removeCollectionListeners(collection) {
-    this.collectionListeners.delete(collection);
+  removeCollectionListeners(targetKey) {
+    this.collectionListeners.delete(targetKey);
+    this.childListeners.delete(targetKey);
   }
-  /**
-   * Remove all listeners for a specific document (useful for cleanup)
-   */
   removeDocumentListeners(collection, id) {
     const key = this.docKey(collection, id);
     this.documentListeners.delete(key);
   }
+  dispatchChildEvent(callbacks, change, emission) {
+    const context = {
+      snapshots: emission.snapshots,
+      source: emission.source,
+      changedDocId: emission.changedDocId,
+      fromCache: emission.fromCache ?? true,
+      oldIndex: change.oldIndex,
+      newIndex: change.newIndex,
+      previousDoc: change.previousDoc
+    };
+    try {
+      if (change.type === "added") {
+        callbacks.onChildAdded?.(change.doc, context);
+      } else if (change.type === "modified") {
+        callbacks.onChildUpdated?.(change.doc, context);
+      } else if (change.type === "removed") {
+        callbacks.onChildRemoved?.(change.doc, context);
+      }
+    } catch (err) {
+      console.error("[EdmaxLabs] Error in child listener:", err);
+    }
+  }
 };
 
 // ../../../../node_modules/idb/build/wrap-idb-value.js
@@ -1791,11 +2061,25 @@ var Persistence = class {
   }
   async getPendingMutations() {
     const app = await this.getDb();
-    const [pending, failed] = await Promise.all([
-      app.getAllFromIndex("mutations", "by-status", "pending"),
-      app.getAllFromIndex("mutations", "by-status", "failed")
-    ]);
-    return [...pending, ...failed].sort((a, b) => a.createdAt - b.createdAt);
+    const pending = await app.getAllFromIndex("mutations", "by-status", "pending");
+    return pending.sort((a, b) => a.createdAt - b.createdAt);
+  }
+  async getFailedMutations() {
+    const app = await this.getDb();
+    const failed = await app.getAllFromIndex("mutations", "by-status", "failed");
+    return failed.sort((a, b) => a.createdAt - b.createdAt);
+  }
+  async recoverSyncingMutations() {
+    const app = await this.getDb();
+    const syncing = await app.getAllFromIndex("mutations", "by-status", "syncing");
+    for (const mutation of syncing) {
+      await app.put("mutations", {
+        ...mutation,
+        status: "pending",
+        updatedAt: this.now()
+      });
+    }
+    return syncing.length;
   }
   async getMutation(mutationId) {
     const app = await this.getDb();
@@ -1900,6 +2184,27 @@ var Persistence = class {
     }
     return this.markDeleted(collection, id, 0);
   }
+  async reconcileCollectionFromRemote(collection, documents) {
+    const app = await this.getDb();
+    const existing = await app.getAllFromIndex("docs", "by-collection", collection);
+    const incomingIds = /* @__PURE__ */ new Set();
+    for (const data of documents) {
+      const id = data.id ?? data._id;
+      if (!id)
+        continue;
+      incomingIds.add(String(id));
+      await this.applyRemoteDoc(collection, { ...data, id: String(id) });
+    }
+    for (const doc of existing) {
+      if (doc.pending && doc.pending > 0)
+        continue;
+      if (!doc.exists || doc.deleted)
+        continue;
+      if (incomingIds.has(doc.id))
+        continue;
+      await this.markDeleted(collection, doc.id, 0);
+    }
+  }
   // ==================== UTILITIES ====================
   createLocalId() {
     return `local_${crypto.randomUUID()}`;
@@ -1929,112 +2234,169 @@ var RealtimeBridge = class {
     this.app = app;
     this.persistence = persistence;
     this.store = store;
-    this.collectionUnsubs = /* @__PURE__ */ new Map();
-    this.documentUnsubs = /* @__PURE__ */ new Map();
+    this.collectionTargets = /* @__PURE__ */ new Map();
+    this.documentTargets = /* @__PURE__ */ new Map();
   }
   docKey(collection, id) {
     return `${collection}:${id}`;
   }
-  // ===================== PUBLIC API =====================
-  watchCollection(collection, filter = {}) {
-    const key = `${collection}:${JSON.stringify(filter)}`;
-    if (this.collectionUnsubs.has(key)) {
-      return this.collectionUnsubs.get(key);
+  watchCollection(collection, filter = {}, read) {
+    const targetKey = buildTargetKey(collection, filter);
+    const existing = this.collectionTargets.get(targetKey);
+    if (existing) {
+      existing.refCount += 1;
+      return () => this.releaseCollection(targetKey);
     }
-    this.emitCurrentCollection(collection);
     const unsub = this.app.rtdb().subscribeToCollectionRaw(
       collection,
       async (payload, change) => {
         if (change === "delete") {
           const id = payload?.id || payload?._id;
-          if (id)
+          if (id) {
             await this.handleRemoteDelete(collection, id);
-        } else {
-          await this.handleRemoteCreateOrUpdate(collection, payload, change);
+          }
+          return;
         }
+        await this.handleRemoteCreateOrUpdate(collection, payload, change);
       },
       filter
     );
-    const fullUnsub = () => {
-      unsub();
-      this.collectionUnsubs.delete(key);
-    };
-    this.collectionUnsubs.set(key, fullUnsub);
-    return fullUnsub;
+    this.collectionTargets.set(targetKey, {
+      targetKey,
+      collection,
+      filter,
+      read,
+      refCount: 1,
+      unsub,
+      lastSnapshots: []
+    });
+    return () => this.releaseCollection(targetKey);
   }
   watchDocument(collection, id) {
     const key = this.docKey(collection, id);
-    if (this.documentUnsubs.has(key)) {
-      return this.documentUnsubs.get(key);
+    const existing = this.documentTargets.get(key);
+    if (existing) {
+      existing.refCount += 1;
+      return () => this.releaseDocument(key);
     }
-    this.emitCurrentDocument(collection, id);
     const unsub = this.app.rtdb().subscribeToDocumentRaw(
       collection,
       id,
       async (payload, change) => {
         if (change === "delete") {
           await this.handleRemoteDelete(collection, id);
-        } else {
-          await this.handleRemoteCreateOrUpdate(collection, payload, change);
+          return;
         }
+        await this.handleRemoteCreateOrUpdate(collection, payload, change);
       }
     );
-    const fullUnsub = () => {
-      unsub();
-      this.documentUnsubs.delete(key);
-    };
-    this.documentUnsubs.set(key, fullUnsub);
-    return fullUnsub;
+    this.documentTargets.set(key, {
+      key,
+      collection,
+      id,
+      refCount: 1,
+      unsub
+    });
+    return () => this.releaseDocument(key);
+  }
+  async emitCurrentCollection(collection, filter = {}) {
+    const targetKey = buildTargetKey(collection, filter);
+    const target = this.collectionTargets.get(targetKey);
+    if (!target)
+      return [];
+    return this.refreshCollectionTarget(target, "initial");
+  }
+  primeCollectionTarget(collection, filter, snapshots) {
+    const targetKey = buildTargetKey(collection, filter);
+    const target = this.collectionTargets.get(targetKey);
+    if (!target)
+      return;
+    target.lastSnapshots = snapshots;
   }
-  // ===================== INTERNAL HANDLERS =====================
   async emitCurrentDocument(collection, id) {
-    const localDoc = await this.persistence.getDoc(collection, id);
-    const snapshot = localDoc && localDoc.exists && !localDoc.deleted ? DocumentSnapshot.fromMap(localDoc.data) : null;
-    this.store.emitDocument(collection, id, snapshot, "insert");
+    const snapshot = await this.getCurrentDocumentSnapshot(collection, id);
+    this.store.emitDocument(collection, id, snapshot, "initial");
+    return snapshot;
   }
-  async emitCurrentCollection(collection) {
-    const localDocs = await this.persistence.getCollectionSnapshots(collection);
-    this.store.emitCollection(collection, localDocs, "insert");
+  async publishLocalChange(collection, id, source) {
+    const snapshot = await this.getCurrentDocumentSnapshot(collection, id);
+    this.store.emitDocument(collection, id, snapshot, source);
+    await this.refreshCollectionTargets(collection, source, id);
+  }
+  async onReconnect() {
+    for (const target of this.collectionTargets.values()) {
+      await this.refreshCollectionTarget(target, "initial");
+    }
+    for (const target of this.documentTargets.values()) {
+      await this.emitCurrentDocument(target.collection, target.id);
+    }
+  }
+  dispose() {
+    this.collectionTargets.forEach((target) => target.unsub());
+    this.documentTargets.forEach((target) => target.unsub());
+    this.collectionTargets.clear();
+    this.documentTargets.clear();
   }
-  async handleRemoteCreateOrUpdate(collection, raw, change) {
+  async handleRemoteCreateOrUpdate(collection, raw, source) {
     const id = raw.id ?? raw._id;
     if (!id)
       return;
     const saved = await this.persistence.applyRemoteDoc(collection, raw);
-    if (!saved)
-      return;
-    const snap = DocumentSnapshot.fromMap(saved.data);
-    this.store.emitDocument(collection, id, snap, change);
-    this.store.notifyCollectionChanged(collection, id, change);
+    if (saved) {
+      const snap = DocumentSnapshot.fromMap(saved.data);
+      this.store.emitDocument(collection, id, snap, source);
+    }
+    await this.refreshCollectionTargets(collection, source, id, false);
   }
   async handleRemoteDelete(collection, id) {
     await this.persistence.applyRemoteDelete(collection, id);
     this.store.emitDocument(collection, id, null, "delete");
-    this.store.notifyCollectionChanged(collection, id, "delete");
+    await this.refreshCollectionTargets(collection, "delete", id, false);
   }
-  // ===================== LIFECYCLE =====================
-  /**
-   * Call this when Socket.IO reconnects or when going online
-   * Replays pending mutations + refreshes all active subscriptions from cache
-   */
-  async onReconnect() {
-    for (const [key] of this.collectionUnsubs) {
-      const collection = key.split(":")[0];
-      await this.emitCurrentCollection(collection);
-    }
-    for (const [key] of this.documentUnsubs) {
-      const [collection, id] = key.split(":");
-      await this.emitCurrentDocument(collection, id);
-    }
+  async getCurrentDocumentSnapshot(collection, id) {
+    const localDoc = await this.persistence.getDoc(collection, id);
+    return localDoc && localDoc.exists && !localDoc.deleted ? DocumentSnapshot.fromMap(localDoc.data) : null;
   }
-  /**
-   * Clean up all subscriptions (call from EdmaxLabs destructor if needed)
-   */
-  dispose() {
-    this.collectionUnsubs.forEach((unsub) => unsub());
-    this.documentUnsubs.forEach((unsub) => unsub());
-    this.collectionUnsubs.clear();
-    this.documentUnsubs.clear();
+  async refreshCollectionTargets(collection, source, changedDocId, fromCache = true) {
+    const targets = Array.from(this.collectionTargets.values()).filter(
+      (target) => target.collection === collection
+    );
+    for (const target of targets) {
+      await this.refreshCollectionTarget(target, source, changedDocId, fromCache);
+    }
+  }
+  async refreshCollectionTarget(target, source, changedDocId, fromCache = true) {
+    const snapshots = await target.read();
+    const childChanges = diffSnapshots(target.lastSnapshots, snapshots);
+    target.lastSnapshots = snapshots;
+    this.store.emitCollection(target.targetKey, {
+      snapshots,
+      source,
+      changedDocId,
+      fromCache,
+      childChanges
+    });
+    return snapshots;
+  }
+  releaseCollection(targetKey) {
+    const target = this.collectionTargets.get(targetKey);
+    if (!target)
+      return;
+    target.refCount -= 1;
+    if (target.refCount > 0)
+      return;
+    target.unsub();
+    this.collectionTargets.delete(targetKey);
+  }
+  releaseDocument(key) {
+    const target = this.documentTargets.get(key);
+    if (!target)
+      return;
+    target.refCount -= 1;
+    if (target.refCount > 0)
+      return;
+    target.unsub();
+    this.documentTargets.delete(key);
   }
 };
 
@@ -2046,16 +2408,19 @@ var SyncEngine = class {
     this.retryTimeout = null;
     this.MAX_RETRIES = 5;
     this.BASE_RETRY_DELAY = 2e3;
+    this.handleOnline = () => this.onNetworkOnline();
+    this.handleVisibilityChange = () => {
+      if (document.visibilityState === "visible")
+        this.onNetworkOnline();
+    };
     this.app = app;
     this.persistence = persistence;
     this.store = store;
     this.realtimeBridge = realtimeBridge || null;
+    this.persistence.recoverSyncingMutations().catch(console.error);
     if (typeof window !== "undefined") {
-      window.addEventListener("online", () => this.onNetworkOnline());
-      document.addEventListener("visibilitychange", () => {
-        if (document.visibilityState === "visible")
-          this.onNetworkOnline();
-      });
+      window.addEventListener("online", this.handleOnline);
+      document.addEventListener("visibilitychange", this.handleVisibilityChange);
     }
   }
   onNetworkOnline() {
@@ -2072,6 +2437,7 @@ var SyncEngine = class {
       return;
     this.syncing = true;
     try {
+      await this.persistence.recoverSyncingMutations();
       const pending = await this.persistence.getPendingMutations();
       for (const mutation of pending) {
         if (mutation.retryCount >= this.MAX_RETRIES) {
@@ -2148,8 +2514,7 @@ var SyncEngine = class {
     if (replaced) {
       const snap = DocumentSnapshot.fromMap(replaced.data);
       this.store.emitDocument(mutation.collection, oldId, snap, "insert");
-      this.store.emitDocument(mutation.collection, newId, snap, "insert");
-      this.store.notifyCollectionChanged(mutation.collection, newId, "insert");
+      await this.realtimeBridge?.publishLocalChange(mutation.collection, newId, "insert");
     }
     return true;
   }
@@ -2182,7 +2547,7 @@ var SyncEngine = class {
     });
     const snap = DocumentSnapshot.fromMap(local.data);
     this.store.emitDocument(mutation.collection, mutation.documentId, snap, "update");
-    this.store.notifyCollectionChanged(mutation.collection, mutation.documentId, "update");
+    await this.realtimeBridge?.publishLocalChange(mutation.collection, mutation.documentId, "update");
     return true;
   }
   async syncDelete(mutation) {
@@ -2199,7 +2564,7 @@ var SyncEngine = class {
       return false;
     await this.persistence.markDeleted(mutation.collection, mutation.documentId, 0);
     this.store.emitDocument(mutation.collection, mutation.documentId, null, "delete");
-    this.store.notifyCollectionChanged(mutation.collection, mutation.documentId, "delete");
+    await this.realtimeBridge?.publishLocalChange(mutation.collection, mutation.documentId, "delete");
     return true;
   }
   scheduleRetry() {
@@ -2219,8 +2584,7 @@ var SyncEngine = class {
    * Returns mutations that exceeded MAX_RETRIES
    */
   async getFailedMutations() {
-    const all = await this.persistence.getPendingMutations();
-    return all.filter((m) => m.status === "failed");
+    return this.persistence.getFailedMutations();
   }
   /**
    * Retry a specific failed mutation by resetting its retry count
@@ -2262,6 +2626,10 @@ var SyncEngine = class {
     if (this.retryTimeout) {
       clearTimeout(this.retryTimeout);
     }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this.handleOnline);
+      document.removeEventListener("visibilitychange", this.handleVisibilityChange);
+    }
   }
 };