@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

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

@@ -13,42 +13,37 @@ describe('coalesceTextOperations', () => {
       // Simulate typing "Hello" quickly (within 300ms)
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:2',
-          content: 'e',
-          parentId: 'alice:1', // Forms chain with previous
+          value: ['alice:1', 'e'], // Forms chain with previous
           seq: 2,
           ts: 1000.05, // 50ms later
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:3',
-          content: 'l',
-          parentId: 'alice:2', // Forms chain with previous
+          value: ['alice:2', 'l'], // Forms chain with previous
           seq: 3,
           ts: 1000.1, // 100ms from start
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:4',
-          content: 'l',
-          parentId: 'alice:3', // Forms chain with previous
+          value: ['alice:3', 'l'], // Forms chain with previous
           seq: 4,
           ts: 1000.15, // 150ms from start
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:5',
-          content: 'o',
-          parentId: 'alice:4', // Forms chain with previous
+          value: ['alice:4', 'o'], // Forms chain with previous
           seq: 5,
           ts: 1000.2, // 200ms from start
         },
@@ -56,54 +51,49 @@ describe('coalesceTextOperations', () => {
 
       const result = coalesceTextOperations(ops, { thresholdMs: 300 });
 
-      // Should coalesce into ONE operation with content="Hello"
+      // Should coalesce into ONE operation with value="Hello"
       expect(result).toHaveLength(1);
-      expect(result[0].otype).toBe('insert');
-      expect((result[0] as any).content).toBe('Hello');
+      expect(result[0].ot).toBe('insert');
+      expect((result[0] as any).value[1]).toBe('Hello');
       expect((result[0] as any).id).toBe('alice:1'); // Keep first ID
-      expect((result[0] as any).parentId).toBe(null); // Keep first parentId
+      expect((result[0] as any).value[0]).toBeNull(); // Keep first anchor (null)
     });
 
     it('should respect time threshold and create separate operations for slow typing', () => {
       // Simulate typing "He" quickly, then pause, then "llo" quickly
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:2',
-          content: 'e',
-          parentId: 'alice:1',
+          value: ['alice:1', 'e'],
           seq: 2,
           ts: 1000.05, // 50ms later - within threshold
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:3',
-          content: 'l',
-          parentId: 'alice:2',
+          value: ['alice:2', 'l'],
           seq: 3,
           ts: 1000.5, // 450ms later - EXCEEDS threshold
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:4',
-          content: 'l',
-          parentId: 'alice:3',
+          value: ['alice:3', 'l'],
           seq: 4,
           ts: 1000.55, // 50ms after 'l'
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:5',
-          content: 'o',
-          parentId: 'alice:4',
+          value: ['alice:4', 'o'],
           seq: 5,
           ts: 1000.6, // 50ms after second 'l'
         },
@@ -113,35 +103,32 @@ describe('coalesceTextOperations', () => {
 
       // Should create TWO operations: "He" and "llo"
       expect(result).toHaveLength(2);
-      expect((result[0] as any).content).toBe('He');
+      expect((result[0] as any).value[1]).toBe('He');
       expect((result[0] as any).id).toBe('alice:1');
-      expect((result[1] as any).content).toBe('llo');
+      expect((result[1] as any).value[1]).toBe('llo');
       expect((result[1] as any).id).toBe('alice:3');
     });
 
     it('should handle single character operations (no coalescence)', () => {
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:2',
-          content: 'e',
-          parentId: 'alice:1',
+          value: ['alice:1', 'e'],
           seq: 2,
           ts: 1001.5, // 1500ms later - exceeds threshold
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:3',
-          content: 'l',
-          parentId: 'alice:2',
+          value: ['alice:2', 'l'],
           seq: 3,
           ts: 1003.0, // 1500ms later - exceeds threshold
         },
@@ -151,26 +138,24 @@ describe('coalesceTextOperations', () => {
 
       // Should create THREE separate operations (no coalescence)
       expect(result).toHaveLength(3);
-      expect((result[0] as any).content).toBe('H');
-      expect((result[1] as any).content).toBe('e');
-      expect((result[2] as any).content).toBe('l');
+      expect((result[0] as any).value[1]).toBe('H');
+      expect((result[1] as any).value[1]).toBe('e');
+      expect((result[2] as any).value[1]).toBe('l');
     });
 
     it('should handle non-sequential IDs (different agents)', () => {
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'bob:1', // Different agent
-          content: 'e',
-          parentId: 'alice:1',
+          value: ['alice:1', 'e'],
           seq: 2,
           ts: 1000.05,
         },
@@ -180,33 +165,29 @@ describe('coalesceTextOperations', () => {
 
       // Should NOT coalesce (different agents)
       expect(result).toHaveLength(2);
-      expect((result[0] as any).content).toBe('H');
-      expect((result[1] as any).content).toBe('e');
+      expect((result[0] as any).value[1]).toBe('H');
+      expect((result[1] as any).value[1]).toBe('e');
     });
 
     it('should handle delete operations (flush pending inserts)', () => {
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:2',
-          content: 'e',
-          parentId: 'alice:1',
+          value: ['alice:1', 'e'],
           seq: 2,
           ts: 1000.05,
         },
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:2', length: 1 }],
-          seq: 3,
-          ts: 1000.1,
+          ot: 'delete',
+          rm: [['alice:2', 1]],
         } as any,
       ];
 
@@ -214,34 +195,31 @@ describe('coalesceTextOperations', () => {
 
       // Should flush "He" and then add the delete
       expect(result).toHaveLength(2);
-      expect(result[0].otype).toBe('insert');
-      expect((result[0] as any).content).toBe('He');
-      expect(result[1].otype).toBe('delete');
+      expect(result[0].ot).toBe('insert');
+      expect((result[0] as any).value[1]).toBe('He');
+      expect(result[1].ot).toBe('delete');
     });
 
     it('should verify _lastCharId metadata is tracked correctly', () => {
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'a',
-          parentId: null,
+          value: [null, 'a'],
           seq: 1,
           ts: 1000.0,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:2',
-          content: 'b',
-          parentId: 'alice:1',
+          value: ['alice:1', 'b'],
           seq: 2,
           ts: 1000.05,
         },
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:3',
-          content: 'c',
-          parentId: 'alice:2', // This should match _lastCharId after first merge
+          value: ['alice:2', 'c'], // This should match _lastCharId after first merge
           seq: 3,
           ts: 1000.1,
         },
@@ -251,7 +229,7 @@ describe('coalesceTextOperations', () => {
 
       // Should coalesce all three
       expect(result).toHaveLength(1);
-      expect((result[0] as any).content).toBe('abc');
+      expect((result[0] as any).value[1]).toBe('abc');
       expect((result[0] as any)._lastCharId).toBe('alice:3');
     });
   });
@@ -261,32 +239,32 @@ describe('coalesceTextOperations', () => {
       // Simulate pressing backspace 7 times (7 separate delete operations)
       const ops: TextOperation[] = [
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:7', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:7', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:6', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:6', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:5', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:5', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:4', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:4', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:3', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:3', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:2', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:2', 1]],
         } as any,
         {
-          otype: 'delete',
-          deletions: [{ id: 'alice:1', length: 1 }],
+          ot: 'delete',
+          rm: [['alice:1', 1]],
         } as any,
       ];
 
