edmaxlabs-core 1.3.5 → 1.3.7

package/dist/index.mjs

@@ -52,29 +52,45 @@ var HttpsRequest = class {
     this.isMultipart = isMultipart;
   }
   async sendRequest() {
-    if (this.isMultipart && this.file) {
-      const formData = new FormData();
-      Object.entries(this.body).forEach(([key, value]) => {
-        formData.append(key, value);
-      });
-      formData.append("file", this.file);
-      const response = await fetch(this.endpoint, {
-        method: this.method,
-        headers: this.headers,
-        // Let browser handle multipart boundaries
-        body: formData
-      });
-      return await response.json();
-    } else {
+    try {
+      if (this.isMultipart && this.file) {
+        const formData = new FormData();
+        Object.entries(this.body).forEach(([key, value]) => {
+          formData.append(key, value);
+        });
+        formData.append("file", this.file);
+        const response2 = await fetch(this.endpoint, {
+          method: this.method,
+          headers: this.headers,
+          body: formData
+        });
+        if (!response2.ok) {
+          const errorText = await response2.text().catch(() => "Network error");
+          throw new Error(`HTTP ${response2.status}: ${errorText}`);
+        }
+        return await response2.json().catch(() => ({}));
+      }
       const response = await fetch(this.endpoint, {
         method: this.method,
         headers: {
-          ...this.headers,
-          "Content-Type": "application/json"
+          "Content-Type": "application/json",
+          ...this.headers
         },
-        body: JSON.stringify(this.body)
+        body: this.method !== "GET" /* GET */ ? JSON.stringify(this.body) : void 0
       });
-      return await response.json();
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Network error");
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
+      }
+      return await response.json().catch(() => ({}));
+    } catch (error) {
+      if (error.name === "TypeError" && error.message.includes("fetch")) {
+        throw new Error("Network connection failed. Please check your internet connection.");
+      }
+      if (error.name === "AbortError") {
+        throw new Error("Request was cancelled.");
+      }
+      throw error;
     }
   }
 };
