@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

package/tests/client/graph-coalescence-phase1.test.ts

@@ -23,7 +23,7 @@ describe('Phase 1 Graph Coalescence', () => {
   describe('number.add coalescence', () => {
     it('should merge consecutive number.add operations on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
@@ -31,20 +31,20 @@ describe('Phase 1 Graph Coalescence', () => {
       });
 
       // Create a score counter
-      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0 } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { score: 0 } });
       store.commit('create player');
 
       // Add to score 3 times rapidly
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 5 });
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 3 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 5 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 3 });
       store.commit('add to score');
 
       // Should coalesce into 1 operation with sum: 10 + 5 + 3 = 18
       const scoreMsg = messages[1];
       expect(scoreMsg.ops).toHaveLength(1);
       expect(scoreMsg.ops[0]).toMatchObject({
-        otype: 'number.add',
+        ot: 'number.add',
         key: 'player',
         path: 'score',
         value: 18,
@@ -53,32 +53,32 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should NOT merge number.add operations on different targets', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player1', value: { score: 0 } });
-      store.edit({ otype: 'node.insert', key: 'player2', value: { score: 0 } });
+      store.edit({ ot: 'node.insert', key: 'player1', value: { score: 0 } });
+      store.edit({ ot: 'node.insert', key: 'player2', value: { score: 0 } });
       store.commit('create players');
 
       // Add to different players
-      store.edit({ otype: 'number.add', key: 'player1', path: 'score', value: 10 });
-      store.edit({ otype: 'number.add', key: 'player2', path: 'score', value: 5 });
+      store.edit({ ot: 'number.add', key: 'player1', path: 'score', value: 10 });
+      store.edit({ ot: 'number.add', key: 'player2', path: 'score', value: 5 });
       store.commit('add to scores');
 
       // Should NOT coalesce (different keys)
       const scoreMsg = messages[1];
       expect(scoreMsg.ops).toHaveLength(2);
       expect(scoreMsg.ops[0]).toMatchObject({
-        otype: 'number.add',
+        ot: 'number.add',
         key: 'player1',
         value: 10,
       });
       expect(scoreMsg.ops[1]).toMatchObject({
-        otype: 'number.add',
+        ot: 'number.add',
         key: 'player2',
         value: 5,
       });
@@ -86,19 +86,19 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should NOT merge number.add operations on different paths', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
       store.commit('create player');
 
       // Add to different properties
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
-      store.edit({ otype: 'number.add', key: 'player', path: 'health', value: -5 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'health', value: -5 });
       store.commit('update stats');
 
       // Should NOT coalesce (different paths)
