@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

package/tests/client/delete-coalescence-bug.test.ts

@@ -34,9 +34,9 @@ describe('Delete Coalescence Bug', () => {
       const deleteOp = remove(rope, 0, 5);
 
       // FIXED: Now we get 1 deletion with length 5 instead of 5 separate deletions!
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0].length).toBe(5);
-      expect(deleteOp.deletions[0].id).toMatch(/alice:\d+/);
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0][1]).toBe(5);
+      expect(deleteOp.rm[0][0]).toMatch(/alice:\d+/);
 
       // This is efficient - we're sending 1 deletion entry instead of 5
     });
@@ -59,11 +59,11 @@ describe('Delete Coalescence Bug', () => {
       const delete5 = remove(rope, 0, 1); // Delete 'H'
 
       // Each delete creates 1 deletion entry (expected - only deleting 1 char each time)
-      expect(delete1.deletions).toHaveLength(1);
-      expect(delete2.deletions).toHaveLength(1);
-      expect(delete3.deletions).toHaveLength(1);
-      expect(delete4.deletions).toHaveLength(1);
-      expect(delete5.deletions).toHaveLength(1);
+      expect(delete1.rm).toHaveLength(1);
+      expect(delete2.rm).toHaveLength(1);
+      expect(delete3.rm).toHaveLength(1);
+      expect(delete4.rm).toHaveLength(1);
+      expect(delete5.rm).toHaveLength(1);
 
       // Note: These are 5 separate delete OPERATIONS, each with 1 deletion
       // Operation-level coalescence (in coalesceTextOperations) will merge these
@@ -78,9 +78,9 @@ describe('Delete Coalescence Bug', () => {
 
       // Simulate receiving a coalesced operation from Alice
       const coalescedOp: InsertOp = {
+        ot: 'insert',
         id: 'alice:1',
-        content: 'Hello',
-        parentId: null,
+        value: [null, 'Hello'],
         seq: 1,
         ts: 1000.0,
       };
@@ -93,9 +93,9 @@ describe('Delete Coalescence Bug', () => {
       const deleteOp = remove(rope, 0, 5);
 
       // GOOD: Only 1 deletion with length 5 (because it's a single item)
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0].id).toBe('alice:1');
-      expect(deleteOp.deletions[0].length).toBe(5);
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0][0]).toBe('alice:1');
+      expect(deleteOp.rm[0][1]).toBe(5);
     });
   });
 
@@ -117,13 +117,13 @@ describe('Delete Coalescence Bug', () => {
 
       // Coalescence merged 5 ops into 1 op
       expect(coalesced).toHaveLength(1);
-      expect((coalesced[0] as any).content).toBe('Hello');
+      expect((coalesced[0] as any).value[1]).toBe('Hello');
 
       // The local rope still has 5 separate items (coalescence doesn't modify the rope)
       // BUT remove() now optimizes the deletions array!
       const deleteOp = remove(rope, 0, 5);
-      expect(deleteOp.deletions).toHaveLength(1); // FIXED: 1 deletion instead of 5!
-      expect(deleteOp.deletions[0].length).toBe(5);
+      expect(deleteOp.rm).toHaveLength(1); // FIXED: 1 deletion instead of 5!
+      expect(deleteOp.rm[0][1]).toBe(5);
 
       // This is the fix: even though rope has 5 items, remove() merges consecutive
       // deletions from the same agent into a single deletion entry
@@ -144,9 +144,9 @@ describe('Delete Coalescence Bug', () => {
       // Delete all 5 characters
       const deleteOp = remove(rope, 0, 5);
 
-      // FIXED: deletions = [{id: alice:0, len:5}] (merged consecutive IDs)
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0].length).toBe(5);
+      // FIXED: deletions = [['alice:0', 5]] (merged consecutive IDs)
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0][1]).toBe(5);
     });
 
     it('should handle mixed local and remote items correctly', () => {
@@ -158,9 +158,9 @@ describe('Delete Coalescence Bug', () => {
 
       // Bob types "ey" (received as coalesced op)
       const bobOp: InsertOp = {
+        ot: 'insert',
         id: 'bob:1',
-        content: 'ey',
-        parentId: 'alice:1',
+        value: ['alice:1', 'ey'],
         seq: 3,
         ts: 1000.0,
       };
@@ -178,14 +178,14 @@ describe('Delete Coalescence Bug', () => {
       // FIXED: 2 deletions (can't merge across agents, but alice's chars are merged)
       // - alice:0-1 merged → 1 deletion with length 2
       // - bob:1 → 1 deletion with length 2
-      expect(deleteOp.deletions).toHaveLength(2);
+      expect(deleteOp.rm).toHaveLength(2);
 
       // Both deletions should be multi-char
-      expect(deleteOp.deletions[0].length).toBe(2);
-      expect(deleteOp.deletions[1].length).toBe(2);
+      expect(deleteOp.rm[0][1]).toBe(2);
+      expect(deleteOp.rm[1][1]).toBe(2);
 
       // One from alice, one from bob
-      const agents = deleteOp.deletions.map(d => d.id.split(':')[0]);
+      const agents = deleteOp.rm.map(d => d[0].split(':')[0]);
       expect(agents).toContain('alice');
       expect(agents).toContain('bob');
     });
@@ -206,9 +206,9 @@ describe('Delete Coalescence Bug', () => {
       const deleteOp = remove(rope, 0, 7);
 
       // FIXED: Creates 1 deletion entry with length 7
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0].length).toBe(7);
-      expect(deleteOp.deletions[0].id).toMatch(/Alice:\d+/);
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0][1]).toBe(7);
+      expect(deleteOp.rm[0][0]).toMatch(/Alice:\d+/);
 
       // This is now efficient - 1 deletion entry instead of 7
     });