@@ -179,7 +195,8 @@ var _Authentication = class _Authentication {
         method: "POST" /* POST */,
         endpoint: this.client.getBaseUrl() + "/auth/rules/verify",
         headers: {
-          authorization: this.client.getConfig().token
+          authorization: this.client.getConfig().token,
+          project: this.client.getConfig().project
         },
         body: {
           path,
@@ -521,8 +538,8 @@ var Array2 = class {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/app/array/show`,
-        headers: { authorization: this.app.getConfig().token },
+        endpoint: `${this.app.getBaseUrl()}/db/array/show`,
+        headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: {
           collection: this.collection,
           document: this.docID,
@@ -574,15 +591,15 @@ var Array2 = class {
           this.collection,
           this.docID,
           DocumentSnapshot.fromMap({ ...doc.data, [this.key]: updatedArray }),
-          "local_update"
+          "update"
         );
       }
       return ArraySnapshot.fromMap(payload);
     }
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/array/push`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/array/push`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: this.collection,
         document: this.docID,
@@ -608,8 +625,8 @@ var Array2 = class {
     }
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/array/update`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/array/update`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: this.collection,
         document: this.docID,
@@ -633,7 +650,47 @@ var Array2 = class {
   }
 };
 
+// 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) {
+    throw new Error(`${operation}: data cannot be null or undefined`);
+  }
+  if (typeof data !== "object") {
+    throw new Error(`${operation}: data must be an object`);
+  }
+  if (data instanceof Array2) {
+    throw new Error(`${operation}: data cannot be an array`);
+  }
+  const reservedFields = ["id", "_id", "_createdAt", "_updatedAt", "_deleted"];
+  for (const field of reservedFields) {
+    if (field in data) {
+      throw new Error(`${operation}: '${field}' is a reserved field and cannot be set manually`);
+    }
+  }
+  const dataSize = JSON.stringify(data).length;
+  if (dataSize > 1024 * 1024) {
+    throw new Error(`${operation}: document size (${Math.round(dataSize / 1024)}KB) exceeds maximum allowed size (1MB)`);
+  }
+  try {
+    JSON.stringify(data);
+  } catch {
+    throw new Error(`${operation}: data contains circular references`);
+  }
+}
 var DocumentRef = class {
   constructor(app, collection, id) {
     this.app = app;
@@ -645,50 +702,24 @@ var DocumentRef = class {
   }
   async get() {
     if (this.persistence) {
-      const localSnap = await this.persistence.getDocSnapshot(this.collection, this.id);
-      if (localSnap)
-        return localSnap;
-    }
-    if (typeof navigator === "undefined" || navigator.onLine) {
-      this.refreshFromRemote().catch(() => {
-      });
-    }
-    return null;
-  }
-  async refreshFromRemote() {
-    try {
-      const res = await new HttpsRequest({
-        method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/app/read`,
-        headers: { authorization: this.app.getConfig().token },
-        body: {
-          collection: this.collection,
-          document: this.id
-        }
-      }).sendRequest();
-      if (!res?.success || !res.document)
+      try {
+        const localSnap = await this.persistence.getDocSnapshot(this.collection, this.id);
+        if (localSnap)
+          return localSnap;
         return null;
-      const doc = {
-        ...res.document,
-        id: res.document.id ?? res.document._id ?? this.id
-      };
-      delete doc._id;
-      if (this.persistence) {
-        await this.persistence.applyRemoteDoc(this.collection, doc);
+      } catch (error) {
+        console.error("[EdmaxLabs] Error reading from cache:", error);
       }
-      const snap = DocumentSnapshot.fromMap(doc);
-      this.localStore?.emitDocument(this.collection, this.id, snap, "remote_update");
-      return snap;
-    } catch {
-      return null;
     }
+    return await this.app.getDatabase.collection(this.collection).doc(this.id).get();
   }
   async set(data) {
+    validateDocumentData(data, "DocumentRef.set");
     if (!this.persistence) {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/app/create`,
-        headers: { authorization: this.app.getConfig().token },
+        endpoint: `${this.app.getBaseUrl()}/db/create`,
+        headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: { collection: this.collection, data: { ...data, id: this.id } }
       }).sendRequest();
       return res?.success ? DocumentSnapshot.fromMap(data) : null;
@@ -707,78 +738,85 @@ var DocumentRef = class {
       mutationId: this.persistence.createMutationId(),
       collection: this.collection,
       documentId: this.id,
-      type: "update",
+      type: "insert",
       // or "create" if you want to distinguish truly new docs
       payload: data
     });
     const snap = DocumentSnapshot.fromMap(updated.data);
-    this.localStore?.emitDocument(this.collection, this.id, snap, "local_update");
+    this.localStore?.emitDocument(this.collection, this.id, snap, "update");
     const currentCollection = await this.persistence.getCollectionSnapshots(this.collection);
-    this.localStore?.emitCollection(this.collection, currentCollection, "local_update", this.id);
+    this.localStore?.emitCollection(this.collection, currentCollection, "update", this.id);
     this.syncEngine?.flush().catch(console.error);
     return snap;
   }
   async update(data) {
-    if (!this.persistence)
-      return null;
-    const old = await this.persistence.getDoc(this.collection, this.id);
-    if (!old || old.deleted)
-      return null;
-    const mergedData = { ...old.data, ...data, id: this.id };
-    const updated = await this.persistence.upsertDoc({
-      collection: this.collection,
-      id: this.id,
-      data: mergedData,
-      exists: true,
-      deleted: false,
-      pending: 1,
-      localOnly: old.localOnly,
-      status: "pending",
-      revision: old.revision,
-      lastSyncedAt: old.lastSyncedAt
-    });
-    await this.persistence.enqueueMutation({
-      mutationId: this.persistence.createMutationId(),
-      collection: this.collection,
-      documentId: this.id,
-      type: "update",
-      payload: data,
-      baseRevision: old.revision
-    });
-    const snap = DocumentSnapshot.fromMap(updated.data);
-    this.localStore?.emitDocument(this.collection, this.id, snap, "local_update");
-    const currentCollection = await this.persistence.getCollectionSnapshots(this.collection);
-    this.localStore?.emitCollection(this.collection, currentCollection, "local_update", this.id);
-    this.syncEngine?.flush().catch(console.error);
-    return snap;
+    validateDocumentData(data, "DocumentRef.update");
+    if (this.persistence) {
+      const old = await this.persistence.getDoc(this.collection, this.id);
+      if (!old || old.deleted)
+        return null;
+      const mergedData = { ...old.data, ...data, id: this.id };
+      const updated = await this.persistence.upsertDoc({
+        collection: this.collection,
+        id: this.id,
+        data: mergedData,
+        exists: true,
+        deleted: false,
+        pending: 1,
+        localOnly: old.localOnly,
+        status: "pending",
+        revision: old.revision,
+        lastSyncedAt: old.lastSyncedAt
+      });
+      await this.persistence.enqueueMutation({
+        mutationId: this.persistence.createMutationId(),
+        collection: this.collection,
+        documentId: this.id,
+        type: "update",
+        payload: data,
+        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.syncEngine?.flush().catch(console.error);
+      return snap;
+    }
+    return await this.app.getDatabase.collection(this.collection).doc(this.id).update(data);
   }
   async delete() {
-    if (!this.persistence)
-      return false;
-    await this.persistence.markDeleted(this.collection, this.id, 1);
-    await this.persistence.enqueueMutation({
-      mutationId: this.persistence.createMutationId(),
-      collection: this.collection,
-      documentId: this.id,
-      type: "delete",
-      payload: null
-    });
-    this.localStore?.emitDocument(this.collection, this.id, null, "local_delete");
-    const currentCollection = await this.persistence.getCollectionSnapshots(this.collection);
-    this.localStore?.emitCollection(this.collection, currentCollection, "local_delete", this.id);
-    this.syncEngine?.flush().catch(console.error);
-    return true;
-  }
-  array(key) {
-    return new Array2(this.app, this.collection, key, this.id);
+    if (this.persistence) {
+      await this.persistence.markDeleted(this.collection, this.id, 1);
+      await this.persistence.enqueueMutation({
+        mutationId: this.persistence.createMutationId(),
+        collection: this.collection,
+        documentId: this.id,
+        type: "delete",
+        payload: null
+      });
+      this.localStore?.emitDocument(this.collection, this.id, null, "empty");
+      this.localStore?.notifyCollectionChanged(this.collection, this.id, "delete");
+      this.syncEngine?.flush().catch(console.error);
+      return true;
+    }
+    return await this.app.getDatabase.collection(this.collection).doc(this.id).delete();
   }
+  // array(key: string): Array {
+  //   return new Array(this.app, this.collection, key, this.id);
+  // }
   onSnapshot(callback) {
-    this.app.offline().realtimeBridge?.watchDocument(this.collection, this.id);
-    return this.localStore?.subscribeToDocument(
-      this.collection,
-      this.id,
-      callback
-    ) ?? (() => {
+    if (this.app.offline().persistence && this.app.offline().localStore && this.app.offline().realtimeBridge) {
+      this.app.offline().realtimeBridge?.watchDocument(this.collection, this.id);
+      return this.app.offline().localStore?.subscribeToDocument(
+        this.collection,
+        this.id,
+        callback
+      ) || (() => {
+      });
+    }
+    return this.app.rtdb().subscribeToDocumentRaw(this.collection, this.id, (snapshot, change) => {
+      const res = normalizePayload(snapshot);
+      callback(DocumentSnapshot.fromMap(res?.data), change);
     });
   }
 };
@@ -789,6 +827,7 @@ var Query = class {
     this.filter = [];
     this.app = app;
     this.collection = collection;
+    this.localStore = app.offline().localStore;
   }
   where(expression) {
     this.filter.push(expression);
@@ -832,8 +871,59 @@ var Query = class {
     });
     return mongoFilter;
   }
+  matchesFilter(document2, { key, op, value }) {
+    const fieldValue = document2[key];
+    switch (op) {
+      case "==":
+      case "===":
+        return fieldValue === value;
+      case "!=":
+        return fieldValue !== value;
+      case "<":
+        return fieldValue < value;
+      case "<=":
+        return fieldValue <= value;
+      case ">":
+        return fieldValue > value;
+      case ">=":
+        return fieldValue >= value;
+      case "in":
+        return Array.isArray(value) && value.includes(fieldValue);
+      case "nin":
+        return Array.isArray(value) && !value.includes(fieldValue);
+      case "contains":
+        if (fieldValue == null)
+          return false;
+        return String(fieldValue).toLowerCase().includes(String(value).toLowerCase());
+      default:
+        return false;
+    }
+  }
+  filterDocuments(docs) {
+    if (this.filter.length === 0)
+      return docs;
+    return docs.filter(
+      (snapshot) => this.filter.every(
+        (expression) => this.matchesFilter(snapshot.data, expression)
+      )
+    );
+  }
+  async getLocalFilteredSnapshots() {
+    const persistence = this.app.offline().persistence;
+    if (!persistence)
+      return [];
+    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) {
@@ -849,8 +939,8 @@ var Query = class {
       const genfilter = this.buildFilter();
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/app/read`,
-        headers: { authorization: this.app.getConfig().token },
+        endpoint: `${this.app.getBaseUrl()}/db/read`,
+        headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: {
           collection: this.collection,
           filter: genfilter
@@ -874,8 +964,8 @@ var Query = class {
     const genfilter = this.buildFilter();
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/update`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/update`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: this.collection,
         filter: genfilter,
@@ -886,17 +976,42 @@ var Query = class {
   }
   onSnapshot(callback) {
     const genfilter = this.buildFilter();
-    this.app.rtdb().subscribeToCollectionRaw?.(
-      this.collection,
-      (payload, change) => {
-      },
-      genfilter
-    );
-    return this.app.offline().localStore?.subscribeToCollection(
-      this.collection,
-      callback
-    ) ?? (() => {
-    });
+    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);
+            }
+          }
+        ) ?? (() => {
+        });
+        return () => {
+          localUnsub2();
+          remoteUnsub?.();
+        };
+      }
+      const localUnsub = this.localStore?.subscribeToCollection(this.collection, callback) ?? (() => {
+      });
+      return () => {
+        localUnsub();
+        remoteUnsub?.();
+      };
+    }
+    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, changes) => {
+      const res = normalizePayload(payload);
+      callback([DocumentSnapshot.fromMap(res?.data)], changes);
+    }, genfilter);
   }
 };
 