@@ -112,27 +112,27 @@ describe('Phase 1 Graph Coalescence', () => {
   describe('vector3.add coalescence', () => {
     it('should merge consecutive vector3.add operations on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
       store.commit('create player');
 
       // Move player in multiple steps
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 0, 3] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [0, 0, 3] });
       store.commit('move player');
 
       // Should coalesce into 1 operation with sum: [1+0+0, 0+2+0, 0+0+3] = [1, 2, 3]
       const moveMsg = messages[1];
       expect(moveMsg.ops).toHaveLength(1);
       expect(moveMsg.ops[0]).toMatchObject({
-        otype: 'vector3.add',
+        ot: 'vector3.add',
         key: 'player',
         path: 'position',
         value: [1, 2, 3],
@@ -141,19 +141,19 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should NOT merge vector3.add operations on different targets', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0], velocity: [0, 0, 0] } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { position: [0, 0, 0], velocity: [0, 0, 0] } });
       store.commit('create player');
 
       // Add to different properties
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'velocity', value: [0, 1, 0] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'velocity', value: [0, 1, 0] });
       store.commit('update player');
 
       // Should NOT coalesce (different paths)
@@ -167,27 +167,27 @@ describe('Phase 1 Graph Coalescence', () => {
   describe('LWW (*.set) coalescence', () => {
     it('should keep only last number.set operation on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0 } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { score: 0 } });
       store.commit('create player');
 
       // Set score multiple times
-      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 10 });
-      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 20 });
-      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 30 });
+      store.edit({ ot: 'number.set', key: 'player', path: 'score', value: 10 });
+      store.edit({ ot: 'number.set', key: 'player', path: 'score', value: 20 });
+      store.edit({ ot: 'number.set', key: 'player', path: 'score', value: 30 });
       store.commit('set score');
 
       // Should keep only last set (LWW)
       const scoreMsg = messages[1];
       expect(scoreMsg.ops).toHaveLength(1);
       expect(scoreMsg.ops[0]).toMatchObject({
-        otype: 'number.set',
+        ot: 'number.set',
         key: 'player',
         path: 'score',
         value: 30, // Only last value
@@ -196,27 +196,27 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should keep only last string.set operation on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { name: '' } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { name: '' } });
       store.commit('create player');
 
       // Set name multiple times
-      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Alice' });
-      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Bob' });
-      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Charlie' });
+      store.edit({ ot: 'string.set', key: 'player', path: 'name', value: 'Alice' });
+      store.edit({ ot: 'string.set', key: 'player', path: 'name', value: 'Bob' });
+      store.edit({ ot: 'string.set', key: 'player', path: 'name', value: 'Charlie' });
       store.commit('set name');
 
       // Should keep only last set (LWW)
       const nameMsg = messages[1];
       expect(nameMsg.ops).toHaveLength(1);
       expect(nameMsg.ops[0]).toMatchObject({
-        otype: 'string.set',
+        ot: 'string.set',
         key: 'player',
         path: 'name',
         value: 'Charlie', // Only last value
@@ -225,27 +225,27 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should keep only last boolean.set operation on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { active: false } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { active: false } });
       store.commit('create player');
 
       // Toggle active multiple times
-      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: true });
-      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: false });
-      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: true });
+      store.edit({ ot: 'boolean.set', key: 'player', path: 'active', value: true });
+      store.edit({ ot: 'boolean.set', key: 'player', path: 'active', value: false });
+      store.edit({ ot: 'boolean.set', key: 'player', path: 'active', value: true });
       store.commit('toggle active');
 
       // Should keep only last set (LWW)
       const activeMsg = messages[1];
       expect(activeMsg.ops).toHaveLength(1);
       expect(activeMsg.ops[0]).toMatchObject({
-        otype: 'boolean.set',
+        ot: 'boolean.set',
         key: 'player',
         path: 'active',
         value: true, // Only last value
@@ -254,27 +254,27 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should keep only last vector3.set operation on same target', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
       store.commit('create player');
 
       // Set position multiple times
-      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [1, 0, 0] });
-      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [2, 0, 0] });
-      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [3, 0, 0] });
+      store.edit({ ot: 'vector3.set', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ ot: 'vector3.set', key: 'player', path: 'position', value: [2, 0, 0] });
+      store.edit({ ot: 'vector3.set', key: 'player', path: 'position', value: [3, 0, 0] });
       store.commit('set position');
 
       // Should keep only last set (LWW)
       const posMsg = messages[1];
       expect(posMsg.ops).toHaveLength(1);
       expect(posMsg.ops[0]).toMatchObject({
-        otype: 'vector3.set',
+        ot: 'vector3.set',
         key: 'player',
         path: 'position',
         value: [3, 0, 0], // Only last value
@@ -283,19 +283,19 @@ describe('Phase 1 Graph Coalescence', () => {
 
     it('should NOT merge set operations on different paths', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
       store.commit('create player');
 
       // Set different properties
-      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 10 });
-      store.edit({ otype: 'number.set', key: 'player', path: 'health', value: 50 });
+      store.edit({ ot: 'number.set', key: 'player', path: 'score', value: 10 });
+      store.edit({ ot: 'number.set', key: 'player', path: 'health', value: 50 });
       store.commit('set stats');
 
       // Should NOT coalesce (different paths)
@@ -309,23 +309,23 @@ describe('Phase 1 Graph Coalescence', () => {
   describe('Mixed operations', () => {
     it('should coalesce operations independently by type', () => {
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
         onSend: (msg) => messages.push(msg),
       });
 
-      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, position: [0, 0, 0], name: '' } });
+      store.edit({ ot: 'node.insert', key: 'player', value: { score: 0, position: [0, 0, 0], name: '' } });
       store.commit('create player');
 
       // Mix of operations
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
-      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 5 });
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
-      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
-      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Alice' });
-      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Bob' });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ ot: 'number.add', key: 'player', path: 'score', value: 5 });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ ot: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
+      store.edit({ ot: 'string.set', key: 'player', path: 'name', value: 'Alice' });
+      store.edit({ ot: 'string.set', key: 'player', path: 'name', value: 'Bob' });
       store.commit('update player');
 
       // Should coalesce each type independently
@@ -334,21 +334,21 @@ describe('Phase 1 Graph Coalescence', () => {
 
       // number.add should be coalesced: 10 + 5 = 15
       expect(updateMsg.ops[0]).toMatchObject({
-        otype: 'number.add',
+        ot: 'number.add',
         path: 'score',
         value: 15,
       });
 
       // vector3.add should be coalesced: [1, 0, 0] + [0, 2, 0] = [1, 2, 0]
       expect(updateMsg.ops[1]).toMatchObject({
-        otype: 'vector3.add',
+        ot: 'vector3.add',
         path: 'position',
         value: [1, 2, 0],
       });
 
       // string.set should keep last: 'Bob'
       expect(updateMsg.ops[2]).toMatchObject({
-        otype: 'string.set',
+        ot: 'string.set',
         path: 'name',
         value: 'Bob',
       });

package/tests/client/graph-coalescence.test.ts

@@ -18,7 +18,7 @@ describe('Graph Operation Coalescence (Integration)', () => {
       const messages: CRDTMessage[] = [];
 
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
@@ -26,27 +26,27 @@ describe('Graph Operation Coalescence (Integration)', () => {
       });
 
       // Initialize scene and text node
-      store.edit({ otype: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
+      store.edit({ ot: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
       store.commit('init scene');
 
-      store.edit({ otype: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
+      store.edit({ ot: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
       store.commit('add text node');
 
-      store.edit({ otype: 'text.init', key: 'text-doc', path: 'content', value: '' } as any);
+      store.edit({ ot: 'text.init', key: 'text-doc', path: 'content', value: '' } as any);
       store.commit('init text');
 
       // Type "Hello" (5 operations)
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 0, value: 'H' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 1, value: 'e' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 2, value: 'l' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 3, value: 'l' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 4, value: 'o' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 0, value: 'H' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 1, value: 'e' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 2, value: 'l' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 3, value: 'l' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 4, value: 'o' } as any);
       store.commit('type Hello');
 
       messages.length = 0; // Clear previous messages
 
       // Delete all 5 characters (1 operation)
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 5 } as any);
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 5 } as any);
       store.commit('delete all');
 
       // Verify we sent exactly 1 message
@@ -54,22 +54,22 @@ describe('Graph Operation Coalescence (Integration)', () => {
 
       const msg = messages[0];
       expect(msg.ops).toHaveLength(1);
-      expect(msg.ops[0].otype).toBe('text.delete');
+      expect(msg.ops[0].ot).toBe('text.delete');
 
       const deleteOp = msg.ops[0] as any;
-      expect(deleteOp.deletions).toBeDefined();
+      expect(deleteOp.rm).toBeDefined();
 
       // CRITICAL: This verifies the coalescence optimization works!
       // Without the fix, this would have many single-char deletions
-      expect(deleteOp.deletions).toHaveLength(1);
-      expect(deleteOp.deletions[0].length).toBe(5);
+      expect(deleteOp.rm).toHaveLength(1);
+      expect(deleteOp.rm[0][1]).toBe(5);
     });
 
     it('should coalesce multiple consecutive delete operations', () => {
       const messages: CRDTMessage[] = [];
 
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
@@ -77,23 +77,23 @@ describe('Graph Operation Coalescence (Integration)', () => {
       });
 
       // Initialize
-      store.edit({ otype: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
+      store.edit({ ot: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
       store.commit('init');
 
-      store.edit({ otype: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
+      store.edit({ ot: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
       store.commit('add text');
 
-      store.edit({ otype: 'text.init', key: 'text-doc', path: 'content', value: 'Hello' } as any);
+      store.edit({ ot: 'text.init', key: 'text-doc', path: 'content', value: 'Hello' } as any);
       store.commit('init text with Hello');
 
       messages.length = 0;
 
       // Simulate rapid backspace (5 separate delete operations)
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 4, length: 1 } as any); // 'o'
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 3, length: 1 } as any); // 'l'
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 2, length: 1 } as any); // 'l'
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 1, length: 1 } as any); // 'e'
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 1 } as any); // 'H'
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 4, length: 1 } as any); // 'o'
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 3, length: 1 } as any); // 'l'
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 2, length: 1 } as any); // 'l'
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 1, length: 1 } as any); // 'e'
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 1 } as any); // 'H'
       store.commit('rapid backspace');
 
       // Verify coalescence worked
