@peers-app/peers-device 0.7.25 → 0.7.27

package/dist/tracked-data-source.test.js

@@ -1,19 +1,25 @@
 "use strict";
+/**
+ * Unit tests for TrackedDataSource
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
 const peers_sdk_1 = require("@peers-app/peers-sdk");
 const zod_1 = require("zod");
 const tracked_data_source_1 = require("./tracked-data-source");
 const local_data_source_1 = require("./local.data-source");
-describe('tracked-table', () => {
-    const db = new local_data_source_1.DBLocal(':memory:');
+describe('TrackedDataSource', () => {
+    let db;
+    let sqlDataSource;
+    // let Notes: Table<INote>;
+    let changeTrackingTable;
+    let trackedTable;
     const notesSchema = zod_1.z.object({
         noteId: zod_1.z.string(),
         title: zod_1.z.string(),
         completed: zod_1.z.boolean().optional(),
-        number: zod_1.z.number().optional(),
-        string: zod_1.z.string().optional(),
-        date: zod_1.z.date().optional(),
+        count: zod_1.z.number().optional(),
+        tags: zod_1.z.array(zod_1.z.string()).optional(),
+        links: peers_sdk_1.zodAnyObject.optional(),
     });
     const NotesMetaData = {
         name: 'notes',
@@ -21,805 +27,842 @@ describe('tracked-table', () => {
         primaryKeyName: 'noteId',
         fields: (0, peers_sdk_1.schemaToFields)(notesSchema),
     };
-    const sqlDataSource = new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema);
-    const mockDataContext = {
-        dataSourceFactory: () => sqlDataSource,
-        eventRegistry: {
-            getEmitter: () => ({
-                event: { subscribe: () => { } },
-                emit: () => { }
-            })
-        }
-    };
-    const deps = {
-        dataSource: sqlDataSource,
-        eventRegistry: mockDataContext.eventRegistry
-    };
-    const Notes = new peers_sdk_1.Table(NotesMetaData, deps);
-    const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
-    const trackedTable = new tracked_data_source_1.TrackedDataSource(Notes, changeTrackingTable);
-    beforeEach(async () => {
-        // await Notes.dropTableIfExists();
-        await changeTrackingTable.dropTableIfExists();
-        await (0, peers_sdk_1.sleep)(200);
+    beforeAll(async () => {
+        db = new local_data_source_1.DBLocal(':memory:');
+    });
+    afterEach(() => {
+        trackedTable.preserveHistory = false;
     });
     afterAll(async () => {
-        await (0, peers_sdk_1.sleep)(200);
+        if (db) {
+            await db.close();
+        }
     });
-    it('should track changes when inserting data', async () => {
-        // Insert a new record
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        expect(note.noteId).toBeDefined();
-        // Check that the change was recorded
-        const changes = await changeTrackingTable.list();
-        expect(changes.length).toBe(1);
-        expect(changes[0].tableName).toBe('notes');
-        const change = changes[0];
-        expect(change).toEqual({
-            changeId: expect.any(String),
-            changeType: 'insert',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: note,
-        });
+    async function dataSourceFactory(db) {
+        let createDb = !db;
+        if (!db) {
+            db = new local_data_source_1.DBLocal(':memory:');
+        }
+        // Create fresh instances for each test
+        sqlDataSource = new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema);
+        const mockDataContext = {
+            dataSourceFactory: () => sqlDataSource,
+            eventRegistry: {
+                getEmitter: () => ({
+                    event: { subscribe: () => { } },
+                    emit: () => { },
+                }),
+            },
+        };
+        const deps = {
+            dataSource: sqlDataSource,
+            eventRegistry: mockDataContext.eventRegistry,
+        };
+        const Notes = new peers_sdk_1.Table(NotesMetaData, deps);
+        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
+        const trackedTable = new tracked_data_source_1.TrackedDataSource(Notes, changeTrackingTable);
+        if (!createDb) {
+            // Clean up tables
+            await changeTrackingTable.dropTableIfExists();
+            await sqlDataSource.dropTableIfExists();
+            await (0, peers_sdk_1.sleep)(50);
+        }
+        return [changeTrackingTable, trackedTable];
+    }
+    beforeEach(async () => {
+        [changeTrackingTable, trackedTable] = await dataSourceFactory(db);
     });
-    it('should track changes when updating data', async () => {
-        // Insert a new record
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Update the record
-        note.title = 'updated note';
-        note.completed = true;
-        await trackedTable.update(note);
-        // Check that both changes were recorded
-        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(2);
-        // Verify insert change
-        expect(changes[0]).toEqual({
-            changeId: expect.any(String),
-            changeType: 'insert',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'test note',
-                noteId: note.noteId
-            }),
-        });
-        // Verify update change
-        const updateChange = changes[1];
-        expect(updateChange).toEqual({
-            changeId: expect.any(String),
-            changeType: 'update',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'updated note',
-                noteId: note.noteId,
-                completed: true
-            }),
-            jsonDiff: expect.any(Array),
-        });
-        // TypeScript needs this cast for type narrowing
-        expect(updateChange.jsonDiff.length).toBeGreaterThan(0);
+    describe('Insert Operations', () => {
+        it('should insert a record and create a single full-object change', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note', completed: false });
+            expect(note.noteId).toBeDefined();
+            expect(note.title).toBe('test note');
+            // Check that changes were recorded
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            // Should have exactly one change at path "/"
+            expect(changes.length).toBe(1);
+            expect(changes[0].op).toBe('set');
+            expect(changes[0].path).toBe('/');
+            expect(changes[0].value).toEqual(note);
+            expect(changes[0].tableName).toBe('notes');
+            expect(changes[0].recordId).toBe(note.noteId);
+            expect(changes[0].createdAt).toBeDefined();
+            expect(changes[0].appliedAt).toBeDefined();
+            // Verify the record was actually inserted
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toEqual(note);
+        });
+        it('should auto-generate noteId if not provided', async () => {
+            const note = await trackedTable.insert({ title: 'test note' });
+            expect(note.noteId).toBeDefined();
+            expect(note.noteId.length).toBeGreaterThan(0);
+        });
+        it('should store operations in sequential timestamp order', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note', completed: false });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }, { sortBy: ['createdAt'] });
+            // Verify timestamps are sequential
+            for (let i = 1; i < changes.length; i++) {
+                expect(changes[i].createdAt).toBeGreaterThan(changes[i - 1].createdAt);
+            }
+        });
     });
-    it('should track changes when deleting data', async () => {
-        // Insert a new record
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Delete the record
-        await trackedTable.delete(note);
-        // Check that both changes were recorded
-        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(2);
-        // Get the changes in the right order
-        const insertChange = changes.find(c => c.changeType === 'insert');
-        const deleteChange = changes.find(c => c.changeType === 'delete');
-        expect(insertChange).toEqual({
-            changeId: expect.any(String),
-            changeType: 'insert',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'test note',
-                noteId: note.noteId
-            }),
-        });
-        // Verify delete change
-        expect(deleteChange).toEqual({
-            changeId: expect.any(String),
-            changeType: 'delete',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            oldRecord: expect.objectContaining({
-                title: 'test note',
-                noteId: note.noteId
-            }),
+    describe('Update Operations', () => {
+        it('should update a record and store granular change records', async () => {
+            // Insert
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            // Count initial changes
+            const initialChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const initialCount = initialChanges.length;
+            // Update
+            note.title = 'updated';
+            note.completed = true;
+            await trackedTable.update(note);
+            // Check that new changes were added
+            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(allChanges.length).toBeGreaterThan(initialCount);
+            // The new changes should be 'replace' or 'add' operations
+            const updateChanges = allChanges.slice(initialCount);
+            updateChanges.forEach((change) => {
+                expect(['set', 'delete', 'patch-text']).toContain(change.op);
+            });
+            // Verify the record was actually updated
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved?.title).toBe('updated');
+            expect(retrieved?.completed).toBe(true);
+        });
+        it('should handle no-op updates gracefully', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const changesBeforeUpdate = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            // Update with same values
+            await trackedTable.update(note);
+            const changesAfterUpdate = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changesAfterUpdate.length).toBe(changesBeforeUpdate.length); // No new changes
+        });
+        it('should mark old changes as superseded when saveAsSnapshot is true', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            // Get initial changes
+            const initialChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(initialChanges.every((c) => !c.supersededAt)).toBe(true);
+            // Update with saveAsSnapshot
+            note.title = 'updated';
+            await trackedTable.save(note, { saveAsSnapshot: true });
+            // Check that old changes are marked as superseded
+            const oldChanges = await changeTrackingTable.list({
+                recordId: note.noteId,
+                supersededAt: { $exists: true },
+            });
+            expect(oldChanges.length).toBeGreaterThan(0);
+            oldChanges.forEach((change) => {
+                expect(change.supersededAt).toBeDefined();
+            });
+            // New changes should not be superseded
+            const activeChanges = await changeTrackingTable.list({
+                recordId: note.noteId,
+                supersededAt: { $exists: false },
+            });
+            expect(activeChanges.length).toBeGreaterThan(0);
+            activeChanges.forEach((change) => {
+                expect(change.supersededAt).toBeUndefined();
+            });
         });
     });
-    it('should track changes when using save method for new records', async () => {
-        // Save a new record
-        const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Check that the change was recorded
-        const changes = await changeTrackingTable.list();
-        expect(changes.length).toBe(1);
-        expect(changes[0]).toEqual({
-            changeId: expect.any(String),
-            changeType: 'insert',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'test note',
-                noteId: note.noteId
-            }),
+    describe('Delete Operations', () => {
+        it('should delete a record and create a remove operation', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            // Check for remove operation
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const removeOp = changes.find((c) => c.op === 'delete');
+            expect(removeOp).toBeDefined();
+            expect(removeOp?.op).toBe('delete');
+            // Verify record was deleted
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toBeUndefined();
+        });
+        it('should delete by string ID', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note.noteId);
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toBeUndefined();
+        });
+        it('should mark old changes as superseded after delete', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            // Initial changes should not be superseded
+            const beforeDelete = await changeTrackingTable.list({
+                tableName: 'notes',
+                recordId: note.noteId,
+                supersededAt: { $exists: false },
+            });
+            expect(beforeDelete.length).toBeGreaterThan(0);
+            await trackedTable.delete(note);
+            // Old changes should now be superseded (except the remove operation)
+            const superseded = await changeTrackingTable.list({
+                tableName: 'notes',
+                recordId: note.noteId,
+                supersededAt: { $exists: true },
+            });
+            expect(superseded.length).toBeGreaterThan(0);
         });
     });
-    it('should track changes when using save method for existing records', async () => {
-        // Save a new record
-        const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Update using save
-        note.title = 'updated note';
-        await trackedTable.save(note);
-        // Check that both changes were recorded
-        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(2);
-        // Verify first change (insert)
-        expect(changes[0]).toEqual({
-            changeId: expect.any(String),
-            changeType: 'insert',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'test note',
-                noteId: note.noteId
-            }),
-        });
-        // Verify second change (update)
-        const updateChange = changes[1];
-        expect(updateChange).toEqual({
-            changeId: expect.any(String),
-            changeType: 'update',
-            timestamp: expect.any(Number),
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: note.noteId,
-            newRecord: expect.objectContaining({
-                title: 'updated note',
-                noteId: note.noteId
-            }),
-            jsonDiff: expect.any(Array),
-        });
-        // TypeScript needs this cast for type narrowing
-        expect(updateChange.jsonDiff.length).toBeGreaterThan(0);
+    describe('Restore Operations', () => {
+        it('should restore a deleted record', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            // Restore
+            const restored = await trackedTable.restore(note);
+            expect(restored.noteId).toBe(note.noteId);
+            expect(restored.title).toBe(note.title);
+            // Verify it's accessible
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toEqual(note);
+        });
+        it('should create a single add operation for restored record', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const noteId = note.noteId;
+            await trackedTable.delete(note);
+            // Count changes before restore
+            const beforeRestore = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            await trackedTable.restore(note);
+            const afterRestore = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            expect(afterRestore.length).toBe(beforeRestore.length + 1);
+            // Find the new 'add' operation from restore (should be exactly one at path "/")
+            const restoreOps = afterRestore.filter((c) => !c.supersededAt);
+            expect(restoreOps.length).toBe(1);
+            expect(restoreOps[0].op).toBe('set');
+            expect(restoreOps[0].path).toBe('/');
+            expect(restoreOps[0].value).toEqual(note);
+        });
+        it('should mark old changes as superseded after restore', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            await trackedTable.restore(note);
+            const superseded = await changeTrackingTable.list({
+                tableName: 'notes',
+                recordId: note.noteId,
+                supersededAt: { $exists: true },
+            });
+            expect(superseded.length).toBeGreaterThan(0);
+        });
     });
-    it('should not track read operations', async () => {
-        // Insert a record
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Perform read operations
-        await trackedTable.get(note.noteId);
-        await trackedTable.list();
-        await trackedTable.cursor();
-        // Only the insert should be recorded
-        const changes = await changeTrackingTable.list();
-        expect(changes.length).toBe(1);
-        expect(changes[0].changeType).toBe('insert');
+    describe('Save Operations', () => {
+        it('should route to insert for new records', async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            expect(note.noteId).toBeDefined();
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changes.length).toBeGreaterThan(0);
+            expect(changes.every((c) => c.op === 'set')).toBe(true);
+        });
+        it('should route to update for existing records', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            const initialCount = (await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId })).length;
+            note.title = 'updated';
+            await trackedTable.save(note);
+            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(allChanges.length).toBeGreaterThan(initialCount);
+        });
+        it('should restore deleted record when restoreIfDeleted is true', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            // Try to save with restoreIfDeleted option
+            const restored = await trackedTable.save(note, { restoreIfDeleted: true });
+            expect(restored.noteId).toBe(note.noteId);
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toBeDefined();
+        });
+        it('should throw error when saving deleted record without restoreIfDeleted', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            await expect(trackedTable.save(note)).rejects.toThrow('has been deleted');
+        });
+        it('should save snapshots as a single add at root path', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original', count: 1 });
+            const updatedNote = await trackedTable.save({ ...note, title: 'updated', count: 2 }, { saveAsSnapshot: true });
+            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+            expect(changes.length).toBe(2); // One for insert, one for snapshot save
+            expect(changes[0].value).toEqual(note);
+            expect(changes[1].value).toEqual(updatedNote);
+        });
+        it('should save non-snapshot updates as individual changes', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original', count: 1 });
+            await trackedTable.save({ ...note, title: 'updated', count: 2 });
+            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+            expect(changes.length).toBe(3); // One for insert, two for field updates
+            expect(changes[0].value).toEqual(note);
+            const titleChange = changes.find(c => c.path === '/title');
+            const countChange = changes.find(c => c.path === '/count');
+            expect(titleChange?.value).toBe('updated');
+            expect(countChange?.value).toBe(2);
+        });
     });
-    it('should handle snapshot changes', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Create a snapshot change directly
-        const snapshotChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'snapshot',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'snapshot note', completed: false }
-        };
-        // Apply the snapshot change
-        await trackedTable.applyChanges([snapshotChange]);
-        // Verify the record was created
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'snapshot note', completed: false });
-        // Verify the snapshot change was recorded
-        const changes = await changeTrackingTable.list({ recordId: noteId });
-        expect(changes.length).toBe(1);
-        expect(changes[0]).toEqual({
-            changeId: snapshotChange.changeId,
-            changeType: 'snapshot',
-            timestamp: snapshotChange.timestamp,
-            timestampApplied: expect.any(Number),
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: expect.objectContaining({
-                noteId,
-                title: 'snapshot note',
-                completed: false
-            })
+    describe('weakInsert Option', () => {
+        it('should use weak timestamp (1 + Math.random()) for insert with weakInsert: true', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            expect(change.createdAt).toBeGreaterThanOrEqual(1);
+            expect(change.createdAt).toBeLessThan(2); // 1 + Math.random() is between 1 and 2
+            expect(change.appliedAt).toBe(change.createdAt); // appliedAt should match createdAt for weak writes
+        });
+        it('should use normal timestamp for insert without weakInsert', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            // Normal timestamp should be much larger (performance.timeOrigin + performance.now() or Date.now())
+            expect(change.createdAt).toBeGreaterThan(1000);
+        });
+        it('should use normal timestamp for insert with weakInsert: false', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: false });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            // weakInsert: false should use normal timestamp
+            expect(change.createdAt).toBeGreaterThan(1000);
+        });
+        it('should use weak timestamp for save (new record) with weakInsert: true', async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            expect(change.createdAt).toBeGreaterThanOrEqual(1);
+            expect(change.createdAt).toBeLessThan(2);
+        });
+        it('should not affect update operations (weakInsert ignored for updates)', async () => {
+            // Insert with normal timestamp
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            const initialChange = (await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }))[0];
+            const initialTimestamp = initialChange.createdAt;
+            // Update with weakInsert - should not affect the update timestamp
+            note.title = 'updated';
+            await trackedTable.save(note, { weakInsert: true });
+            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }, { sortBy: ['createdAt'] });
+            // Should have more changes (the update)
+            expect(allChanges.length).toBeGreaterThan(1);
+            // The update changes should have normal timestamps (not weak)
+            const updateChanges = allChanges.slice(1);
+            updateChanges.forEach(change => {
+                expect(change.createdAt).toBeGreaterThan(initialTimestamp);
+                expect(change.createdAt).toBeGreaterThan(1000); // Normal timestamp
+            });
+        });
+        it('should use weak timestamp when save routes to insert (existing ID but no record)', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // Save with an ID but no existing record - this routes to _insert
+            const note = await trackedTable.save({ noteId, title: 'test' }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            expect(change.createdAt).toBeGreaterThanOrEqual(1);
+            expect(change.createdAt).toBeLessThan(2);
+        });
+        it('should work with restoreIfDeleted option', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            await trackedTable.delete(note);
+            // Restore with weakInsert - note: restore doesn't use weakInsert, but we can test the combination
+            const restored = await trackedTable.save(note, { restoreIfDeleted: true, weakInsert: true });
+            expect(restored.noteId).toBe(note.noteId);
+            // Note: restore() doesn't use _insert, so weakInsert won't affect it
+            // But the save that routes to restore should still work
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toBeDefined();
+        });
+        it('should work with saveAsSnapshot option', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            // Save as snapshot with weakInsert
+            const updated = await trackedTable.save({ ...note, title: 'updated' }, { saveAsSnapshot: true, weakInsert: true });
+            // The snapshot save is an update, so weakInsert won't affect it
+            // But we can verify the operation completed successfully
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved?.title).toBe('updated');
+        });
+        it('should allow weak writes to be superseded by normal writes', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // First, insert with weakInsert (simulating a new device creating the record)
+            const note1 = await trackedTable.insert({ noteId, title: 'weak write 1' }, { weakInsert: true });
+            const change1 = (await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }))[0];
+            expect(change1.createdAt).toBeLessThan(2);
+            expect(change1.createdAt).toBeGreaterThanOrEqual(1);
+            // Wait a bit to ensure normal timestamp is later
+            await (0, peers_sdk_1.sleep)(10);
+            // Then, update with normal write (simulating another device with authoritative data)
+            // This simulates the scenario where an existing device updates the record
+            note1.title = 'normal write';
+            await trackedTable.save(note1); // Normal save without weakInsert
+            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }, { sortBy: ['createdAt'] });
+            // Should have more than 1 change (initial insert + update changes)
+            expect(allChanges.length).toBeGreaterThan(1);
+            // The update changes should have normal timestamps
+            const updateChanges = allChanges.slice(1);
+            updateChanges.forEach(change => {
+                expect(change.createdAt).toBeGreaterThan(1000); // Normal timestamp
+            });
+            // Verify that the initial weak write has a weak timestamp
+            expect(change1.createdAt).toBeLessThan(2);
+            expect(change1.createdAt).toBeGreaterThanOrEqual(1);
+            // The final record should reflect the normal write (update takes precedence)
+            const final = await trackedTable.get(noteId);
+            expect(final?.title).toBe('normal write');
+            // Note: The initial change at path "/" may or may not be superseded depending on the update logic.
+            // The key point is that weak writes have very small timestamps (1 + Math.random()) and normal writes 
+            // have large timestamps, so when syncing between devices, the normal writes will take precedence 
+            // due to their later timestamps.
+        });
+        it('should use weak timestamp for insert called via save when recordId is provided but record does not exist', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // Save with an ID but no existing record - routes to _insert with skipDeletedCheck=true
+            const note = await trackedTable.save({ noteId, title: 'test' }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            expect(changes.length).toBe(1);
+            const change = changes[0];
+            expect(change.createdAt).toBeGreaterThanOrEqual(1);
+            expect(change.createdAt).toBeLessThan(2);
         });
     });
-    it('should list changes for a specific table', async () => {
-        // Insert a record
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Update the record
-        note.title = 'updated note';
-        await trackedTable.update(note);
-        // Delete the record
-        await trackedTable.delete(note);
-        // Use listChanges to get changes
-        const changes = await trackedTable.listChanges({}, { sortBy: ['timestamp'] });
-        // Verify we have 3 changes (insert, update, delete)
-        expect(changes.length).toBe(3);
-        expect(changes[0].changeType).toBe('insert');
-        expect(changes[1].changeType).toBe('update');
-        expect(changes[2].changeType).toBe('delete');
-        // Test filtering by changeType
-        const insertChanges = await trackedTable.listChanges({ changeType: 'insert' });
-        expect(insertChanges.length).toBe(1);
-        expect(insertChanges[0].changeType).toBe('insert');
-        // Test filtering by recordId
-        const recordChanges = await trackedTable.listChanges({ recordId: note.noteId }, { sortBy: ['timestamp'] });
-        expect(recordChanges.length).toBe(3);
-        expect(recordChanges.map(c => c.changeType)).toEqual(['insert', 'update', 'delete']);
+    describe('Read Operations', () => {
+        it('should get a record by id', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved).toEqual(note);
+        });
+        it('should list records with filters', async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1', completed: true });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2', completed: false });
+            const completed = await trackedTable.list({ completed: true });
+            expect(completed.length).toBe(1);
+            expect(completed[0].title).toBe('note1');
+        });
+        it('should count records', async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+            const count = await trackedTable.count();
+            expect(count).toBe(2);
+        });
+        it('should iterate records with cursor', async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+            const cursor = trackedTable.cursor();
+            const notes = [];
+            for await (const note of cursor) {
+                notes.push(note);
+            }
+            expect(notes.length).toBe(2);
+        });
     });
-    it('should apply new changes to a table and remove old, irrelevant changes', async () => {
-        // Create a change to insert a record
-        const noteId = (0, peers_sdk_1.newid)();
-        const insertChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'insert',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'test note' }
-        };
-        // Apply the insert change
-        await trackedTable.applyChanges([insertChange]);
-        // Verify the record was inserted
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'test note' });
-        // Create an update change
-        const updateChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'update',
-            timestamp: insertChange.timestamp + 1,
-            timestampApplied: insertChange.timestamp + 1,
-            tableName: 'notes',
-            recordId: noteId,
-            oldRecord: { noteId, title: 'test note' },
-            newRecord: { noteId, title: 'updated note', completed: true },
-            jsonDiff: [{ op: 'replace', path: '/title', value: 'updated note' },
-                { op: 'add', path: '/completed', value: true }]
-        };
-        // Apply the update change
-        await trackedTable.applyChanges([updateChange]);
-        // Verify the record was updated
-        const updatedNote = await trackedTable.get(noteId);
-        expect(updatedNote).toEqual({ noteId, title: 'updated note', completed: true });
-        // Verify the changes were recorded in the change tracking table
-        let changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(2);
-        expect(changes.map(c => c.changeType)).toEqual(['insert', 'update']);
-        // Create a delete change
-        const deleteChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'delete',
-            timestamp: insertChange.timestamp + 2,
-            timestampApplied: insertChange.timestamp + 2,
-            tableName: 'notes',
-            recordId: noteId,
-            oldRecord: { noteId, title: 'updated note', completed: true },
-        };
-        // Apply the delete change
-        await trackedTable.applyChanges([deleteChange]);
-        // Verify the record was deleted
-        const deletedNote = await trackedTable.get(noteId);
-        expect(deletedNote).toBeUndefined();
-        // Verify the delete change was recorded and removed older (and no longer applicable changes)
-        changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(1);
-        expect(changes.map(c => c.changeType)).toEqual(['delete']);
-        // reapply the insert change
-        // Create a change to insert a record
-        const insertChange2 = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'insert',
-            timestamp: insertChange.timestamp + 3,
-            timestampApplied: insertChange.timestamp + 3,
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'reinsert note' }
-        };
-        // Apply the insert change
-        await trackedTable.applyChanges([insertChange2]);
-        // Verify the insert change was recorded and removed older (and no longer applicable delete change)
-        changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changes.length).toBe(1);
-        expect(changes.map(c => c.changeType)).toEqual(['insert']);
+    describe('Change Tracking Methods', () => {
+        it('should list changes for this table', async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const changes = await trackedTable.listChanges();
+            expect(changes.length).toBeGreaterThan(0);
+            changes.forEach((c) => {
+                expect(c.tableName).toBe('notes');
+            });
+        });
+        it('should filter changes by recordId', async () => {
+            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
+            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+            const changes1 = await trackedTable.listChanges({ recordId: note1.noteId });
+            expect(changes1.every((c) => c.recordId === note1.noteId)).toBe(true);
+            const changes2 = await trackedTable.listChanges({ recordId: note2.noteId });
+            expect(changes2.every((c) => c.recordId === note2.noteId)).toBe(true);
+        });
+        it('should use cursor for changes', async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const cursor = await trackedTable.cursorChanges();
+            const changes = [];
+            for await (const change of cursor) {
+                changes.push(change);
+            }
+            expect(changes.length).toBeGreaterThan(0);
+        });
     });
-    it('should not reapply changes that have already been applied', async () => {
-        // Create a test change
-        const noteId = (0, peers_sdk_1.newid)();
-        const changeId = (0, peers_sdk_1.newid)();
-        const insertChange = {
-            changeId,
-            changeType: 'insert',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'duplicate test' }
-        };
-        // Apply the change
-        await trackedTable.applyChanges([insertChange]);
-        // Verify the record was inserted
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'duplicate test' });
-        // Try to apply the same change again
-        await trackedTable.applyChanges([insertChange]);
-        // Verify the change was only recorded once
-        const changes = await changeTrackingTable.list({ changeId });
-        expect(changes.length).toBe(1);
+    describe('Helper Methods', () => {
+        it('should identify deleted records', async () => {
+            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
+            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+            await trackedTable.delete(note1);
+            const deletedIds = await changeTrackingTable.filterToDeletedIds([note1.noteId, note2.noteId]);
+            expect(deletedIds).toContain(note1.noteId);
+            expect(deletedIds).not.toContain(note2.noteId);
+        });
+        it('should handle empty array in filterToDeletedIds', async () => {
+            const deletedIds = await changeTrackingTable.filterToDeletedIds([]);
+            expect(deletedIds).toEqual([]);
+        });
     });
-    it('should apply changes in timestamp order', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        const now = Date.now();
-        // Create changes with out-of-order timestamps
-        const changes = [
-            {
+    describe('Edge Cases', () => {
+        it('should handle insert with all optional fields', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'minimal' });
+            expect(note.completed).toBeUndefined();
+            expect(note.count).toBeUndefined();
+        });
+        it('should handle update removing optional fields', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test', completed: true, count: 5 });
+            // Update to remove optional fields
+            const updated = { noteId: note.noteId, title: 'test' };
+            await trackedTable.update(updated);
+            const retrieved = await trackedTable.get(note.noteId);
+            expect(retrieved?.title).toBe('test');
+            // The optional fields behavior depends on the underlying implementation
+        });
+        it('should handle concurrent operations on different records', async () => {
+            const promises = [];
+            for (let i = 0; i < 5; i++) {
+                promises.push(trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: `note${i}` }));
+            }
+            const notes = await Promise.all(promises);
+            expect(notes.length).toBe(5);
+            const count = await trackedTable.count();
+            expect(count).toBe(5);
+        });
+        it('should handle distributed deletion scenario', async () => {
+            // Scenario: One peer deletes a record, another peer (disconnected) makes changes
+            const noteId = (0, peers_sdk_1.newid)();
+            trackedTable.preserveHistory = true;
+            // Peer 1: Create record
+            await trackedTable.insert({ noteId, title: 'original', completed: false });
+            // Peer 1: Delete record at timestamp 2000
+            await trackedTable.delete(noteId);
+            // Peer 2: Makes changes AFTER deletion (while disconnected)
+            // Simulates this by manually inserting change records with later timestamps
+            const laterTimestamp = Date.now() + 10000; // 10 seconds later
+            // Peer 2 writes to specific paths (doesn't know about deletion)
+            const laterChange1 = {
                 changeId: (0, peers_sdk_1.newid)(),
-                changeType: 'update',
-                timestamp: now + 200,
-                timestampApplied: now + 200,
                 tableName: 'notes',
                 recordId: noteId,
-                oldRecord: { noteId, title: 'second title' },
-                newRecord: { noteId, title: 'final title' },
-                jsonDiff: [{ op: 'replace', path: '/title', value: 'final title' }]
-            },
-            {
+                op: 'set',
+                path: '/title',
+                value: 'updated by peer 2',
+                createdAt: laterTimestamp,
+                appliedAt: laterTimestamp,
+            };
+            const laterChange2 = {
                 changeId: (0, peers_sdk_1.newid)(),
-                changeType: 'insert',
-                timestamp: now,
-                timestampApplied: now,
                 tableName: 'notes',
                 recordId: noteId,
-                newRecord: { noteId, title: 'initial title' }
-            },
-            {
+                op: 'set',
+                path: '/completed',
+                value: true,
+                createdAt: laterTimestamp + 1,
+                appliedAt: laterTimestamp + 1,
+            };
+            // Apply changes from "Peer 2" - this will insert them and trigger superseding detection
+            await trackedTable.applyChanges([laterChange1, laterChange2]);
+            // Verify the record is still considered deleted (based on path "/" remove)
+            const deletedIds = await changeTrackingTable.filterToDeletedIds([noteId]);
+            expect(deletedIds).toContain(noteId);
+            // Verify the later changes are marked as superseded
+            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }, { sortBy: ['createdAt'] });
+            // Find the changes with the later timestamps (the ones we manually added)
+            const change1InDb = allChanges.find((c) => c.changeId === laterChange1.changeId);
+            const change2InDb = allChanges.find((c) => c.changeId === laterChange2.changeId);
+            // All changes after the deletion should be superseded
+            expect(change1InDb).toBeDefined();
+            expect(change1InDb?.supersededAt).toBeDefined();
+            expect(change2InDb).toBeDefined();
+            expect(change2InDb?.supersededAt).toBeDefined();
+            // Verify the record does not exist in the data source (still deleted)
+            const record = await trackedTable.get(noteId);
+            expect(record).toBeUndefined();
+        });
+        it('should handle insert with existing deleted record', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // Insert and then delete a record
+            await trackedTable.insert({ noteId, title: 'original note' });
+            await trackedTable.delete(noteId);
+            // Try to insert with same ID - should fail
+            await expect(trackedTable.insert({ noteId, title: 'new note' })).rejects.toThrow('because it has been deleted');
+        });
+        it('should handle update with missing record', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // Try to update non-existent record
+            await expect(trackedTable.update({ noteId, title: 'new note' })).rejects.toThrow('No record found to update');
+        });
+        it('should handle delete with string ID', async () => {
+            const noteId = (0, peers_sdk_1.newid)();
+            // Insert a record first
+            await trackedTable.insert({ noteId, title: 'test note' });
+            // Delete by string ID should work
+            await trackedTable.delete(noteId);
+            // Verify it was deleted
+            const note = await trackedTable.get(noteId);
+            expect(note).toBeUndefined();
+        });
+        it('should find and track untracked records', async () => {
+            // Insert records directly into the underlying data source (bypassing change tracking)
+            const note1 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 1' };
+            const note2 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 2' };
+            const note3 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 3' };
+            await sqlDataSource.insert(note1);
+            await sqlDataSource.insert(note2);
+            await sqlDataSource.insert(note3);
+            // Verify no change records exist for these
+            let changes = await changeTrackingTable.list({ tableName: 'notes' });
+            expect(changes.length).toBe(0);
+            // Run findAndTrackRecords
+            await trackedTable.findAndTrackRecords();
+            // Verify change records were created
+            changes = await changeTrackingTable.list({ tableName: 'notes' });
+            expect(changes.length).toBe(3);
+            // All should be 'set' operations at path "/"
+            changes.forEach(change => {
+                expect(change.op).toBe('set');
+                expect(change.path).toBe('/');
+                expect(change.createdAt).toBeLessThan(10); // Low timestamp
+                expect(change.appliedAt).toBeGreaterThan(Date.now() - 1000); // Recent appliedAt
+            });
+            // Verify the records themselves are accessible
+            const allNotes = await trackedTable.list();
+            expect(allNotes.length).toBe(3);
+        });
+        it('should compact superseded changes older than given timestamp', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const noteId = note.noteId;
+            // Make several updates to create multiple changes
+            await trackedTable.update({ noteId, title: 'update 1' });
+            await (0, peers_sdk_1.sleep)(10);
+            await trackedTable.update({ noteId, title: 'update 2' });
+            await (0, peers_sdk_1.sleep)(10);
+            await trackedTable.update({ noteId, title: 'update 3' });
+            await (0, peers_sdk_1.sleep)(10);
+            // Get all changes before compacting
+            const changesBefore = await changeTrackingTable.list({ recordId: noteId });
+            expect(changesBefore.length).toBeGreaterThan(1);
+            // Count superseded changes
+            const supersededBefore = changesBefore.filter(c => c.supersededAt).length;
+            expect(supersededBefore).toBeGreaterThan(0);
+            // Compact (remove all superseded changes by using future timestamp)
+            await trackedTable.compact(Date.now() + 1000);
+            // Get changes after compacting
+            const changesAfter = await changeTrackingTable.list({ recordId: noteId });
+            // Should have fewer changes now
+            expect(changesAfter.length).toBeLessThan(changesBefore.length);
+            // Should have no superseded changes left
+            const supersededAfter = changesAfter.filter(c => c.supersededAt).length;
+            expect(supersededAfter).toBe(0);
+            // Verify the record is still accessible and correct
+            const retrieved = await trackedTable.get(noteId);
+            expect(retrieved?.title).toBe('update 3');
+        });
+        it('should compact only changes superseded before given timestamp', async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+            const noteId = note.noteId;
+            // Make updates
+            await trackedTable.update({ noteId, title: 'update 1' });
+            await (0, peers_sdk_1.sleep)(10);
+            const midTimestamp = Date.now();
+            await (0, peers_sdk_1.sleep)(10);
+            await trackedTable.update({ noteId, title: 'update 2' });
+            await (0, peers_sdk_1.sleep)(10);
+            await trackedTable.update({ noteId, title: 'update 3' });
+            const changesBefore = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
+            const supersededBefore = changesBefore.filter(c => c.supersededAt).length;
+            // Compact only changes superseded before midTimestamp
+            await trackedTable.compact(midTimestamp);
+            const changesAfter = await changeTrackingTable.list({ recordId: noteId });
+            // Since all updates happen to /title, and superseding happens when the next update occurs,
+            // only changes superseded BEFORE midTimestamp will be removed.
+            // In this test, update 1 happens before midTimestamp, but is superseded by update 2 which happens AFTER midTimestamp.
+            // Therefore, no changes should be removed.
+            expect(changesAfter.length).toBe(changesBefore.length); // No changes should be removed
+            // There should still be superseded changes (the ones after midTimestamp)
+            const supersededAfter = changesAfter.filter(c => c.supersededAt).length;
+            expect(supersededAfter).toBe(supersededBefore); // Same number of superseded changes
+        });
+    });
+    describe('applyChanges', () => {
+        it('should save but supersede remote changes that are older', async () => {
+            const noteId = `000000000000000000note001`;
+            trackedTable.preserveHistory = true;
+            const note = await trackedTable.save({ noteId, title: 'original' });
+            const timeUpdatedRemote = (0, peers_sdk_1.getTimestamp)();
+            note.title = 'updated1';
+            await trackedTable.save(note);
+            const changes = await changeTrackingTable.list({ recordId: note.noteId });
+            expect(changes.length).toBe(2);
+            // Create changes to apply
+            const remoteChange = {
                 changeId: (0, peers_sdk_1.newid)(),
-                changeType: 'update',
-                timestamp: now + 100,
-                timestampApplied: now + 100,
                 tableName: 'notes',
-                recordId: noteId,
-                oldRecord: { noteId, title: 'initial title' },
-                newRecord: { noteId, title: 'second title' },
-                jsonDiff: [{ op: 'replace', path: '/title', value: 'second title' }]
-            }
-        ];
-        // Store the changeIds for verification later
-        const changeIds = {
-            insert: changes[1].changeId,
-            update1: changes[2].changeId,
-            update2: changes[0].changeId
-        };
-        // Apply the out-of-order changes
-        await trackedTable.applyChanges(changes);
-        // Verify the final state reflects the changes applied in timestamp order
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'final title' });
-        // Verify the changes were recorded in order
-        const recordedChanges = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(recordedChanges.length).toBe(3);
-        expect(recordedChanges.map(c => c.changeId)).toEqual([
-            changeIds.insert,
-            changeIds.update1,
-            changeIds.update2
-        ]);
-    });
-    it('should require a restore operation to bring a record back after being deleted', async () => {
-        // Create a change to insert a record
-        const noteId = (0, peers_sdk_1.newid)();
-        const insertChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'insert',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'test note' }
-        };
-        // Apply the insert change
-        await trackedTable.applyChanges([insertChange]);
-        // Verify the record was inserted
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'test note' });
-        // Create a delete change
-        const deleteChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'delete',
-            timestamp: insertChange.timestamp + 1,
-            timestampApplied: insertChange.timestamp + 1,
-            tableName: 'notes',
-            recordId: noteId,
-            oldRecord: { noteId, title: 'test note' }
-        };
-        // Apply the delete change
-        await trackedTable.applyChanges([deleteChange]);
-        // Verify the record was deleted
-        const deletedNote = await trackedTable.get(noteId);
-        expect(deletedNote).toBeUndefined();
-        // Create an update change
-        const updateChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'update',
-            timestamp: insertChange.timestamp + 1,
-            timestampApplied: insertChange.timestamp + 1,
-            tableName: 'notes',
-            recordId: noteId,
-            oldRecord: { noteId, title: 'test note' },
-            newRecord: { noteId, title: 'updated note', completed: true },
-            jsonDiff: [{ op: 'replace', path: '/title', value: 'updated note' },
-                { op: 'add', path: '/completed', value: true }]
-        };
-        // Apply the update change
-        await trackedTable.applyChanges([updateChange]);
-        // Verify the record was not updated
-        const updatedNote = await trackedTable.get(noteId);
-        expect(updatedNote).toBeUndefined();
-        // Create a restore change
-        const restoreChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'restore',
-            timestamp: insertChange.timestamp + 2,
-            timestampApplied: insertChange.timestamp + 2,
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'restored note' }
-        };
-        // Apply the restore change
-        await trackedTable.applyChanges([restoreChange]);
-        // Verify the record was restored
-        const restoredNote = await trackedTable.get(noteId);
-        expect(restoredNote).toEqual({ noteId, title: 'restored note' });
-    });
-    it('should correctly and efficiently apply new changes to records with a very large amount of existing writes', async () => {
-        const db2 = new local_data_source_1.DBLocal(':memory:');
-        const mockDataContext2 = {
-            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db2, NotesMetaData, notesSchema),
-            eventRegistry: {
-                getEmitter: () => ({
-                    event: { subscribe: () => { } },
-                    emit: () => { }
-                })
-            }
-        };
-        const deps2 = {
-            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db2, NotesMetaData, notesSchema),
-            eventRegistry: mockDataContext2.eventRegistry,
-        };
-        const Notes2 = new peers_sdk_1.Table(NotesMetaData, deps2);
-        const changeTrackingTable2 = new peers_sdk_1.ChangeTrackingTable({ db: db2 });
-        const trackedTable2 = new tracked_data_source_1.TrackedDataSource(Notes2, changeTrackingTable2);
-        // Create a record with a large number of changes
-        const noteId = (0, peers_sdk_1.newid)();
-        const note = { noteId, title: 'test note' };
-        const checkpointCount = 20;
-        const writesBetweenCheckpointsCount = 20;
-        let lastCheckpointTimestamp = 0;
-        let note1Deleted = false;
-        let note2Deleted = false;
-        async function save1() {
-            if (note1Deleted) {
-                await trackedTable.save(note, { restoreIfDeleted: true });
-                note1Deleted = false;
-            }
-            else {
-                await trackedTable.save(note);
-            }
-        }
-        async function save2() {
-            if (note2Deleted) {
-                await trackedTable2.save(note, { restoreIfDeleted: true });
-                note2Deleted = false;
-            }
-            else {
-                await trackedTable2.save(note);
-            }
-        }
-        for (let i = 0; i < checkpointCount; i++) {
-            for (let j = 0; j < writesBetweenCheckpointsCount; j++) {
-                note.title = `update ${i} ${j}`;
-                note.completed = (0, lodash_1.random)(0, 10) === 0;
-                if ((0, lodash_1.random)(0, 10) === 0) {
-                    note.number = (0, lodash_1.random)(0, 1000);
-                }
-                if ((0, lodash_1.random)(0, 2) === 0) {
-                    note.string = (note.string || '') + note.title;
-                    note.string = (note.string || '') + note.title;
-                    const replaceStartI = (0, lodash_1.random)(0, note.string.length - 1);
-                    const replaceEndI = (0, lodash_1.random)(replaceStartI, note.string.length - 1);
-                    note.string = note.string.replace(note.string?.substring(replaceStartI, replaceEndI), note.title);
-                }
-                if ((0, lodash_1.random)(0, 4) > 0) {
-                    note.date = new Date();
-                }
-                if ((0, lodash_1.random)(0, 10) > 0 || j === writesBetweenCheckpointsCount - 1) {
-                    await save1();
-                }
-                if ((0, lodash_1.random)(0, 10) > 0) {
-                    await save2();
-                }
-                // random delete
-                if ((0, lodash_1.random)(0, 10) === 0) {
-                    await trackedTable.delete(note);
-                    note1Deleted = true;
-                }
-                if ((0, lodash_1.random)(0, 10) === 0) {
-                    await trackedTable2.delete(note);
-                    note2Deleted = true;
-                }
-            }
-            if (note1Deleted !== note2Deleted) {
-                note.title = `checkpoint ${i}`;
-                await save1();
-                await save2();
-                note1Deleted = false;
-                note2Deleted = false;
-            }
-            let changes = await trackedTable.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
-            let changes2 = await trackedTable2.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
-            await trackedTable.applyChanges(changes2);
-            await trackedTable2.applyChanges(changes);
-            changes = await trackedTable.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
-            changes2 = await trackedTable2.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
-            expect(changes.map(c => c.changeId)).toEqual(changes2.map(c => c.changeId));
-            lastCheckpointTimestamp = changes[changes.length - 1].timestamp;
-        }
-        const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        const changes2 = await changeTrackingTable2.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changes.map(c => c.changeId)).toEqual(changes2.map(c => c.changeId));
-        const dbNote = await Notes.get(noteId);
-        expect(dbNote).toEqual(note);
-        const dbNote2 = await Notes2.get(noteId);
-        expect(dbNote2).toEqual(note);
-    });
-    it("should be able to compact changes to remain performant", async () => {
-        const db = new local_data_source_1.DBLocal(':memory:');
-        const mockDataContext3 = {
-            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema),
-            eventRegistry: {
-                getEmitter: () => ({
-                    event: { subscribe: () => { } },
-                    emit: () => { }
-                })
-            }
-        };
-        const deps3 = {
-            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db, NotesMetaData, notesSchema),
-            eventRegistry: mockDataContext3.eventRegistry,
-        };
-        const NotesTable = new peers_sdk_1.Table(NotesMetaData, deps3);
-        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db: db });
-        const trackedTable = new tracked_data_source_1.TrackedDataSource(NotesTable, changeTrackingTable);
-        // Create a record with a large number of updates
-        const noteId = (0, peers_sdk_1.newid)();
-        const note = { noteId, title: 'test note' };
-        const writesCount = 200;
-        for (let i = 0; i < writesCount; i++) {
-            note.title = `update ${i}`;
-            note.completed = (0, lodash_1.random)(0, 10) === 0;
-            if ((0, lodash_1.random)(0, 10) === 0) {
-                note.number = (0, lodash_1.random)(0, 1000);
-            }
-            if ((0, lodash_1.random)(0, 2) === 0) {
-                note.string = (note.string || '') + note.title;
-                note.string = (note.string || '') + note.title;
-                const replaceStartI = (0, lodash_1.random)(0, note.string.length - 1);
-                const replaceEndI = (0, lodash_1.random)(replaceStartI, note.string.length - 1);
-                note.string = note.string.replace(note.string?.substring(replaceStartI, replaceEndI), note.title);
-            }
-            if ((0, lodash_1.random)(0, 4) > 0) {
-                note.date = new Date();
-            }
+                recordId: note.noteId,
+                op: 'set',
+                path: '/title',
+                value: 'updated2',
+                createdAt: timeUpdatedRemote,
+                appliedAt: timeUpdatedRemote,
+            };
+            await trackedTable.applyChanges([remoteChange]);
+            const finalRecord = await trackedTable.get(note.noteId);
+            expect(finalRecord).toBeDefined();
+            expect(finalRecord?.title).toBe('updated1'); // because remote change is superseded
+            const finalChanges = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+            expect(finalChanges.length).toBe(3);
+            const remoteChangeInDb = finalChanges.find((c) => c.changeId === remoteChange.changeId);
+            expect(remoteChangeInDb).toBeDefined();
+            expect(remoteChangeInDb?.supersededAt).toBeDefined();
+        });
+        it('should replace the entire array when an item in the array is added or removed', async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'original', tags: ['tag1', 'tag2'] });
+            note.tags = ['tag1', 'tag2', 'tag3'];
             await trackedTable.save(note);
-        }
-        let dbNote = await NotesTable.get(noteId);
-        expect(dbNote).toEqual(note);
-        const changesBeforeCompact = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changesBeforeCompact.length).toBeGreaterThan(100);
-        const tenthLastChange = changesBeforeCompact[changesBeforeCompact.length - 10];
-        await trackedTable.compact(tenthLastChange.timestamp);
-        const changesAfterCompact = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
-        expect(changesAfterCompact.length).toEqual(11);
-        dbNote = await NotesTable.get(noteId);
-        expect(dbNote).toEqual(note);
-    });
-    it('should handle restore operation correctly', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Insert and then delete a record
-        await trackedTable.insert({ noteId, title: 'original note' });
-        await trackedTable.delete(noteId);
-        // Verify it's deleted
-        const deletedNote = await trackedTable.get(noteId);
-        expect(deletedNote).toBeUndefined();
-        // Restore the record
-        const restoredNote = await trackedTable.restore({ noteId, title: 'restored note' });
-        expect(restoredNote).toEqual({ noteId, title: 'restored note' });
-        // Verify it's restored
-        const retrievedNote = await trackedTable.get(noteId);
-        expect(retrievedNote).toEqual({ noteId, title: 'restored note' });
-        // Verify restore change was tracked
-        const changes = await trackedTable.listChanges({ recordId: noteId, changeType: 'restore' });
-        expect(changes.length).toBe(1);
-        expect(changes[0].changeType).toBe('restore');
-    });
-    it('should handle restore without recordId provided', async () => {
-        await expect(trackedTable.restore({ title: 'no id' })).rejects.toThrow('No recordId provided to restore');
-    });
-    it('should handle insert with existing deleted record', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Insert and then delete a record
-        await trackedTable.insert({ noteId, title: 'original note' });
-        await trackedTable.delete(noteId);
-        // Try to insert with same ID - should fail
-        await expect(trackedTable.insert({ noteId, title: 'new note' })).rejects.toThrow('because it has been deleted.  Use restore instead');
-    });
-    it('should handle save with deleted record without restore flag', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Insert and then delete a record
-        await trackedTable.insert({ noteId, title: 'original note' });
-        await trackedTable.delete(noteId);
-        // Try to save without restore flag - should fail
-        await expect(trackedTable.save({ noteId, title: 'new note' })).rejects.toThrow('because it has been deleted.  Use restore instead');
-    });
-    it('should handle update with missing record', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Try to update non-existent record
-        await expect(trackedTable.update({ noteId, title: 'new note' })).rejects.toThrow('No record found to update');
-    });
-    it('should handle delete with string ID for non-existent record', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Mock console.warn to capture the warning
-        const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
-        // Try to delete non-existent record
-        await trackedTable.delete(noteId);
-        // Verify warning was logged
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Record not found'));
-        warnSpy.mockRestore();
-    });
-    it('should handle update with no changes', async () => {
-        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
-        // Update with same data - should return unchanged
-        const result = await trackedTable.update(note);
-        expect(result).toEqual(note);
-        // Should still only have one change (the insert)
-        const changes = await trackedTable.listChanges({ recordId: note.noteId });
-        expect(changes.length).toBe(1);
-        expect(changes[0].changeType).toBe('insert');
-    });
-    it('should handle compact with default timestamp', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        const note = { noteId, title: 'test note' };
-        // Create some changes
-        await trackedTable.save(note);
-        note.title = 'updated';
-        await trackedTable.save(note);
-        // Test compact with default timestamp (should use 2 weeks ago)
-        await trackedTable.compact();
-        // Should still have changes since they're recent
-        const changes = await trackedTable.listChanges({ recordId: noteId });
-        expect(changes.length).toBeGreaterThan(0);
-    });
-    it('should handle findAndTrackRecords method', async () => {
-        // Use separate instance for isolation
-        const db = new local_data_source_1.DBLocal(':memory:');
-        const mockDataContext4 = {
-            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema),
-            eventRegistry: {
-                getEmitter: () => ({
-                    event: { subscribe: () => { } },
-                    emit: () => { }
-                })
-            }
-        };
-        const deps4 = {
-            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db, NotesMetaData, notesSchema),
-            eventRegistry: mockDataContext4.eventRegistry,
-        };
-        const NotesTable = new peers_sdk_1.Table(NotesMetaData, deps4);
-        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
-        const isolatedTrackedTable = new tracked_data_source_1.TrackedDataSource(NotesTable, changeTrackingTable);
-        // Insert some records directly to data source (bypassing tracking)
-        const note1 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 1' };
-        const note2 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 2' };
-        await NotesTable.insert(note1);
-        await NotesTable.insert(note2);
-        // Mock console.log to capture output
-        const logSpy = jest.spyOn(console, 'log').mockImplementation();
-        // Find and track records
-        await isolatedTrackedTable.findAndTrackRecords(1);
-        // Verify records were tracked
-        const changes = await isolatedTrackedTable.listChanges({ changeType: 'snapshot' });
-        expect(changes.length).toBe(2);
-        // Verify console output
-        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Found 2 new records to track in table: notes'));
-        logSpy.mockRestore();
-    });
-    it('should handle apply changes with restore after delete', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Apply delete change
-        const deleteChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'delete',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-            oldRecord: { noteId, title: 'deleted note' }
-        };
-        await trackedTable.applyChanges([deleteChange]);
-        // Apply restore change
-        const restoreChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'restore',
-            timestamp: Date.now() + 1,
-            timestampApplied: Date.now() + 1,
-            tableName: 'notes',
-            recordId: noteId,
-            newRecord: { noteId, title: 'restored note' }
-        };
-        await trackedTable.applyChanges([restoreChange]);
-        // Verify record was restored
-        const note = await trackedTable.get(noteId);
-        expect(note).toEqual({ noteId, title: 'restored note' });
-    });
-    it('should handle error cases in applyChanges', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Create a change with unsupported type
-        const unsupportedChange = {
-            changeId: (0, peers_sdk_1.newid)(),
-            changeType: 'unsupported',
-            timestamp: Date.now(),
-            timestampApplied: Date.now(),
-            tableName: 'notes',
-            recordId: noteId,
-        };
-        await expect(trackedTable.applyChanges([unsupportedChange])).rejects.toThrow('Unsupported change type');
-    });
-    it('should handle insert without primaryKey', async () => {
-        // Test insert without providing primary key
-        const result = await trackedTable.insert({ title: 'no id' });
-        expect(result.noteId).toBeDefined();
-        expect(result.title).toBe('no id');
-    });
-    it('should handle save with record that needs insert', async () => {
-        const noteId = (0, peers_sdk_1.newid)();
-        // Test save with new record (should insert)
-        const result = await trackedTable.save({ noteId, title: 'new record' });
-        expect(result).toEqual({ noteId, title: 'new record' });
-        // Verify it was inserted
-        const retrieved = await trackedTable.get(noteId);
-        expect(retrieved).toEqual({ noteId, title: 'new record' });
-    });
-    it('should handle save without primaryKey', async () => {
-        // Test save without providing primary key (should insert)
-        const result = await trackedTable.save({ title: 'no id' });
-        expect(result.noteId).toBeDefined();
-        expect(result.title).toBe('no id');
+            const changes = await changeTrackingTable.list({ recordId: note.noteId });
+            expect(changes.length).toBe(2);
+            const addTagChange = changes.find((c) => c.op === 'set' && c.path === '/tags');
+            expect(addTagChange).toBeDefined();
+            expect(addTagChange?.value).toEqual(['tag1', 'tag2', 'tag3']);
+        });
+        it('should updating two similarly named fields', async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'original', links: { a: 1, aa: 2 } });
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'set', path: '/links/aa', value: 3, createdAt: ts, appliedAt: ts },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'set', path: '/links/a', value: 4, createdAt: ts + 1, appliedAt: ts + 1 },
+            ]);
+            const dbNote = await trackedTable.get(note.noteId);
+            expect(dbNote).toBeDefined();
+            expect(dbNote?.links).toBeDefined();
+            expect(dbNote?.links?.aa).toBe(3);
+            expect(dbNote?.links?.a).toBe(4);
+        });
+        it('should apply deep changes after higher changes', async () => {
+            const noteId = `000000000000000000note001`;
+            let note = {
+                noteId,
+                title: 'original',
+            };
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
+            ]);
+            note = await trackedTable.get(noteId);
+            expect(note).toBeDefined();
+            expect(note?.links).toBeDefined();
+            expect(note?.links?.a).toBe('2');
+        });
+        it('should correctly apply and supersede changes from a single batch', async () => {
+            const noteId = `000000000000000000note001`;
+            let note = {
+                noteId,
+                title: 'original',
+            };
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/links', createdAt: ts + 3, appliedAt: ts + 3 },
+            ]);
+            note = await trackedTable.get(noteId);
+            expect(note).toBeDefined();
+            expect(note?.links).toBeUndefined();
+        });
+        it('should delete records on a delete change on path /', async () => {
+            let note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'to be deleted' });
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
+            ]);
+            note = await trackedTable.get(note.noteId);
+            expect(note).toBeUndefined();
+        });
+        it('should correctly apply and supersede changes from a single batch that includes both creating and deleting the object', async () => {
+            const noteId = `000000000000000000note001`;
+            let note = {
+                noteId,
+                title: 'original',
+            };
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/links', createdAt: ts + 3, appliedAt: ts + 3 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
+            ]);
+            note = await trackedTable.get(noteId);
+            expect(note).toBeUndefined();
+        });
+        it('should correctly apply and supersede changes from a single batch that includes both creating, deleting the object, and restoring the object', async () => {
+            const noteId = `000000000000000000note001`;
+            const note = {
+                noteId,
+                title: 'original',
+            };
+            const ts = (0, peers_sdk_1.getTimestamp)();
+            await trackedTable.applyChanges([
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 2, appliedAt: ts + 2 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
+                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts + 5, appliedAt: ts + 5 },
+            ]);
+            const dbNote = await trackedTable.get(noteId);
+            expect(dbNote).toEqual(note);
+        });
+        // // not sure we want to support this behavior
+        // it.skip('should create nested objects if they do not exist along a path', async () => {
+        //   const noteId = `000000000000000000note001`;
+        //   const note: INote = {
+        //     noteId,
+        //     title: 'original',
+        //   }
+        //   const ts = getTimestamp();
+        //   await trackedTable.applyChanges([
+        //     { changeId: newid(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
+        //     { changeId: newid(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: 1, createdAt: ts + 2, appliedAt: ts + 2 },
+        //   ]);
+        //   const dbNote = await trackedTable.get(noteId) as INote;
+        //   expect(dbNote?.links?.a).toEqual(1);
+        // });
+        it('should handle two peers adding items to an array separately (last write wins)', async () => {
+            const [changeTrackingTable, trackedTable] = await dataSourceFactory();
+            const [changeTrackingTableRemote, trackedTableRemote] = await dataSourceFactory();
+            const noteId = `000000000000000000note001`;
+            const note = await trackedTable.save({ noteId, title: 'original', tags: ['tag1', 'tag2'] });
+            await trackedTableRemote.applyChanges(await changeTrackingTable.list({ recordId: note.noteId }));
+            let noteLocal = await trackedTable.get(note.noteId);
+            let noteRemote = await trackedTableRemote.get(note.noteId);
+            expect(noteLocal).toEqual(noteRemote);
+            noteLocal.tags.push('tag3');
+            await trackedTable.save(noteLocal);
+            noteRemote.tags.push('tag4');
+            await trackedTableRemote.save(noteRemote);
+            await trackedTableRemote.applyChanges(await changeTrackingTable.list({ recordId: note.noteId }));
+            await trackedTable.applyChanges(await changeTrackingTableRemote.list({ recordId: note.noteId }));
+            noteRemote = await trackedTableRemote.get(note.noteId);
+            noteLocal = await trackedTable.get(note.noteId);
+            // changes to arrays are treated as full replacements, so last write wins
+            expect(noteRemote?.tags).toEqual(['tag1', 'tag2', 'tag4']);
+            expect(noteLocal?.tags).toEqual(['tag1', 'tag2', 'tag4']);
+        });
+        it('should treat changes to objects nested in arrays as a full replacement of the array', async () => {
+            const noteId = `000000000000000000note001`;
+            const note = { noteId, title: 'original', links: { a: [{ b: 1 }, { c: 2 }] }, };
+            const noteInserted = await trackedTable.save(note);
+            noteInserted.links.a[0].b = 2;
+            const noteUpdated = await trackedTable.save(noteInserted);
+            expect(noteUpdated).toEqual(noteInserted);
+            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
+            expect(changes.length).toBe(2);
+            const arrayChange = changes[1];
+            expect(arrayChange.path).toBe('/links/a');
+            expect(arrayChange.value).toEqual([{ b: 2 }, { c: 2 }]);
+        });
+        it('should treat changes to arrays nested in another array as a full replacement of the top array', async () => {
+            const noteId = `000000000000000000note001`;
+            const note = { noteId, title: 'original', links: { a: [[{ b: 1 }, { c: 2 }, 2], 3] }, };
+            const noteInserted = await trackedTable.save(note);
+            noteInserted.links.a[0][0].b = 2;
+            const noteUpdated = await trackedTable.save(noteInserted);
+            expect(noteUpdated).toEqual(noteInserted);
+            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
+            expect(changes.length).toBe(2);
+            const arrayChange = changes[1];
+            expect(arrayChange.path).toBe('/links/a');
+            expect(arrayChange.value).toEqual([[{ b: 2 }, { c: 2 }, 2], 3]);
+        });
     });
 });
 //# sourceMappingURL=tracked-data-source.test.js.map