@@ -233,17 +233,17 @@ describe('Delete Coalescence Bug', () => {
 
       // Operation-level coalescence works: 7 ops → 1 op
       expect(coalesced).toHaveLength(1);
-      expect(coalesced[0].otype).toBe('delete');
+      expect(coalesced[0].ot).toBe('delete');
 
       // FIXED in v0.5.4: coalesceTextOperations now sorts and optimizes deletions!
       // Each individual remove() creates 1 deletion (only deleting 1 char)
       // When coalesceTextOperations merges the 7 ops, it:
-      // 1. Combines the deletions arrays: [{id:Alice:6,len:1}, ..., {id:Alice:0,len:1}]
-      // 2. Sorts them: [{id:Alice:0,len:1}, ..., {id:Alice:6,len:1}]
-      // 3. Optimizes them: [{id:Alice:0,len:7}]
+      // 1. Combines the deletions arrays: [['Alice:6',1], ..., ['Alice:0',1]]
+      // 2. Sorts them: [['Alice:0',1], ..., ['Alice:6',1]]
+      // 3. Optimizes them: [['Alice:0',7]]
       const coalescedOp = coalesced[0] as any;
-      expect(coalescedOp.deletions).toHaveLength(1);
-      expect(coalescedOp.deletions[0]).toEqual({ id: 'Alice:0', length: 7 });
+      expect(coalescedOp.rm).toHaveLength(1);
+      expect(coalescedOp.rm[0]).toEqual(['Alice:0', 7]);
     });
   });
 });

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

@@ -105,7 +105,7 @@ describe('EditBuffer', () => {
       const buffer = new EditBufferImpl();
       buffer.add({
         key: 'cube-1',
-        otype: 'number.set',
+        ot: 'number.set',
         path: 'opacity',
         value: 0.5,
       });
@@ -119,26 +119,24 @@ describe('EditBuffer', () => {
     it('should NOT coalesce text inserts with CRDT metadata', () => {
       const ops: Operation[] = [
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 0,
-          value: 'a',
-          id: { agent: 'session-1', seq: 1 },
-          content: 'a',
-          parentId: null,
+          value: [null, 'a'],
+          id: 'session-1:1',
           seq: 1,
+          ts: 1000.0,
         } as any,
         {
-          otype: 'text.insert',
+          ot: '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 },
+          value: ['session-1:1', 'b'],
+          id: 'session-1:2',
           seq: 2,
+          ts: 1000.0,
         } as any,
       ];
 
@@ -146,23 +144,23 @@ describe('EditBuffer', () => {
 
       // 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');
+      expect((result[0] as any).id).toBe('session-1:1');
+      expect((result[0] as any).value[1]).toBe('a');
+      expect((result[1] as any).id).toBe('session-1:2');
+      expect((result[1] as any).value[1]).toBe('b');
     });
 
     it('should coalesce position-based text inserts without CRDT metadata', () => {
       const ops: Operation[] = [
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 0,
           value: 'a',
         } as any,
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 1,
@@ -182,20 +180,20 @@ describe('EditBuffer', () => {
     it('should NOT coalesce text deletes with CRDT metadata', () => {
       const ops: Operation[] = [
         {
-          otype: 'text.delete',
+          ot: 'text.delete',
           key: 'text-doc',
           path: 'content',
           position: 0,
           length: 1,
-          deletions: [{ id: { agent: 'session-1', seq: 1 }, length: 1 }],
+          value: [['session-1:1', 1]],
         } as any,
         {
-          otype: 'text.delete',
+          ot: 'text.delete',
           key: 'text-doc',
           path: 'content',
           position: 0,
           length: 1,
-          deletions: [{ id: { agent: 'session-1', seq: 2 }, length: 1 }],
+          value: [['session-1:2', 1]],
         } as any,
       ];
 
@@ -203,32 +201,31 @@ describe('EditBuffer', () => {
 
       // 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 }]);
+      expect((result[0] as any).value).toEqual([['session-1:1', 1]]);
+      expect((result[1] as any).value).toEqual([['session-1:2', 1]]);
     });
 
     it('should preserve CRDT metadata through mixed operations', () => {
       const ops: Operation[] = [
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 0,
           value: 'hello',
         } as any,
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 5,
           value: ' ',
-          id: { agent: 'session-1', seq: 1 },
-          content: ' ',
-          parentId: null,
+          id: 'session-1:1',
           seq: 1,
+          ts: 1000.0,
         } as any,
         {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: 'text-doc',
           path: 'content',
           position: 6,
@@ -245,7 +242,7 @@ describe('EditBuffer', () => {
       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[1] as any).id).toBe('session-1:1');
       expect((result[2] as any).value).toBe('world');
       expect((result[2] as any).id).toBeUndefined();
     });