@@ -102,22 +102,22 @@ describe('Graph Operation Coalescence (Integration)', () => {
       const msg = messages[0];
 
       // Find the delete operation(s)
-      const deleteOps = msg.ops.filter(op => op.otype === 'text.delete');
+      const deleteOps = msg.ops.filter(op => op.ot === 'text.delete');
       expect(deleteOps.length).toBeGreaterThan(0);
 
       // CRITICAL TEST: Verify each operation has optimized deletions
       // The key fix is that isTextDeleteOp now accepts operations with deletions arrays
       for (const op of deleteOps) {
         const deleteOp = op as any;
-        expect(deleteOp.deletions).toBeDefined();
-        expect(Array.isArray(deleteOp.deletions)).toBe(true);
-        expect(deleteOp.deletions.length).toBeGreaterThan(0);
+        expect(deleteOp.rm).toBeDefined();
+        expect(Array.isArray(deleteOp.rm)).toBe(true);
+        expect(deleteOp.rm.length).toBeGreaterThan(0);
 
         // Each deletion should be valid
-        for (const del of deleteOp.deletions) {
-          expect(del.id).toBeDefined();
-          expect(typeof del.length).toBe('number');
-          expect(del.length).toBeGreaterThan(0);
+        for (const del of deleteOp.rm) {
+          expect(del[0]).toBeDefined();
+          expect(typeof del[1]).toBe('number');
+          expect(del[1]).toBeGreaterThan(0);
         }
       }
 
@@ -130,7 +130,7 @@ describe('Graph Operation Coalescence (Integration)', () => {
       const messages: CRDTMessage[] = [];
 
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
@@ -138,19 +138,19 @@ describe('Graph Operation Coalescence (Integration)', () => {
       });
 
       // Initialize
-      store.edit({ otype: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
+      store.edit({ ot: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
       store.commit('init');
 
-      store.edit({ otype: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
+      store.edit({ ot: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
       store.commit('add text');
 
-      store.edit({ otype: 'text.init', key: 'text-doc', path: 'content', value: 'Test' } as any);
+      store.edit({ ot: 'text.init', key: 'text-doc', path: 'content', value: 'Test' } as any);
       store.commit('init text');
 
       messages.length = 0;
 
       // Single delete operation
-      store.edit({ otype: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 4 } as any);
+      store.edit({ ot: 'text.delete', key: 'text-doc', path: 'content', position: 0, length: 4 } as any);
       store.commit('delete');
 
       expect(messages).toHaveLength(1);
@@ -159,9 +159,9 @@ describe('Graph Operation Coalescence (Integration)', () => {
 
       // CRITICAL: Verify the operation has the deletions field
       // This is what isTextDeleteOp checks for
-      expect(deleteOp.otype).toBe('text.delete');
-      expect(Array.isArray(deleteOp.deletions)).toBe(true);
-      expect(deleteOp.deletions.length).toBeGreaterThan(0);
+      expect(deleteOp.ot).toBe('text.delete');
+      expect(Array.isArray(deleteOp.rm)).toBe(true);
+      expect(deleteOp.rm.length).toBeGreaterThan(0);
 
       // Verify it does NOT have seq/ts (those are on TextInsertOp only!)
       expect(deleteOp.seq).toBeUndefined();
@@ -174,7 +174,7 @@ describe('Graph Operation Coalescence (Integration)', () => {
       const messages: CRDTMessage[] = [];
 
       const store = createGraph({
-        sessionId: 'alice',
+        client: 'alice',
         coalescingEnabled: true,
         coalescingDelayMs: 0,
         coalescingThresholdMs: 1000,
@@ -182,23 +182,23 @@ describe('Graph Operation Coalescence (Integration)', () => {
       });
 
       // Initialize
-      store.edit({ otype: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
+      store.edit({ ot: 'node.init', key: 'scene', path: '', value: { tag: 'Scene' } });
       store.commit('init');
 
-      store.edit({ otype: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
+      store.edit({ ot: 'node.insert', key: 'scene', path: 'children', value: { key: 'text-doc', tag: 'Text' } });
       store.commit('add text');
 
-      store.edit({ otype: 'text.init', key: 'text-doc', path: 'content', value: '' } as any);
+      store.edit({ ot: 'text.init', key: 'text-doc', path: 'content', value: '' } as any);
       store.commit('init text');
 
       messages.length = 0;
 
       // Type "Hello" (5 operations)
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 0, value: 'H' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 1, value: 'e' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 2, value: 'l' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 3, value: 'l' } as any);
-      store.edit({ otype: 'text.insert', key: 'text-doc', path: 'content', position: 4, value: 'o' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 0, value: 'H' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 1, value: 'e' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 2, value: 'l' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 3, value: 'l' } as any);
+      store.edit({ ot: 'text.insert', key: 'text-doc', path: 'content', position: 4, value: 'o' } as any);
       store.commit('type Hello');
 
       expect(messages).toHaveLength(1);
@@ -207,10 +207,10 @@ describe('Graph Operation Coalescence (Integration)', () => {
 
       // Verify inserts were coalesced
       expect(msg.ops).toHaveLength(1);
-      expect(msg.ops[0].otype).toBe('text.insert');
+      expect(msg.ops[0].ot).toBe('text.insert');
 
       const insertOp = msg.ops[0] as any;
-      expect(insertOp.content).toBe('Hello');
+      expect(insertOp.value[1]).toBe('Hello');
       expect(insertOp.id).toBeDefined();
       expect(insertOp.seq).toBeDefined();
       expect(insertOp.ts).toBeDefined();

package/tests/client/journal-benchmark.test.ts

@@ -27,18 +27,18 @@ import type { Operation } from '../../src/operations/OperationTypes.js';
 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 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 commitAndAck(state: ClientState, op: Operation): ClientState {
@@ -47,8 +47,8 @@ function commitAndAck(state: ClientState, op: Operation): ClientState {
   return onServerAck(committed, msg!.id);
 }
 
-function setupState(sessionId = 'bench-session'): ClientState {
-  let s = createInitialState(sessionId);
+function setupState(client = 'bench-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);