@@ -916,20 +1031,22 @@ var CollectionRef = class {
     return new Query(this.app, this.collection);
   }
   async get() {
-    if (!this.persistence)
-      return [];
-    const local = await this.persistence.getCollectionSnapshots(this.collection);
-    if (typeof navigator === "undefined" || navigator.onLine) {
-      this.refreshFromRemote().catch(() => {
-      });
+    if (this.persistence) {
+      const local = await this.persistence.getCollectionSnapshots(this.collection);
+      if (typeof navigator === "undefined" || navigator.onLine) {
+        this.refreshFromRemote().catch(() => {
+        });
+      }
+      return local;
     }
-    return local;
+    ;
+    return await this.app.getDatabase.collection(this.collection).get();
   }
   async refreshFromRemote() {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: `${this.app.getBaseUrl()}/app/read`,
+        endpoint: `${this.app.getBaseUrl()}/db/read`,
         headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: {
           collection: this.collection,
@@ -943,52 +1060,61 @@ var CollectionRef = class {
         const doc = { ...raw };
         doc.id = doc.id ?? doc._id;
         delete doc._id;
-        delete doc.token;
         if (this.persistence) {
           await this.persistence.applyRemoteDoc(this.collection, doc);
         }
       }
       if (this.persistence) {
-        const updatedCollection = await this.persistence.getCollectionSnapshots(this.collection);
-        this.localStore?.emitCollection(this.collection, updatedCollection, "remote_update");
-        return updatedCollection;
+        return await this.persistence.getCollectionSnapshots(this.collection);
       }
-      return [];
+      return res.documents.map((d) => {
+        delete d.token;
+        d.id = d.id ?? d._id;
+        delete d._id;
+        return DocumentSnapshot.fromMap(d);
+      });
     } catch {
       return [];
     }
   }
   async add(data) {
-    if (!this.persistence)
-      return null;
-    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: "create",
-      payload: docRecord.data
-    });
-    const snap = DocumentSnapshot.fromMap(docRecord.data);
-    this.localStore?.emitDocument(this.collection, localId, snap, "local_create");
-    const currentCollection = await this.persistence.getCollectionSnapshots(this.collection);
-    this.localStore?.emitCollection(this.collection, currentCollection, "local_create", localId);
-    this.syncEngine?.flush().catch(console.error);
-    return snap;
+    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;
+    }
+    ;
+    return await this.app.getDatabase.collection(this.collection).add(data);
   }
   onSnapshot(callback) {
-    this.app.offline().realtimeBridge?.watchCollection(this.collection);
-    return this.localStore?.subscribeToCollection(this.collection, callback) ?? (() => {
+    if (this.app.offline().persistence) {
+      this.app.offline().realtimeBridge?.watchCollection(this.collection);
+      return this.app.offline().localStore?.subscribeToCollection(this.collection, callback) ?? (() => {
+      });
+    }
+    return this.app.rtdb().subscribeToCollectionRaw(this.collection, (payload, changes) => {
+      const res = normalizePayload(payload);
+      callback([DocumentSnapshot.fromMap(res?.data)], changes);
     });
   }
 };
@@ -1008,6 +1134,15 @@ var Batch = class {
     });
     return this;
   }
