@vuer-ai/vuer-rtc 0.4.2 → 0.5.1

package/tests/client/coalesce-text-operations.test.ts

@@ -0,0 +1,326 @@
+/**
+ * Tests for coalesceTextOperations - verifying the bug fix for multi-character coalescence
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { coalesceTextOperations } from '../../src/client/coalesceTextOperations.js';
+import type { TextOperation } from '../../src/client/textTypes.js';
+import type { InsertOp } from '../../src/crdt/Rope.js';
+
+describe('coalesceTextOperations', () => {
+  describe('multi-character coalescence (bug fix verification)', () => {
+    it('should coalesce ALL consecutive characters within threshold, not just pairs', () => {
+      // Simulate typing "Hello" quickly (within 300ms)
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:2',
+            content: 'e',
+            parentId: 'alice:1', // Forms chain with previous
+            seq: 2,
+            ts: 1000.05, // 50ms later
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:3',
+            content: 'l',
+            parentId: 'alice:2', // Forms chain with previous
+            seq: 3,
+            ts: 1000.1, // 100ms from start
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:4',
+            content: 'l',
+            parentId: 'alice:3', // Forms chain with previous
+            seq: 4,
+            ts: 1000.15, // 150ms from start
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:5',
+            content: 'o',
+            parentId: 'alice:4', // Forms chain with previous
+            seq: 5,
+            ts: 1000.2, // 200ms from start
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should coalesce into ONE operation with content="Hello"
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('insert');
+      expect((result[0] as any).op.content).toBe('Hello');
+      expect((result[0] as any).op.id).toBe('alice:1'); // Keep first ID
+      expect((result[0] as any).op.parentId).toBe(null); // Keep first parentId
+    });
+
+    it('should respect time threshold and create separate operations for slow typing', () => {
+      // Simulate typing "He" quickly, then pause, then "llo" quickly
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:2',
+            content: 'e',
+            parentId: 'alice:1',
+            seq: 2,
+            ts: 1000.05, // 50ms later - within threshold
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:3',
+            content: 'l',
+            parentId: 'alice:2',
+            seq: 3,
+            ts: 1000.5, // 450ms later - EXCEEDS threshold
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:4',
+            content: 'l',
+            parentId: 'alice:3',
+            seq: 4,
+            ts: 1000.55, // 50ms after 'l'
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:5',
+            content: 'o',
+            parentId: 'alice:4',
+            seq: 5,
+            ts: 1000.6, // 50ms after second 'l'
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should create TWO operations: "He" and "llo"
+      expect(result).toHaveLength(2);
+      expect((result[0] as any).op.content).toBe('He');
+      expect((result[0] as any).op.id).toBe('alice:1');
+      expect((result[1] as any).op.content).toBe('llo');
+      expect((result[1] as any).op.id).toBe('alice:3');
+    });
+
+    it('should handle single character operations (no coalescence)', () => {
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:2',
+            content: 'e',
+            parentId: 'alice:1',
+            seq: 2,
+            ts: 1001.5, // 1500ms later - exceeds threshold
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:3',
+            content: 'l',
+            parentId: 'alice:2',
+            seq: 3,
+            ts: 1003.0, // 1500ms later - exceeds threshold
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should create THREE separate operations (no coalescence)
+      expect(result).toHaveLength(3);
+      expect((result[0] as any).op.content).toBe('H');
+      expect((result[1] as any).op.content).toBe('e');
+      expect((result[2] as any).op.content).toBe('l');
+    });
+
+    it('should handle non-sequential IDs (different agents)', () => {
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'bob:1', // Different agent
+            content: 'e',
+            parentId: 'alice:1',
+            seq: 2,
+            ts: 1000.05,
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should NOT coalesce (different agents)
+      expect(result).toHaveLength(2);
+      expect((result[0] as any).op.content).toBe('H');
+      expect((result[1] as any).op.content).toBe('e');
+    });
+
+    it('should handle delete operations (flush pending inserts)', () => {
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:2',
+            content: 'e',
+            parentId: 'alice:1',
+            seq: 2,
+            ts: 1000.05,
+          },
+        },
+        {
+          type: 'delete',
+          op: {
+            deletions: [{ id: 'alice:2', length: 1 }],
+            seq: 3,
+            ts: 1000.1,
+          },
+        } as any,
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should flush "He" and then add the delete
+      expect(result).toHaveLength(2);
+      expect(result[0].type).toBe('insert');
+      expect((result[0] as any).op.content).toBe('He');
+      expect(result[1].type).toBe('delete');
+    });
+
+    it('should verify _lastCharId metadata is tracked correctly', () => {
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'a',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:2',
+            content: 'b',
+            parentId: 'alice:1',
+            seq: 2,
+            ts: 1000.05,
+          },
+        },
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:3',
+            content: 'c',
+            parentId: 'alice:2', // This should match _lastCharId after first merge
+            seq: 3,
+            ts: 1000.1,
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+      // Should coalesce all three
+      expect(result).toHaveLength(1);
+      expect((result[0] as any).op.content).toBe('abc');
+      expect((result[0] as any).op._lastCharId).toBe('alice:3');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty operations array', () => {
+      const result = coalesceTextOperations([]);
+      expect(result).toHaveLength(0);
+    });
+
+    it('should handle single operation', () => {
+      const ops: TextOperation[] = [
+        {
+          type: 'insert',
+          op: {
+            id: 'alice:1',
+            content: 'H',
+            parentId: null,
+            seq: 1,
+            ts: 1000.0,
+          },
+        },
+      ];
+
+      const result = coalesceTextOperations(ops);
+      expect(result).toHaveLength(1);
+      expect((result[0] as any).op.content).toBe('H');
+    });
+  });
+});

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);