@vuer-ai/vuer-rtc 0.4.2 → 0.5.0

package/tests/client/edit-buffer.test.ts

@@ -6,7 +6,7 @@ import { describe, it, expect } from '@jest/globals';
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { isAdditiveOp, mergeValues, EditBufferImpl } from '../../src/client/EditBuffer.js';
+import { isAdditiveOp, mergeValues, EditBufferImpl, coalesceTextOps } from '../../src/client/EditBuffer.js';
 import type { Operation } from '../../src/operations/OperationTypes.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -114,4 +114,140 @@ describe('EditBuffer', () => {
       expect(buffer.getOps()).toHaveLength(0);
     });
   });
+
+  describe('coalesceTextOps', () => {
+    it('should NOT coalesce text inserts with CRDT metadata', () => {
+      const ops: Operation[] = [
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          value: 'a',
+          id: { agent: 'session-1', seq: 1 },
+          content: 'a',
+          parentId: null,
+          seq: 1,
+        } as any,
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 1,
+          value: 'b',
+          id: { agent: 'session-1', seq: 2 },
+          content: 'b',
+          parentId: { agent: 'session-1', seq: 1 },
+          seq: 2,
+        } as any,
+      ];
+
+      const result = coalesceTextOps(ops);
+
+      // Should NOT coalesce - each operation keeps its CRDT metadata
+      expect(result).toHaveLength(2);
+      expect((result[0] as any).id).toEqual({ agent: 'session-1', seq: 1 });
+      expect((result[0] as any).value).toBe('a');
+      expect((result[1] as any).id).toEqual({ agent: 'session-1', seq: 2 });
+      expect((result[1] as any).value).toBe('b');
+    });
+
+    it('should coalesce position-based text inserts without CRDT metadata', () => {
+      const ops: Operation[] = [
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          value: 'a',
+        } as any,
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 1,
+          value: 'b',
+        } as any,
+      ];
+
+      const result = coalesceTextOps(ops);
+
+      // Should coalesce position-based operations
+      expect(result).toHaveLength(1);
+      expect((result[0] as any).position).toBe(0);
+      expect((result[0] as any).value).toBe('ab');
+      expect((result[0] as any).id).toBeUndefined();
+    });
+
+    it('should NOT coalesce text deletes with CRDT metadata', () => {
+      const ops: Operation[] = [
+        {
+          otype: 'text.delete',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          length: 1,
+          deletions: [{ id: { agent: 'session-1', seq: 1 }, length: 1 }],
+        } as any,
+        {
+          otype: 'text.delete',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          length: 1,
+          deletions: [{ id: { agent: 'session-1', seq: 2 }, length: 1 }],
+        } as any,
+      ];
+
+      const result = coalesceTextOps(ops);
+
+      // Should NOT coalesce - each operation keeps its CRDT metadata
+      expect(result).toHaveLength(2);
+      expect((result[0] as any).deletions).toEqual([{ id: { agent: 'session-1', seq: 1 }, length: 1 }]);
+      expect((result[1] as any).deletions).toEqual([{ id: { agent: 'session-1', seq: 2 }, length: 1 }]);
+    });
+
+    it('should preserve CRDT metadata through mixed operations', () => {
+      const ops: Operation[] = [
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          value: 'hello',
+        } as any,
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 5,
+          value: ' ',
+          id: { agent: 'session-1', seq: 1 },
+          content: ' ',
+          parentId: null,
+          seq: 1,
+        } as any,
+        {
+          otype: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          position: 6,
+          value: 'world',
+        } as any,
+      ];
+
+      const result = coalesceTextOps(ops);
+
+      // First "hello" should be alone (position-based, coalesced)
+      // Second " " should be alone (has CRDT metadata)
+      // Third "world" should be alone (position-based but not adjacent to first)
+      expect(result).toHaveLength(3);
+      expect((result[0] as any).value).toBe('hello');
+      expect((result[0] as any).id).toBeUndefined();
+      expect((result[1] as any).value).toBe(' ');
+      expect((result[1] as any).id).toEqual({ agent: 'session-1', seq: 1 });
+      expect((result[2] as any).value).toBe('world');
+      expect((result[2] as any).id).toBeUndefined();
+    });
+  });
 });

package/tests/crdt/graph-text-crdt.test.ts