@@ -294,30 +272,30 @@ describe('coalesceTextOperations', () => {
 
       // Should merge into ONE delete operation
       expect(result).toHaveLength(1);
-      expect(result[0].otype).toBe('delete');
+      expect(result[0].ot).toBe('delete');
 
       // CRITICAL: Deletions array should be optimized (7 entries → 1 entry)
       const deleteOp = result[0] as any;
-      expect(deleteOp.deletions).toBeDefined();
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0]).toEqual({ id: 'alice:1', length: 7 });
+      expect(deleteOp.rm).toBeDefined();
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0]).toEqual(['alice:1', 7]);
     });
 
     it('should optimize deletions with gaps', () => {
       // Deletions with non-consecutive IDs (can't be fully merged)
       const ops: TextOperation[] = [
         {
-          otype: 'delete',
-          deletions: [
-            { id: 'alice:5', length: 1 },
-            { id: 'alice:4', length: 1 },
+          ot: 'delete',
+          rm: [
+            ['alice:5', 1],
+            ['alice:4', 1],
           ],
         } as any,
         {
-          otype: 'delete',
-          deletions: [
-            { id: 'alice:2', length: 1 }, // Gap! alice:3 is missing
-            { id: 'alice:1', length: 1 },
+          ot: 'delete',
+          rm: [
+            ['alice:2', 1], // Gap! alice:3 is missing
+            ['alice:1', 1],
           ],
         } as any,
       ];
@@ -326,14 +304,14 @@ describe('coalesceTextOperations', () => {
 
       // Should merge into ONE delete operation
       expect(result).toHaveLength(1);
-      expect(result[0].otype).toBe('delete');
+      expect(result[0].ot).toBe('delete');
 
       // Deletions should be optimized: [alice:4-5 (len 2), alice:1-2 (len 2)]
       const deleteOp = result[0] as any;
-      expect(deleteOp.deletions).toBeDefined();
-      expect(deleteOp.deletions).toHaveLength(2); // Two ranges due to gap
-      expect(deleteOp.deletions).toContainEqual({ id: 'alice:4', length: 2 });
-      expect(deleteOp.deletions).toContainEqual({ id: 'alice:1', length: 2 });
+      expect(deleteOp.rm).toBeDefined();
+      expect(deleteOp.rm).toHaveLength(2); // Two ranges due to gap
+      expect(deleteOp.rm).toContainEqual(['alice:4', 2]);
+      expect(deleteOp.rm).toContainEqual(['alice:1', 2]);
     });
   });
 
@@ -346,10 +324,9 @@ describe('coalesceTextOperations', () => {
     it('should handle single operation', () => {
       const ops: TextOperation[] = [
         {
-          otype: 'insert',
+          ot: 'insert',
           id: 'alice:1',
-          content: 'H',
-          parentId: null,
+          value: [null, 'H'],
           seq: 1,
           ts: 1000.0,
         },
@@ -357,7 +334,7 @@ describe('coalesceTextOperations', () => {
 
       const result = coalesceTextOperations(ops);
       expect(result).toHaveLength(1);
-      expect((result[0] as any).content).toBe('H');
+      expect((result[0] as any).value[1]).toBe('H');
     });
   });
 });

package/tests/client/compaction.test.ts

@@ -32,17 +32,17 @@ import type { CRDTMessage, Operation, SceneGraph } from '../../src/operations/Op
 
 function makeRemoteMsg(
   id: string,
-  sessionId: string,
+  client: string,
   ops: Operation[],
-  lamportTime: number,
+  lt: number,
   clock?: Record<string, number>,
 ): CRDTMessage {
   return {
     id,
-    sessionId,
-    clock: clock ?? { [sessionId]: lamportTime },
-    lamportTime,
-    timestamp: Date.now() / 1000,
+    client,
+    clock: clock ?? { [client]: lt },
+    lt,
+    ts: Date.now() / 1000,
     ops,
   };
 }
@@ -50,31 +50,31 @@ function makeRemoteMsg(
 function nodeInsertOp(parentKey: string, nodeKey: string, props: Record<string, unknown> = {}): Operation {
   return {
     key: parentKey,
-    otype: 'node.insert',
+    ot: 'node.insert',
     path: 'children',
     value: { key: nodeKey, tag: 'Mesh', name: nodeKey, ...props },
   } as Operation;
 }
 
 function vec3SetOp(nodeKey: string, path: string, value: [number, number, number]): Operation {
-  return { key: nodeKey, otype: 'vector3.set', path, value } as Operation;
+  return { key: nodeKey, ot: 'vector3.set', path, value } as Operation;
 }
 
 function numSetOp(nodeKey: string, path: string, value: number): Operation {
-  return { key: nodeKey, otype: 'number.set', path, value } as Operation;
+  return { key: nodeKey, ot: 'number.set', path, value } as Operation;
 }
 
 function numAddOp(nodeKey: string, path: string, value: number): Operation {
-  return { key: nodeKey, otype: 'number.add', path, value } as Operation;
+  return { key: nodeKey, ot: 'number.add', path, value } as Operation;
 }
 
 function nodeRemoveOp(parentKey: string, nodeKey: string): Operation {
-  return { key: parentKey, otype: 'node.remove', path: 'children', value: nodeKey } as Operation;
+  return { key: parentKey, ot: 'node.remove', path: 'children', value: nodeKey } as Operation;
 }
 
 /** Set up a state with a scene root + cube node */
-function setupState(sessionId = 'test-session'): ClientState {
-  let s = createInitialState(sessionId);
+function setupState(client = 'test-session'): ClientState {
+  let s = createInitialState(client);
   s = onEdit(s, nodeInsertOp('', 'scene', { tag: 'Scene' }));
   const { state: s1, msg: m1 } = commitEdits(s);
   s = onServerAck(s1, m1!.id);
@@ -214,12 +214,12 @@ describe('Client compact() (Issue #50)', () => {
     s = commitAndAck(s, vec3SetOp('cube', 'position', [1, 2, 3]));
     s = commitAndAck(s, numSetOp('cube', 'opacity', 0.5));
 
-    const lamportBefore = s.snapshot.lamportTime;
+    const lamportBefore = s.snapshot.lt;
     const indexBefore = s.snapshot.journalIndex;
 
     s = compact(s);
 
-    expect(s.snapshot.lamportTime).toBeGreaterThan(lamportBefore);
+    expect(s.snapshot.lt).toBeGreaterThan(lamportBefore);
     expect(s.snapshot.journalIndex).toBeGreaterThan(indexBefore);
   });
 
@@ -346,7 +346,7 @@ describe('initFromServer (state transfer)', () => {
     const emptySnapshot = {
       graph: createEmptyGraph(),
       vectorClock: {},
-      lamportTime: 0,
+      lt: 0,
       journalIndex: 0,
     };
 
@@ -409,7 +409,7 @@ describe('initFromServer (state transfer)', () => {
     const emptySnapshot = {
       graph: createEmptyGraph(),
       vectorClock: {},
-      lamportTime: 0,
+      lt: 0,
       journalIndex: 0,
     };
 
@@ -423,7 +423,7 @@ describe('initFromServer (state transfer)', () => {
     // new-client's clock should include alice and bob
     expect(state.vectorClock['alice']).toBeGreaterThanOrEqual(2);
     expect(state.vectorClock['bob']).toBeGreaterThanOrEqual(1);
-    expect(state.lamportTime).toBeGreaterThanOrEqual(3);
+    expect(state.lt).toBeGreaterThanOrEqual(3);
   });
 });