+  create(docRef, data) {
+    this.ops.push({
+      op: "create",
+      collection: docRef.collection,
+      id: docRef.id,
+      data
+    });
+    return this;
+  }
   update(docRef, data) {
     this.ops.push({
       op: "update",
@@ -1033,11 +1168,33 @@ var Batch = class {
       const results = [];
       for (const op of this.ops) {
         try {
-          if (op.op === "set" || op.op === "update") {
+          if (op.op === "update") {
             const docRef = new DocumentRef(this.app, op.collection, op.id);
-            const snap = await docRef.set(op.data);
+            const snap = await docRef.update(op.data);
             if (snap)
               results.push(snap);
+          } else if (op.op === "create" || op.op === "insert" || op.op === "set") {
+            const upserted = await persistence.upsertDoc({
+              collection: op.collection,
+              id: op.id,
+              data: { ...op.data, id: op.id },
+              exists: true,
+              deleted: false,
+              pending: 1,
+              localOnly: false,
+              status: "pending"
+            });
+            await persistence.enqueueMutation({
+              mutationId: persistence.createMutationId(),
+              collection: op.collection,
+              documentId: op.id,
+              type: "insert",
+              payload: op.data
+            });
+            const snap = DocumentSnapshot.fromMap(upserted.data);
+            localStore.emitDocument(op.collection, op.id, snap, "insert");
+            localStore.notifyCollectionChanged(op.collection, op.id, "insert");
+            results.push(snap);
           } else if (op.op === "delete") {
             const docRef = new DocumentRef(this.app, op.collection, op.id);
             await docRef.delete();
@@ -1051,10 +1208,8 @@ var Batch = class {
     }
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl}/app/batch`,
-      headers: {
-        authorization: this.app.getConfig().token
-      },
+      endpoint: `${this.app.getBaseUrl()}/db/batch`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: { ops: this.ops }
     }).sendRequest();
     if (res?.error) {
@@ -1105,10 +1260,8 @@ var Database = class {
     await transactionFn(tx);
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl}/app/transaction`,
-      headers: {
-        authorization: this.app.getConfig().token
-      },
+      endpoint: `${this.app.getBaseUrl()}/db/transaction`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: { ops: tx.ops }
     }).sendRequest();
     if (res?.error) {
@@ -1219,10 +1372,10 @@ var Realtime = class {
     this.events.forEach((event) => {
       const channel = `${lid}-${event}`;
       const fn = (payload) => {
-        const normalized = this.normalizePayload(payload);
+        const normalized = normalizePayload(payload);
         if (!normalized)
           return;
-        callback(normalized.data, normalized.change ?? event);
+        callback(normalized.data, event);
       };
       this.socket.on(channel, fn);
       handlers.push({ event: channel, fn });
@@ -1242,7 +1395,7 @@ var Realtime = class {
     this.events.forEach((event) => {
       const channel = `${lid}-${event}`;
       const fn = (payload) => {
-        const normalized = this.normalizePayload(payload);
+        const normalized = normalizePayload(payload);
         if (!normalized) {
           callback({ id }, "delete");
           return;
@@ -1256,18 +1409,6 @@ var Realtime = class {
     return () => this.cleanupSubscription(lid);
   }
   // ===================== PRIVATE HELPERS =====================
-  normalizePayload(payload) {
-    const raw = payload?.document ?? payload?.data ?? payload;
-    if (!raw)
-      return null;
-    const doc = { ...raw };
-    doc.id = doc.id ?? doc._id;
-    delete doc._id;
-    return {
-      change: payload?.change ?? raw?.change ?? null,
-      data: doc
-    };
-  }
   registerSubscription(lid, collection, filter, handlers) {
     this.subscriptions.set(lid, { lid, collection, filter, handlers });
   }
@@ -1312,10 +1453,8 @@ var Functions = class {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: this.app.getBaseUrl + "/functions/call/" + functionName,
-        headers: {
-          authorization: this.app.getConfig().token
-        },
+        endpoint: this.app.getBaseUrl() + "/functions/call/" + functionName,
+        headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: data
       }).sendRequest();
       return res;
@@ -1337,10 +1476,8 @@ var Hosting = class {
     try {
       const res = await new HttpsRequest({
         method: "POST" /* POST */,
-        endpoint: this.app.getBaseUrl + "/hosting/register",
-        headers: {
-          authorization: this.app.getConfig().token
-        },
+        endpoint: this.app.getBaseUrl() + "/hosting/register",
+        headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
         body: {
           hostname: name,
           project: this.app.getConfig().project
@@ -1421,6 +1558,20 @@ var LocalStore = class {
       }
     });
   }
+  /**
+   * 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);
+      }
+    });
+  }
   // ===================== UTILITY =====================
   /**
    * Clear all listeners (useful for testing or when persistence is disabled)
@@ -1439,6 +1590,19 @@ var LocalStore = class {
     this.collectionListeners.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);
+  }
+  /**
+   * Remove all listeners for a specific document (useful for cleanup)
+   */
+  removeDocumentListeners(collection, id) {
+    const key = this.docKey(collection, id);
+    this.documentListeners.delete(key);
+  }
 };
 
 // ../../../../node_modules/idb/build/wrap-idb-value.js
@@ -1650,8 +1814,9 @@ replaceTraps((oldTraps) => ({
 
 // src/persistence/Persistence.ts
 var Persistence = class {
-  constructor() {
-    this.dbPromise = openDB("edmaxlabs_offline", 1, {
+  constructor(appName = "default") {
+    this.appName = appName;
+    this.dbPromise = openDB(`edmaxlabs_offline_${appName}`, 1, {
       upgrade(app, oldVersion) {
         if (oldVersion < 1) {
           if (!app.objectStoreNames.contains("docs")) {
@@ -1674,17 +1839,74 @@ var Persistence = class {
             app.createObjectStore("meta");
           }
         }
+      },
+      blocked() {
+        console.warn("[EdmaxLabs] IndexedDB blocked - another tab has the database open");
+      },
+      blocking() {
+        console.warn("[EdmaxLabs] IndexedDB blocking - closing to allow upgrade");
+      },
+      terminated() {
+        console.error("[EdmaxLabs] IndexedDB terminated unexpectedly");
+      }
+    }).catch((error) => {
+      if (error.name === "QuotaExceededError") {
+        console.error("[EdmaxLabs] IndexedDB quota exceeded - storage full");
+        throw new Error("Storage quota exceeded. Please clear browser data or free up space.");
       }
+      if (error.name === "VersionError") {
+        console.error("[EdmaxLabs] IndexedDB version conflict - clearing and retrying");
+        indexedDB.deleteDatabase(`edmaxlabs_offline_${appName}`);
+        throw error;
+      }
+      throw error;
     });
   }
   docKey(collection, id) {
-    return `${collection}:${id}`;
+    return `${this.appName}:${collection}:${id}`;
   }
   now() {
     return Date.now();
   }
   async getDb() {
-    return this.dbPromise;
+    try {
+      return await this.dbPromise;
+    } catch (error) {
+      if (error.name === "QuotaExceededError") {
+        throw new Error("Storage quota exceeded. Please clear browser data or free up space.");
+      }
+      if (error.name === "VersionError") {
+        console.warn("[EdmaxLabs] IndexedDB version error - attempting recovery");
+        indexedDB.deleteDatabase(`edmaxlabs_offline_${this.appName}`);
+        this.dbPromise = openDB(`edmaxlabs_offline_${this.appName}`, 1, {
+          upgrade(app, oldVersion) {
+            if (oldVersion < 1) {
+              if (!app.objectStoreNames.contains("docs")) {
+                const docs = app.createObjectStore("docs", { keyPath: "key" });
+                docs.createIndex("by-collection", "collection");
+                docs.createIndex("by-id", "id");
+                docs.createIndex("by-updatedAt", "updatedAt");
+                docs.createIndex("by-pending", "pending");
+              }
+              if (!app.objectStoreNames.contains("mutations")) {
+                const mutations = app.createObjectStore("mutations", {
+                  keyPath: "mutationId"
+                });
+                mutations.createIndex("by-status", "status");
+                mutations.createIndex("by-collection", "collection");
+                mutations.createIndex("by-documentId", "documentId");
+                mutations.createIndex("by-createdAt", "createdAt");
+              }
+              if (!app.objectStoreNames.contains("meta")) {
+                app.createObjectStore("meta");
+              }
+            }
+          }
+        });
+        return await this.dbPromise;
+      }
+      throw error;
+    }
   }
   // ==================== DOCS ====================
   async getDoc(collection, id) {
@@ -1757,6 +1979,25 @@ var Persistence = class {
     ]);
     return [...pending, ...failed].sort((a, b) => a.createdAt - b.createdAt);
   }
+  async getMutation(mutationId) {
+    const app = await this.getDb();
+    return await app.get("mutations", mutationId) ?? null;
+  }
+  async resetMutation(mutationId) {
+    const app = await this.getDb();
+    const old = await app.get("mutations", mutationId);
+    if (!old)
+      return null;
+    const next = {
+      ...old,
+      status: "pending",
+      retryCount: 0,
+      updatedAt: this.now(),
+      error: void 0
+    };
+    await app.put("mutations", next);
+    return next;
+  }
   async setMutationStatus(mutationId, status, error) {
     const app = await this.getDb();
     const old = await app.get("mutations", mutationId);
@@ -1891,7 +2132,7 @@ var RealtimeBridge = class {
           if (id)
             await this.handleRemoteDelete(collection, id);
         } else {
-          await this.handleRemoteCreateOrUpdate(collection, payload);
+          await this.handleRemoteCreateOrUpdate(collection, payload, change);
         }
       },
       filter
@@ -1916,7 +2157,7 @@ var RealtimeBridge = class {
         if (change === "delete") {
           await this.handleRemoteDelete(collection, id);
         } else {
-          await this.handleRemoteCreateOrUpdate(collection, payload);
+          await this.handleRemoteCreateOrUpdate(collection, payload, change);
         }
       }
     );
@@ -1931,13 +2172,13 @@ var RealtimeBridge = class {
   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, "init");
+    this.store.emitDocument(collection, id, snapshot, "insert");
   }
   async emitCurrentCollection(collection) {
     const localDocs = await this.persistence.getCollectionSnapshots(collection);
-    this.store.emitCollection(collection, localDocs, "init");
+    this.store.emitCollection(collection, localDocs, "insert");
   }
-  async handleRemoteCreateOrUpdate(collection, raw) {
+  async handleRemoteCreateOrUpdate(collection, raw, change) {
     const id = raw.id ?? raw._id;
     if (!id)
       return;
@@ -1945,15 +2186,13 @@ var RealtimeBridge = class {
     if (!saved)
       return;
     const snap = DocumentSnapshot.fromMap(saved.data);
-    this.store.emitDocument(collection, id, snap, "remote_update");
-    const currentCollection = await this.persistence.getCollectionSnapshots(collection);
-    this.store.emitCollection(collection, currentCollection, "remote_update", id);
+    this.store.emitDocument(collection, id, snap, change);
+    this.store.notifyCollectionChanged(collection, id, change);
   }
   async handleRemoteDelete(collection, id) {
     await this.persistence.applyRemoteDelete(collection, id);
-    this.store.emitDocument(collection, id, null, "remote_delete");
-    const currentCollection = await this.persistence.getCollectionSnapshots(collection);
-    this.store.emitCollection(collection, currentCollection, "remote_delete", id);
+    this.store.emitDocument(collection, id, null, "delete");
+    this.store.notifyCollectionChanged(collection, id, "delete");
   }
   // ===================== LIFECYCLE =====================
   /**
@@ -2029,7 +2268,7 @@ var SyncEngine = class {
         try {
           let success = false;
           switch (mutation.type) {
-            case "create":
+            case "insert":
               success = await this.syncCreate(mutation);
               break;
             case "update":
@@ -2055,7 +2294,7 @@ var SyncEngine = class {
           await this.persistence.setMutationStatus(
             mutation.mutationId,
             "failed",
-            error?.message ?? "Unknown sync error"
+            error?.message ?? "Unknown insert error"
           );
           if (nextRetryCount < this.MAX_RETRIES) {
             this.scheduleRetry();
@@ -2072,8 +2311,8 @@ var SyncEngine = class {
   async syncCreate(mutation) {
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/create`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/create`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: mutation.collection,
         data: mutation.payload
@@ -2090,18 +2329,17 @@ var SyncEngine = class {
     );
     if (replaced) {
       const snap = DocumentSnapshot.fromMap(replaced.data);
-      this.store.emitDocument(mutation.collection, oldId, snap, "sync");
-      this.store.emitDocument(mutation.collection, newId, snap, "sync");
-      const currentCollection = await this.persistence.getCollectionSnapshots(mutation.collection);
-      this.store.emitCollection(mutation.collection, currentCollection, "sync", newId);
+      this.store.emitDocument(mutation.collection, oldId, snap, "insert");
+      this.store.emitDocument(mutation.collection, newId, snap, "insert");
+      this.store.notifyCollectionChanged(mutation.collection, newId, "insert");
     }
     return true;
   }
   async syncUpdate(mutation) {
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/update`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/update`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: mutation.collection,
         document: mutation.documentId,
@@ -2123,19 +2361,17 @@ var SyncEngine = class {
       localOnly: false,
       status: "synced",
       lastSyncedAt: this.persistence["now"]?.() ?? Date.now()
-      // fallback
     });
     const snap = DocumentSnapshot.fromMap(local.data);
-    this.store.emitDocument(mutation.collection, mutation.documentId, snap, "sync");
-    const currentCollection = await this.persistence.getCollectionSnapshots(mutation.collection);
-    this.store.emitCollection(mutation.collection, currentCollection, "sync", mutation.documentId);
+    this.store.emitDocument(mutation.collection, mutation.documentId, snap, "update");
+    this.store.notifyCollectionChanged(mutation.collection, mutation.documentId, "update");
     return true;
   }
   async syncDelete(mutation) {
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
-      endpoint: `${this.app.getBaseUrl()}/app/delete`,
-      headers: { authorization: this.app.getConfig().token },
+      endpoint: `${this.app.getBaseUrl()}/db/delete`,
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         collection: mutation.collection,
         document: mutation.documentId
@@ -2144,9 +2380,8 @@ var SyncEngine = class {
     if (!res?.success)
       return false;
     await this.persistence.markDeleted(mutation.collection, mutation.documentId, 0);
-    this.store.emitDocument(mutation.collection, mutation.documentId, null, "sync");
-    const currentCollection = await this.persistence.getCollectionSnapshots(mutation.collection);
-    this.store.emitCollection(mutation.collection, currentCollection, "sync", mutation.documentId);
+    this.store.emitDocument(mutation.collection, mutation.documentId, null, "delete");
+    this.store.notifyCollectionChanged(mutation.collection, mutation.documentId, "delete");
     return true;
   }
   scheduleRetry() {
@@ -2161,6 +2396,50 @@ var SyncEngine = class {
   async forceSync() {
     return this.flush();
   }
+  /**
+   * Get all failed mutations for error handling/UI
+   * Returns mutations that exceeded MAX_RETRIES
+   */
+  async getFailedMutations() {
+    const all = await this.persistence.getPendingMutations();
+    return all.filter((m) => m.status === "failed");
+  }
+  /**
+   * Retry a specific failed mutation by resetting its retry count
+   * Useful for user-initiated recovery after fixing network/server issues
+   */
+  async retryMutation(mutationId) {
+    const reset = await this.persistence.resetMutation(mutationId);
+    if (!reset)
+      return false;
+    this.flush().catch(console.error);
+    return true;
+  }
+  /**
+   * Retry all failed mutations at once
+   */
+  async retryAllFailed() {
+    const failed = await this.getFailedMutations();
+    for (const mut of failed) {
+      await this.persistence.setMutationStatus(mut.mutationId, "pending");
+    }
+    if (failed.length > 0) {
+      this.flush().catch(console.error);
+    }
+    return failed.length;
+  }
+  /**
+   * Remove a mutation entirely (user acknowledges the failure and wants to discard it)
+   * Be careful: this means the operation will never sync to the server
+   */
+  async removeMutation(mutationId) {
+    try {
+      await this.persistence.removeMutation(mutationId);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   dispose() {
     if (this.retryTimeout) {
       clearTimeout(this.retryTimeout);
@@ -2234,9 +2513,7 @@ var StorageRef = class {
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
       endpoint: this.app.getBaseUrl() + "/storage/file/upload",
-      headers: {
-        authorization: this.app.getConfig().token
-      },
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       file: srcFile,
       isMultipart: true
     }).sendRequest();
@@ -2253,9 +2530,7 @@ var StorageRef = class {
     const res = await new HttpsRequest({
       method: "POST" /* POST */,
       endpoint: this.app.getBaseUrl() + "/storage/file/delete",
-      headers: {
-        authorization: this.app.getConfig().token
-      },
+      headers: { authorization: this.app.getConfig().token, project: this.app.getConfig().project },
       body: {
         file_id: id
       }
@@ -2297,7 +2572,8 @@ var _EdmaxLabs = class _EdmaxLabs {
     this._realtime = new Realtime(this);
     this._hosting = new Hosting(this);
     if (persistence) {
-      this.persistence = new Persistence();
+      const appName = config.app_name || config.project;
+      this.persistence = new Persistence(appName);
       this.localStore = new LocalStore();
       this.realtimeBridge = new RealtimeBridge(this, this.persistence, this.localStore);
       this.syncEngine = new SyncEngine(
@@ -2336,6 +2612,29 @@ var _EdmaxLabs = class _EdmaxLabs {
     }
     return Authentication.instance;
   }
+  // ===================== OFFLINE UTILITIES =====================
+  /** Check if offline features are enabled */
+  get isOfflineEnabled() {
+    return !!this.persistence;
+  }
+  /** Get current storage usage (approximate) */
+  async getStorageUsage() {
+    if (!this.persistence)
+      return null;
+    try {
+      const usage = await this.persistence.getStorageUsage();
+      return { used: usage, available: 50 * 1024 * 1024 };
+    } catch {
+      return null;
+    }
+  }
+  /** Clear all cached data (nuclear option) */
+  async clearCache() {
+    if (this.persistence) {
+      await this.persistence.clearAll();
+    }
+    this.localStore?.clearAllListeners();
+  }
   /** New clean offline namespace - highly recommended */
   offline() {
     return {
@@ -2343,9 +2642,39 @@ var _EdmaxLabs = class _EdmaxLabs {
       localStore: this.localStore,
       syncEngine: this.syncEngine,
       realtimeBridge: this.realtimeBridge,
-      enabled: !!this.persistence
+      enabled: !!this.persistence,
+      // Add cleanup utilities
+      clearListeners: () => this.localStore?.clearAllListeners(),
+      getListenerCount: () => this.localStore?.listenerCount || { documents: 0, collections: 0 }
     };
   }
+  /**
+   * Manually trigger sync of pending mutations
+   * Useful for progressive sync or after network restoration
+   */
+  async sync() {
+    if (!this.syncEngine) {
+      console.warn("[EdmaxLabs] Sync called but persistence is not enabled");
+      return;
+    }
+    return this.syncEngine.forceSync();
+  }
+  /**
+   * Get mutations that failed to sync (for error UI)
+   */
+  async getFailedMutations() {
+    if (!this.syncEngine)
+      return [];
+    return this.syncEngine.getFailedMutations();
+  }
+  /**
+   * Retry all failed mutations
+   */
+  async retrySync() {
+    if (!this.syncEngine)
+      return 0;
+    return this.syncEngine.retryAllFailed();
+  }
   // Internal access (for internal classes only)
   getConfig() {
     return { ...this._config };