@@ -96,10 +96,11 @@ describe('GraphTextCRDT', () => {
     it('should return InsertOp with CRDT metadata', () => {
       const op = crdt.insertLocal('node-1', 'content', 0, 'test');
       expect(op.id).toBeDefined();
-      expect(op.id.agent).toBe('session-1');
-      expect(op.id.seq).toBeDefined();
+      expect(typeof op.id).toBe('string');
+      expect(op.id).toMatch(/^session-1:/); // String format: "agent:seq"
       expect(op.content).toBe('test');
       expect(op.seq).toBeDefined();
+      expect(op.ts).toBeDefined();
     });
 
     it('should handle multiple sequential inserts', () => {
@@ -112,7 +113,7 @@ describe('GraphTextCRDT', () => {
     it('should auto-create rope if not initialized', () => {
       const op = crdt.insertLocal('node-2', 'title', 0, 'New Title');
       expect(crdt.getText('node-2', 'title')).toBe('New Title');
-      expect(op.id.agent).toBe('session-1');
+      expect(op.id).toMatch(/^session-1:/);
     });
   });
 
@@ -216,10 +217,11 @@ describe('GraphTextCRDT', () => {
 
     it('should apply remote insert operation', () => {
       const op: InsertOp = {
-        id: { agent: 'session-2', seq: 0 },
+        id: 'session-2:0',
         content: 'Hello',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt.applyInsert('node-1', 'content', op);
       expect(crdt.getText('node-1', 'content')).toBe('Hello');
@@ -227,18 +229,20 @@ describe('GraphTextCRDT', () => {
 
     it('should apply remote insert with parent', () => {
       const op1: InsertOp = {
-        id: { agent: 'session-1', seq: 0 },
+        id: 'session-1:0',
         content: 'Hello',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt.applyInsert('node-1', 'content', op1);
 
       const op2: InsertOp = {
-        id: { agent: 'session-2', seq: 0 },
+        id: 'session-2:0',
         content: ' World',
-        parentId: { agent: 'session-1', seq: 4 },
+        parentId: 'session-1:4',
         seq: 2,
+        ts: Date.now() / 1000,
       };
       crdt.applyInsert('node-1', 'content', op2);
       expect(crdt.getText('node-1', 'content')).toBe('Hello World');
@@ -246,10 +250,11 @@ describe('GraphTextCRDT', () => {
 
     it('should auto-create rope if not initialized', () => {
       const op: InsertOp = {
-        id: { agent: 'session-2', seq: 0 },
+        id: 'session-2:0',
         content: 'test',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt.applyInsert('node-2', 'title', op);
       expect(crdt.getText('node-2', 'title')).toBe('test');
@@ -259,10 +264,11 @@ describe('GraphTextCRDT', () => {
       const op1 = crdt.insertLocal('node-1', 'content', 0, 'A');
 
       const op2: InsertOp = {
-        id: { agent: 'session-2', seq: 0 },
+        id: 'session-2:0',
         content: 'B',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt.applyInsert('node-1', 'content', op2);
 
@@ -301,7 +307,7 @@ describe('GraphTextCRDT', () => {
 
     it('should auto-create rope if not initialized', () => {
       const op: DeleteOp = {
-        deletions: [{ id: { agent: 'session-1', seq: 0 }, length: 5 }],
+        deletions: [{ id: 'session-1:0', length: 5 }],
       };
       crdt.applyDelete('node-2', 'title', op);
       expect(crdt.getText('node-2', 'title')).toBe('');
@@ -311,7 +317,7 @@ describe('GraphTextCRDT', () => {
       const delOp = crdt.deleteLocal('node-1', 'content', 0, 5);
 
       const remoteOp: DeleteOp = {
-        deletions: [{ id: { agent: 'session-1', seq: 5 }, length: 6 }],
+        deletions: [{ id: 'session-1:5', length: 6 }],
       };
       crdt.applyDelete('node-1', 'content', remoteOp);
 
@@ -336,10 +342,11 @@ describe('GraphTextCRDT', () => {
           deletions: [{ id: items[0].id, length: 5 }],
         },
         insert: {
-          id: { agent: 'session-2', seq: 0 },
+          id: 'session-2:0',
           content: 'Hi',
           parentId: null,
           seq: 2,
+          ts: Date.now() / 1000,
         },
       };
       crdt.applyReplace('node-1', 'content', op);
@@ -355,10 +362,11 @@ describe('GraphTextCRDT', () => {
           deletions: [{ id: items[0].id, length: 6 }],
         },
         insert: {
-          id: { agent: 'session-2', seq: 0 },
+          id: 'session-2:0',
           content: '',
           parentId: null,
           seq: 2,
+          ts: Date.now() / 1000,
         },
       };
       crdt.applyReplace('node-1', 'content', op);
@@ -369,10 +377,11 @@ describe('GraphTextCRDT', () => {
       const op: ReplaceOp = {
         delete: { deletions: [] },
         insert: {
-          id: { agent: 'session-2', seq: 0 },
+          id: 'session-2:0',
           content: 'new',
           parentId: null,
           seq: 1,
+          ts: Date.now() / 1000,
         },
       };
       crdt.applyReplace('node-2', 'title', op);
@@ -562,10 +571,11 @@ describe('GraphTextCRDT', () => {
 
       // Initialize both from the same initial state
       const initOp: InsertOp = {
-        id: { agent: 'init', seq: 0 },
+        id: 'init:0',
         content: 'Hello',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt1.applyInsert('doc-1', 'content', initOp);
       crdt2.applyInsert('doc-1', 'content', initOp);
@@ -590,10 +600,11 @@ describe('GraphTextCRDT', () => {
 
       // Initialize from same initial state
       const initOp: InsertOp = {
-        id: { agent: 'init', seq: 0 },
+        id: 'init:0',
         content: 'ABCDEF',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt1.applyInsert('doc-1', 'content', initOp);
       crdt2.applyInsert('doc-1', 'content', initOp);
@@ -615,10 +626,11 @@ describe('GraphTextCRDT', () => {
 
       // Initialize from same initial state
       const initOp: InsertOp = {
-        id: { agent: 'init', seq: 0 },
+        id: 'init:0',
         content: 'test',
         parentId: null,
         seq: 1,
+        ts: Date.now() / 1000,
       };
       crdt1.applyInsert('doc-1', 'content', initOp);
       crdt2.applyInsert('doc-1', 'content', initOp);

package/tests/crdt/rope.test.ts

@@ -24,6 +24,7 @@ import {
   getStats,
   itemIdEquals,
   itemIdCompare,
+  parseItemId,
   toRaw,
   fromRaw,
   hydrateRope,
@@ -276,28 +277,28 @@ describe('TextRope', () => {
 
   describe('ItemId Utilities', () => {
     it('should compare equal ItemIds', () => {
-      const id1: ItemId = { agent: 'a', seq: 1 };
-      const id2: ItemId = { agent: 'a', seq: 1 };
+      const id1: ItemId = 'a:1';
+      const id2: ItemId = 'a:1';
       expect(itemIdEquals(id1, id2)).toBe(true);
     });
 
     it('should compare different ItemIds', () => {
-      const id1: ItemId = { agent: 'a', seq: 1 };
-      const id2: ItemId = { agent: 'a', seq: 2 };
+      const id1: ItemId = 'a:1';
+      const id2: ItemId = 'a:2';
       expect(itemIdEquals(id1, id2)).toBe(false);
     });
 
     it('should handle null ItemIds', () => {
-      const id1: ItemId = { agent: 'a', seq: 1 };
+      const id1: ItemId = 'a:1';
       expect(itemIdEquals(null, null)).toBe(true);
       expect(itemIdEquals(id1, null)).toBe(false);
       expect(itemIdEquals(null, id1)).toBe(false);
     });
 
     it('should compare ItemIds for ordering', () => {
-      const id1: ItemId = { agent: 'a', seq: 1 };
-      const id2: ItemId = { agent: 'b', seq: 1 };
-      const id3: ItemId = { agent: 'a', seq: 2 };
+      const id1: ItemId = 'a:1';
+      const id2: ItemId = 'b:1';
+      const id3: ItemId = 'a:2';
 
       expect(itemIdCompare(id1, id2)).toBeLessThan(0);
       expect(itemIdCompare(id2, id1)).toBeGreaterThan(0);
@@ -384,7 +385,7 @@ describe('TextRope', () => {
 
     it('should return -1 for non-existent ID', () => {
       const rope = create('agent-1');
-      const index = findItemById(rope, { agent: 'unknown', seq: 999 });
+      const index = findItemById(rope, 'unknown:999');
       expect(index).toBe(-1);
     });
   });
@@ -1090,7 +1091,7 @@ describe('TextRope', () => {
       apply(rope1, ins2);
       apply(rope2, ins1);
       // Also need to sync the delete
-      const delOp = { deletions: [{ id: { agent: 'agent-1', seq: 2 }, length: 2 }] };
+      const delOp = { deletions: [{ id: 'agent-1:2', length: 2 }] };
       applyDelete(rope2, delOp);
 
       expect(getText(rope1)).toBe(getText(rope2));
@@ -1305,7 +1306,8 @@ describe('TextRope', () => {
 
       // New inserts should have seq > maxSeq
       const newOp = insert(restored, 4, ' more');
-      expect(newOp.id.seq).toBeGreaterThan(expectedMaxSeq);
+      const parsed = parseItemId(newOp.id);
+      expect(parsed.seq).toBeGreaterThan(expectedMaxSeq);
     });
   });
 });