@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/mutationEngine.spec.cjs

@@ -0,0 +1,1158 @@
+var import_vitest = require("vitest");
+var import_mutationEngine = require("./mutationEngine.cjs");
+var import_types = require("./types.cjs");
+var import_types2 = require("./types.cjs");
+(0, import_vitest.describe)("MutationEngine", () => {
+  let mutationEngine;
+  let mockDb;
+  let mockRealtime;
+  let mockNormalizedCache;
+  let mockMutationJournal;
+  let mockSubscriptionManager;
+  let mockRehydrationManager;
+  const mockDoc = {
+    name: "test-doc",
+    doctype: "TestDoc",
+    title: "Test Document",
+    modified: "2024-01-01T10:00:00",
+    creation: "2024-01-01T09:00:00",
+    owner: "test-user",
+    modified_by: "test-user"
+  };
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    const mockCall = {
+      post: import_vitest.vi.fn().mockResolvedValue({
+        results: []
+      })
+    };
+    mockDb = {
+      getDoc: import_vitest.vi.fn().mockResolvedValue(mockDoc),
+      createDoc: import_vitest.vi.fn().mockResolvedValue({
+        ...mockDoc,
+        name: "real-doc"
+      }),
+      updateDoc: import_vitest.vi.fn().mockResolvedValue({
+        ...mockDoc,
+        title: "Updated"
+      }),
+      deleteDoc: import_vitest.vi.fn().mockResolvedValue(void 0),
+      call: mockCall
+    };
+    mockRealtime = {
+      isHealthy: import_vitest.vi.fn().mockReturnValue(true)
+    };
+    mockNormalizedCache = {
+      get: import_vitest.vi.fn().mockReturnValue(mockDoc),
+      upsert: import_vitest.vi.fn(),
+      remove: import_vitest.vi.fn()
+    };
+    mockMutationJournal = {
+      add: import_vitest.vi.fn(),
+      confirm: import_vitest.vi.fn(),
+      fail: import_vitest.vi.fn(),
+      get: import_vitest.vi.fn().mockReturnValue({
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: mockDoc,
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending,
+        snapshot: mockDoc
+      }),
+      listPending: import_vitest.vi.fn().mockReturnValue([])
+    };
+    const mockSubscription = {
+      id: "sub1",
+      query: {
+        doctype: "TestDoc",
+        fields: ["*"],
+        filters: {},
+        limit: 20
+      },
+      docIds: ["doc1", "doc2"],
+      checkpoint: "checkpoint1",
+      metadata: {}
+    };
+    mockSubscriptionManager = {
+      getAllSubscriptions: import_vitest.vi.fn().mockReturnValue(/* @__PURE__ */new Map([["sub1", mockSubscription]])),
+      updateSubscriptionMembership: import_vitest.vi.fn().mockReturnValue([]),
+      removeFromAllSubscriptions: import_vitest.vi.fn().mockReturnValue(["sub1"]),
+      insertDocumentIntoSubscription: import_vitest.vi.fn()
+    };
+    mockRehydrationManager = {
+      scheduleRehydration: import_vitest.vi.fn(),
+      registerTempIdMapping: import_vitest.vi.fn()
+    };
+    Object.defineProperty(global, "crypto", {
+      value: {
+        randomUUID: import_vitest.vi.fn().mockReturnValue("uuid-12345")
+      },
+      writable: true
+    });
+    Object.defineProperty(global, "navigator", {
+      value: {
+        onLine: true
+      },
+      writable: true
+    });
+    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    import_vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+    import_vitest.vi.useRealTimers();
+  });
+  (0, import_vitest.describe)("constructor", () => {
+    (0, import_vitest.it)("should initialize with default options", () => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager);
+      (0, import_vitest.expect)(mutationEngine).toBeDefined();
+    });
+    (0, import_vitest.it)("should initialize with custom options", () => {
+      const options = {
+        batchSize: 20,
+        batchDelay: 200,
+        versionField: "timestamp"
+      };
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, options);
+      (0, import_vitest.expect)(mutationEngine).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle missing realtime module", () => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, void 0, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager);
+      (0, import_vitest.expect)(mutationEngine).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("mutate", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.describe)("create mutations", () => {
+      (0, import_vitest.it)("should handle create mutations successfully", async () => {
+        const mutation = {
+          mutationId: "mut1",
+          operation: import_types2.Operation.Create,
+          doc: {
+            doctype: "TestDoc",
+            name: "temp-doc",
+            title: "New Document"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "temp-doc",
+          title: "New Document"
+        }));
+        (0, import_vitest.expect)(mockDb.createDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc"
+        }));
+        (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut1");
+      });
+      (0, import_vitest.it)("should handle create without provided name", async () => {
+        const mutation = {
+          mutationId: "mut2",
+          operation: import_types2.Operation.Create,
+          doc: {
+            doctype: "TestDoc",
+            title: "New Document"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: import_vitest.expect.stringContaining("tmp_"),
+          title: "New Document"
+        }));
+      });
+      (0, import_vitest.it)("should handle temporary to real ID mapping", async () => {
+        const mutation = {
+          mutationId: "mut3",
+          operation: import_types2.Operation.Create,
+          doc: {
+            doctype: "TestDoc",
+            name: "temp-doc",
+            title: "New Document"
+          },
+          version: void 0,
+          affected: []
+        };
+        mockDb.createDoc.mockResolvedValue({
+          ...mockDoc,
+          name: "real-doc-123"
+        });
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockRehydrationManager.registerTempIdMapping).toHaveBeenCalledWith("temp-doc", "real-doc-123");
+        (0, import_vitest.expect)(mockNormalizedCache.remove).toHaveBeenCalledWith({
+          doctype: "TestDoc",
+          name: "temp-doc"
+        });
+      });
+      (0, import_vitest.it)("should schedule rehydration for affected subscriptions", async () => {
+        const mutation = {
+          mutationId: "mut4",
+          operation: import_types2.Operation.Create,
+          doc: {
+            doctype: "TestDoc",
+            name: "temp-doc",
+            title: "New Document"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(import_vitest.expect.any(Object), import_types.RehydrationReason.Create);
+      });
+    });
+    (0, import_vitest.describe)("update mutations", () => {
+      (0, import_vitest.it)("should handle update mutations successfully", async () => {
+        const mutation = {
+          mutationId: "mut5",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated Title"
+          },
+          version: "2024-01-01T10:00:00",
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated Title"
+        }));
+        (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated Title"
+        }));
+        (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut5");
+      });
+      (0, import_vitest.it)("should throw error for update without docname", async () => {
+        const mutation = {
+          mutationId: "mut6",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            title: "Updated Title"
+          },
+          version: void 0,
+          affected: []
+        };
+        await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("docname is required for update/delete operations");
+      });
+      (0, import_vitest.it)("should determine version from cached document", async () => {
+        const mutation = {
+          mutationId: "mut7",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated Title"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "test-doc"
+        }));
+      });
+      (0, import_vitest.it)("should fetch document for version when not cached", async () => {
+        mockNormalizedCache.get.mockReturnValue(void 0);
+        mockDb.getDoc.mockResolvedValue({
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Original Title",
+          modified: "2024-01-01T10:00:00"
+        });
+        const mutation = {
+          mutationId: "mut8",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated Title"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "test-doc");
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalled();
+      });
+      (0, import_vitest.it)("should handle preflight fetch failures gracefully", async () => {
+        mockNormalizedCache.get.mockReturnValue(void 0);
+        mockDb.getDoc.mockRejectedValue(new Error("Network error"));
+        const mutation = {
+          mutationId: "mut9",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated Title"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "test-doc"
+        }));
+      });
+    });
+    (0, import_vitest.describe)("delete mutations", () => {
+      (0, import_vitest.it)("should handle delete mutations successfully", async () => {
+        const mutation = {
+          mutationId: "mut10",
+          operation: import_types2.Operation.Delete,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc"
+          },
+          version: "2024-01-01T10:00:00",
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockNormalizedCache.remove).toHaveBeenCalledWith({
+          doctype: "TestDoc",
+          name: "test-doc"
+        });
+        (0, import_vitest.expect)(mockSubscriptionManager.removeFromAllSubscriptions).toHaveBeenCalledWith("TestDoc", "test-doc");
+        (0, import_vitest.expect)(mockDb.deleteDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+          doctype: "TestDoc",
+          name: "test-doc"
+        }));
+        (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut10");
+      });
+      (0, import_vitest.it)("should schedule rehydration for affected subscriptions", async () => {
+        const mockSubscription = {
+          id: "sub1",
+          query: {
+            doctype: "TestDoc",
+            fields: ["*"],
+            filters: {},
+            limit: 20
+          },
+          docIds: ["test-doc", "doc2"],
+          checkpoint: "checkpoint1",
+          metadata: {}
+        };
+        mockSubscriptionManager.getAllSubscriptions.mockReturnValue(/* @__PURE__ */new Map([["sub1", mockSubscription]]));
+        const mutation = {
+          mutationId: "mut11",
+          operation: import_types2.Operation.Delete,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(import_vitest.expect.any(Object), import_types.RehydrationReason.Delete);
+      });
+      (0, import_vitest.it)("should throw error for delete without docname", async () => {
+        const mutation = {
+          mutationId: "mut12",
+          operation: import_types2.Operation.Delete,
+          doc: {
+            doctype: "TestDoc"
+          },
+          version: void 0,
+          affected: []
+        };
+        await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("docname is required for update/delete operations");
+      });
+    });
+    (0, import_vitest.describe)("callback integration", () => {
+      (0, import_vitest.it)("should call mutation lifecycle callbacks", async () => {
+        const callbacks = {
+          onMutationStart: import_vitest.vi.fn(),
+          onMutationSuccess: import_vitest.vi.fn(),
+          onOptimisticApply: import_vitest.vi.fn()
+        };
+        mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, callbacks);
+        const mutation = {
+          mutationId: "mut13",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated"
+          },
+          version: void 0,
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(callbacks.onMutationStart).toHaveBeenCalledWith(mutation);
+        (0, import_vitest.expect)(callbacks.onMutationSuccess).toHaveBeenCalledWith(mutation);
+        (0, import_vitest.expect)(callbacks.onOptimisticApply).toHaveBeenCalledWith({
+          doctype: "TestDoc",
+          name: "test-doc",
+          operation: import_types2.Operation.Update
+        });
+      });
+    });
+    (0, import_vitest.describe)("realtime integration", () => {
+      (0, import_vitest.it)("should refetch documents when realtime is unhealthy", async () => {
+        mockRealtime.isHealthy.mockReturnValue(false);
+        const mutation = {
+          mutationId: "mut14",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated"
+          },
+          version: void 0,
+          affected: [{
+            doctype: "RelatedDoc",
+            name: "related-doc"
+          }]
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "test-doc");
+        (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("RelatedDoc", "related-doc");
+      });
+      (0, import_vitest.it)("should not refetch when realtime is healthy", async () => {
+        mockRealtime.isHealthy.mockReturnValue(true);
+        mockDb.getDoc.mockClear();
+        const mutation = {
+          mutationId: "mut15",
+          operation: import_types2.Operation.Update,
+          doc: {
+            doctype: "TestDoc",
+            name: "test-doc",
+            title: "Updated"
+          },
+          version: "2024-01-01T10:00:00",
+          affected: []
+        };
+        await mutationEngine.mutate(mutation);
+        (0, import_vitest.expect)(mockDb.getDoc).not.toHaveBeenCalled();
+      });
+    });
+  });
+  (0, import_vitest.describe)("error handling", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        onMutationError: import_vitest.vi.fn(),
+        onConflict: import_vitest.vi.fn()
+      });
+    });
+    (0, import_vitest.it)("should handle server errors", async () => {
+      const error = new Error("Server error");
+      mockDb.createDoc.mockRejectedValue(error);
+      const mutation = {
+        mutationId: "mut16",
+        operation: import_types2.Operation.Create,
+        doc: {
+          doctype: "TestDoc",
+          name: "temp-doc",
+          title: "New Document"
+        },
+        version: void 0,
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("Server error");
+      (0, import_vitest.expect)(mockMutationJournal.fail).toHaveBeenCalledWith("mut16");
+    });
+    (0, import_vitest.it)("should handle conflict errors (409)", async () => {
+      const error = {
+        status: 409
+      };
+      mockDb.updateDoc.mockRejectedValue(error);
+      const mutation = {
+        mutationId: "mut17",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        version: "2024-01-01T09:00:00",
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toEqual(error);
+      (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "test-doc");
+    });
+    (0, import_vitest.it)("should handle snapshot rollback on error", async () => {
+      const error = new Error("Update failed");
+      mockDb.updateDoc.mockRejectedValue(error);
+      const mutation = {
+        mutationId: "mut18",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        version: void 0,
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("Update failed");
+      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(mockDoc);
+    });
+    (0, import_vitest.it)("should not rollback when offline", async () => {
+      Object.defineProperty(global, "navigator", {
+        value: {
+          onLine: false
+        },
+        writable: true
+      });
+      const error = new Error("Network error");
+      mockDb.updateDoc.mockRejectedValue(error);
+      const mutation = {
+        mutationId: "mut19",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        version: void 0,
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("Network error");
+      const upsertCalls = mockNormalizedCache.upsert.mock.calls;
+      const rollbackCall = upsertCalls.find(call => call[0] === mockDoc && upsertCalls.indexOf(call) > 0
+      // Not the initial optimistic update
+      );
+      (0, import_vitest.expect)(rollbackCall).toBeUndefined();
+    });
+    (0, import_vitest.it)("should handle failed create mutations", async () => {
+      const error = new Error("Create failed");
+      mockDb.createDoc.mockRejectedValue(error);
+      const subscription = {
+        id: "sub1",
+        query: {
+          doctype: "TestDoc"
+        },
+        docIds: ["temp-doc", "other-doc"]
+      };
+      mockSubscriptionManager.getAllSubscriptions.mockReturnValue(/* @__PURE__ */new Map([["sub1", subscription]]));
+      const mutation = {
+        mutationId: "mut20",
+        operation: import_types2.Operation.Create,
+        doc: {
+          doctype: "TestDoc",
+          name: "temp-doc",
+          title: "New Document"
+        },
+        version: void 0,
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("Create failed");
+      (0, import_vitest.expect)(subscription.docIds).toEqual(["other-doc"]);
+    });
+  });
+  (0, import_vitest.describe)("replayPending", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        onReplayStart: import_vitest.vi.fn(),
+        onReplayComplete: import_vitest.vi.fn(),
+        onConflict: import_vitest.vi.fn(),
+        onMutationError: import_vitest.vi.fn()
+      });
+    });
+    (0, import_vitest.it)("should replay pending create mutations", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Test"
+        },
+        operation: import_types2.Operation.Create,
+        version: void 0,
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut21",
+        entry: pendingEntry
+      }]);
+      await mutationEngine.replayPending();
+      (0, import_vitest.expect)(mockDb.createDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        doctype: "TestDoc",
+        client_mutation_id: "mut21"
+      }));
+      (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut21");
+    });
+    (0, import_vitest.it)("should replay pending update mutations", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut22",
+        entry: pendingEntry
+      }]);
+      await mutationEngine.replayPending();
+      (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        doctype: "TestDoc",
+        name: "test-doc",
+        client_mutation_id: "mut22",
+        base_modified: "2024-01-01T10:00:00"
+      }));
+      (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut22");
+    });
+    (0, import_vitest.it)("should replay pending delete mutations", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: void 0,
+        operation: import_types2.Operation.Delete,
+        version: void 0,
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut23",
+        entry: pendingEntry
+      }]);
+      await mutationEngine.replayPending();
+      (0, import_vitest.expect)(mockDb.deleteDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        doctype: "TestDoc",
+        name: "test-doc",
+        client_mutation_id: "mut23"
+      }));
+      (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("mut23");
+    });
+    (0, import_vitest.it)("should handle replay conflicts", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut24",
+        entry: pendingEntry
+      }]);
+      mockDb.updateDoc.mockRejectedValue({
+        status: 409
+      });
+      await mutationEngine.replayPending();
+      const options = mutationEngine;
+      (0, import_vitest.expect)(options.options.onConflict).toHaveBeenCalledWith({
+        doctype: "TestDoc",
+        name: "test-doc"
+      });
+    });
+    (0, import_vitest.it)("should handle replay auth errors", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        operation: import_types2.Operation.Update,
+        version: void 0,
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut25",
+        entry: pendingEntry
+      }]);
+      mockDb.updateDoc.mockRejectedValue({
+        status: 401
+      });
+      await mutationEngine.replayPending();
+      (0, import_vitest.expect)(mockMutationJournal.confirm).not.toHaveBeenCalledWith("mut25");
+      (0, import_vitest.expect)(mockMutationJournal.fail).not.toHaveBeenCalledWith("mut25");
+    });
+    (0, import_vitest.it)("should handle permanent replay errors", async () => {
+      const pendingEntry = {
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        operation: import_types2.Operation.Update,
+        version: void 0,
+        status: import_types2.Status.Pending
+      };
+      mockMutationJournal.listPending.mockReturnValue([{
+        id: "mut26",
+        entry: pendingEntry
+      }]);
+      mockDb.updateDoc.mockRejectedValue({
+        status: 400
+      });
+      await mutationEngine.replayPending();
+      (0, import_vitest.expect)(mockMutationJournal.fail).toHaveBeenCalledWith("mut26");
+    });
+    (0, import_vitest.it)("should call replay callbacks", async () => {
+      mockMutationJournal.listPending.mockReturnValue([]);
+      await mutationEngine.replayPending();
+      const options = mutationEngine;
+      (0, import_vitest.expect)(options.options.onReplayStart).toHaveBeenCalled();
+      (0, import_vitest.expect)(options.options.onReplayComplete).toHaveBeenCalledWith({
+        anyFailed: false
+      });
+    });
+  });
+  (0, import_vitest.describe)("temporary ID management", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.it)("should return temporary ID mappings", () => {
+      const tempMap = mutationEngine.getTemporaryIdToRealNameMap();
+      (0, import_vitest.expect)(tempMap).toBeInstanceOf(Map);
+    });
+    (0, import_vitest.it)("should clear temporary mappings", () => {
+      const tempMap = mutationEngine.getTemporaryIdToRealNameMap();
+      tempMap.set("temp1", "real1");
+      mutationEngine.clearTemporaryMappings();
+      (0, import_vitest.expect)(tempMap.size).toBe(0);
+    });
+  });
+  (0, import_vitest.describe)("cleanup and disposal", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.it)("should dispose of resources", () => {
+      const tempMap = mutationEngine.getTemporaryIdToRealNameMap();
+      tempMap.set("temp1", "real1");
+      mutationEngine.dispose();
+      (0, import_vitest.expect)(tempMap.size).toBe(0);
+    });
+  });
+  (0, import_vitest.describe)("edge cases", () => {
+    (0, import_vitest.beforeEach)(() => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.it)("should handle missing crypto.randomUUID", async () => {
+      global.crypto = void 0;
+      const mutation = {
+        mutationId: "no-crypto",
+        operation: import_types2.Operation.Create,
+        doc: {
+          doctype: "TestDoc",
+          title: "New Document"
+        },
+        version: void 0,
+        affected: []
+      };
+      mockSubscriptionManager.getAllSubscriptions = import_vitest.vi.fn().mockReturnValue(/* @__PURE__ */new Map());
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).resolves.not.toThrow();
+    });
+    (0, import_vitest.it)("should handle undefined navigator", async () => {
+      global.navigator = void 0;
+      const error = new Error("Update failed");
+      mockDb.updateDoc.mockRejectedValue(error);
+      const mutation = {
+        mutationId: "no-navigator",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        version: void 0,
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toThrow("Update failed");
+      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenLastCalledWith(mockDoc);
+    });
+    (0, import_vitest.it)("should handle custom version fields", async () => {
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        versionFields: {
+          TestDoc: "timestamp"
+        }
+      });
+      const docWithTimestamp = {
+        ...mockDoc,
+        timestamp: "2024-01-01T12:00:00"
+      };
+      mockNormalizedCache.get.mockReturnValue(docWithTimestamp);
+      const mutation = {
+        mutationId: "custom-version",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Updated"
+        },
+        version: void 0,
+        affected: []
+      };
+      await mutationEngine.mutate(mutation);
+      (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        doctype: "TestDoc",
+        name: "test-doc"
+      }));
+    });
+  });
+  (0, import_vitest.describe)("buildMergeConfig", () => {
+    (0, import_vitest.it)("should apply field merge config via handleConflict auto-merge", async () => {
+      const onConflict = import_vitest.vi.fn();
+      const baseDoc = {
+        ...mockDoc,
+        priority: 5
+      };
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        fieldMergeConfig: {
+          TestDoc: {
+            priority: "max"
+          }
+        },
+        onConflict,
+        onMutationError: import_vitest.vi.fn()
+      });
+      mockNormalizedCache.get.mockReturnValue(baseDoc);
+      mockMutationJournal.get.mockReturnValue({
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          ...baseDoc,
+          priority: 8
+        },
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending,
+        snapshot: baseDoc
+      });
+      mockDb.updateDoc.mockRejectedValueOnce({
+        status: 409
+      }).mockResolvedValueOnce({
+        ...baseDoc,
+        priority: 10
+      });
+      const serverDoc = {
+        ...baseDoc,
+        priority: 10,
+        modified: "2024-01-01T11:00:00"
+      };
+      mockDb.getDoc.mockResolvedValue(serverDoc);
+      const mutation = {
+        mutationId: "merge-test",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          priority: 8
+        },
+        version: "2024-01-01T10:00:00",
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toEqual({
+        status: 409
+      });
+      (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledTimes(2);
+      const retryCall = mockDb.updateDoc.mock.calls[1][0];
+      (0, import_vitest.expect)(retryCall.priority).toBe(10);
+      (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("merge-test");
+      (0, import_vitest.expect)(onConflict).not.toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("handleConflict auto-merge", () => {
+    (0, import_vitest.it)("should auto-merge disjoint updates", async () => {
+      const onConflict = import_vitest.vi.fn();
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        onConflict,
+        onMutationError: import_vitest.vi.fn()
+      });
+      const baseDoc = {
+        ...mockDoc,
+        title: "Original Title",
+        status: "Draft"
+      };
+      mockNormalizedCache.get.mockReturnValue(baseDoc);
+      mockMutationJournal.get.mockReturnValue({
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          ...baseDoc,
+          title: "Client Title"
+        },
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending,
+        snapshot: baseDoc
+      });
+      mockDb.updateDoc.mockRejectedValueOnce({
+        status: 409
+      }).mockResolvedValueOnce({
+        ...mockDoc
+      });
+      const serverDoc = {
+        ...baseDoc,
+        status: "Approved",
+        modified: "2024-01-01T11:00:00"
+      };
+      mockDb.getDoc.mockResolvedValue(serverDoc);
+      const mutation = {
+        mutationId: "disjoint-test",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Client Title"
+        },
+        version: "2024-01-01T10:00:00",
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toEqual({
+        status: 409
+      });
+      (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledTimes(2);
+      const retryCall = mockDb.updateDoc.mock.calls[1][0];
+      (0, import_vitest.expect)(retryCall.title).toBe("Client Title");
+      (0, import_vitest.expect)(retryCall.status).toBe("Approved");
+      (0, import_vitest.expect)(mockMutationJournal.confirm).toHaveBeenCalledWith("disjoint-test");
+      (0, import_vitest.expect)(onConflict).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should delegate overlapping conflicts to onConflict", async () => {
+      const onConflict = import_vitest.vi.fn();
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        onConflict,
+        onMutationError: import_vitest.vi.fn()
+      });
+      const baseDoc = {
+        ...mockDoc,
+        title: "Original Title"
+      };
+      mockNormalizedCache.get.mockReturnValue(baseDoc);
+      mockMutationJournal.get.mockReturnValue({
+        doctype: "TestDoc",
+        docname: "test-doc",
+        values: {
+          ...baseDoc,
+          title: "Client Title"
+        },
+        operation: import_types2.Operation.Update,
+        version: "2024-01-01T10:00:00",
+        status: import_types2.Status.Pending,
+        snapshot: baseDoc
+      });
+      mockDb.updateDoc.mockRejectedValue({
+        status: 409
+      });
+      const serverDoc = {
+        ...baseDoc,
+        title: "Server Title",
+        modified: "2024-01-01T11:00:00"
+      };
+      mockDb.getDoc.mockResolvedValue(serverDoc);
+      const mutation = {
+        mutationId: "overlap-test",
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: "test-doc",
+          title: "Client Title"
+        },
+        version: "2024-01-01T10:00:00",
+        affected: []
+      };
+      await (0, import_vitest.expect)(mutationEngine.mutate(mutation)).rejects.toEqual({
+        status: 409
+      });
+      (0, import_vitest.expect)(onConflict).toHaveBeenCalledWith({
+        doctype: "TestDoc",
+        name: "test-doc"
+      });
+      (0, import_vitest.expect)(mockDb.updateDoc).toHaveBeenCalledTimes(1);
+    });
+  });
+  (0, import_vitest.describe)("onRetry callback", () => {
+    (0, import_vitest.it)("should call onRetry for each pending mutation during replay", async () => {
+      const onRetry = import_vitest.vi.fn();
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        onRetry,
+        onReplayStart: import_vitest.vi.fn(),
+        onReplayComplete: import_vitest.vi.fn()
+      });
+      const pendingEntries = [{
+        id: "retry-1",
+        entry: {
+          doctype: "TestDoc",
+          docname: "doc-1",
+          values: {
+            doctype: "TestDoc",
+            name: "doc-1",
+            title: "Doc 1"
+          },
+          operation: import_types2.Operation.Update,
+          version: "2024-01-01T10:00:00",
+          status: import_types2.Status.Pending
+        }
+      }, {
+        id: "retry-2",
+        entry: {
+          doctype: "TestDoc",
+          docname: "doc-2",
+          values: {
+            doctype: "TestDoc",
+            name: "doc-2",
+            title: "Doc 2"
+          },
+          operation: import_types2.Operation.Create,
+          version: void 0,
+          status: import_types2.Status.Pending
+        }
+      }];
+      mockMutationJournal.listPending.mockReturnValue(pendingEntries);
+      const replayPromise = mutationEngine.replayPending();
+      await import_vitest.vi.advanceTimersByTimeAsync(1e3);
+      await replayPromise;
+      (0, import_vitest.expect)(onRetry).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(onRetry).toHaveBeenCalledWith({
+        id: "retry-1",
+        operation: import_types2.Operation.Update
+      });
+      (0, import_vitest.expect)(onRetry).toHaveBeenCalledWith({
+        id: "retry-2",
+        operation: import_types2.Operation.Create
+      });
+    });
+  });
+  (0, import_vitest.describe)("batch mutations", () => {
+    (0, import_vitest.it)("should batch mutations and flush after batchDelay", async () => {
+      mockDb.batchMutations = import_vitest.vi.fn().mockResolvedValue([{
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-1",
+          title: "Title 1"
+        }
+      }, {
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-2",
+          title: "Title 2"
+        }
+      }, {
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-3",
+          title: "Title 3"
+        }
+      }]);
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        enableBatching: true,
+        batchDelay: 50,
+        batchMaxSize: 10
+      });
+      mockNormalizedCache.get.mockImplementation(ref => ({
+        ...mockDoc,
+        name: ref.name,
+        modified: "2024-01-01T10:00:00"
+      }));
+      const mutations = [1, 2, 3].map(i => ({
+        mutationId: `batch-${i}`,
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: `test-doc-${i}`,
+          title: `Title ${i}`
+        },
+        version: "2024-01-01T10:00:00",
+        affected: []
+      }));
+      const promises = mutations.map(m => mutationEngine.mutate(m));
+      await import_vitest.vi.advanceTimersByTimeAsync(100);
+      await Promise.all(promises);
+      (0, import_vitest.expect)(mockDb.batchMutations).toHaveBeenCalledTimes(1);
+      (0, import_vitest.expect)(mockDb.batchMutations).toHaveBeenCalledWith(import_vitest.expect.objectContaining({
+        mutations: import_vitest.expect.arrayContaining([import_vitest.expect.objectContaining({
+          type: "update",
+          doctype: "TestDoc",
+          name: "test-doc-1"
+        }), import_vitest.expect.objectContaining({
+          type: "update",
+          doctype: "TestDoc",
+          name: "test-doc-2"
+        }), import_vitest.expect.objectContaining({
+          type: "update",
+          doctype: "TestDoc",
+          name: "test-doc-3"
+        })])
+      }));
+    });
+    (0, import_vitest.it)("should flush immediately when batchMaxSize is reached and keep remaining pending", async () => {
+      mockDb.batchMutations = import_vitest.vi.fn().mockResolvedValueOnce([{
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-1"
+        }
+      }, {
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-2"
+        }
+      }, {
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-3"
+        }
+      }]).mockResolvedValueOnce([{
+        success: true,
+        data: {
+          ...mockDoc,
+          name: "test-doc-4"
+        }
+      }]);
+      mutationEngine = new import_mutationEngine.MutationEngine(mockDb, mockRealtime, mockNormalizedCache, mockMutationJournal, mockSubscriptionManager, mockRehydrationManager, {
+        enableBatching: true,
+        batchDelay: 50,
+        batchMaxSize: 3
+      });
+      mockNormalizedCache.get.mockImplementation(ref => ({
+        ...mockDoc,
+        name: ref.name,
+        modified: "2024-01-01T10:00:00"
+      }));
+      const mutations = [1, 2, 3, 4].map(i => ({
+        mutationId: `batch-${i}`,
+        operation: import_types2.Operation.Update,
+        doc: {
+          doctype: "TestDoc",
+          name: `test-doc-${i}`,
+          title: `Title ${i}`
+        },
+        version: "2024-01-01T10:00:00",
+        affected: []
+      }));
+      const promises = mutations.map(m => mutationEngine.mutate(m));
+      await import_vitest.vi.advanceTimersByTimeAsync(100);
+      await Promise.all(promises);
+      (0, import_vitest.expect)(mockDb.batchMutations).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(mockDb.batchMutations.mock.calls[0][0].mutations).toHaveLength(3);
+      (0, import_vitest.expect)(mockDb.batchMutations.mock.calls[1][0].mutations).toHaveLength(1);
+    });
+  });
+});