@vuer-ai/vuer-rtc 0.4.2 → 0.5.1

package/test-coalescence.ts

@@ -0,0 +1,201 @@
+import { coalesceTextOperations } from './src/client/coalesceTextOperations.js';
+import type { InsertOp } from './src/crdt/Rope.js';
+import type { TextOperation } from './src/client/textTypes.js';
+
+// Test: Typing "Hello" quickly should create ONE operation
+function testHelloCoalescence() {
+  console.log('\n=== Test: Typing "Hello" ===\n');
+
+  const ops: TextOperation[] = [];
+
+  // Simulate typing "Hello" - each character creates a sequential operation
+  // Character 'H' at position 0
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:1',
+      content: 'H',
+      parentId: null,
+      seq: 1,
+      ts: 1000.0,
+    }
+  });
+
+  // Character 'e' at position 1 (parent is 'H')
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:2',
+      content: 'e',
+      parentId: 'alice:1',
+      seq: 2,
+      ts: 1000.1, // 100ms later
+    }
+  });
+
+  // Character 'l' at position 2 (parent is 'e')
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:3',
+      content: 'l',
+      parentId: 'alice:2',
+      seq: 3,
+      ts: 1000.2, // 200ms later
+    }
+  });
+
+  // Character 'l' at position 3 (parent is first 'l')
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:4',
+      content: 'l',
+      parentId: 'alice:3',
+      seq: 4,
+      ts: 1000.25, // 250ms later
+    }
+  });
+
+  // Character 'o' at position 4 (parent is second 'l')
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:5',
+      content: 'o',
+      parentId: 'alice:4',
+      seq: 5,
+      ts: 1000.29, // 290ms later
+    }
+  });
+
+  console.log('Input operations:');
+  ops.forEach((op, i) => {
+    const insertOp = op.op as InsertOp;
+    console.log(`  ${i + 1}. id=${insertOp.id}, content="${insertOp.content}", parentId=${insertOp.parentId}, ts=${insertOp.ts}`);
+  });
+
+  // Coalesce with 300ms threshold
+  const coalesced = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+  console.log('\nCoalesced operations:');
+  coalesced.forEach((op, i) => {
+    const insertOp = op.op as InsertOp;
+    console.log(`  ${i + 1}. id=${insertOp.id}, content="${insertOp.content}", parentId=${insertOp.parentId}, _lastCharId=${(insertOp as any)._lastCharId}`);
+  });
+
+  // Verify results
+  const success = coalesced.length === 1 && coalesced[0].op.content === 'Hello';
+  console.log('\n' + (success ? '✅ SUCCESS' : '❌ FAILURE') + ': Expected 1 operation with content="Hello"');
+  console.log(`   Got ${coalesced.length} operation(s) with content="${coalesced[0].op.content}"`);
+
+  if (success && (coalesced[0].op as any)._lastCharId) {
+    console.log(`   _lastCharId correctly set to: ${(coalesced[0].op as any)._lastCharId}`);
+  }
+
+  return success;
+}
+
+// Test: Typing "World" with longer delay should NOT coalesce
+function testWorldNoCoalescence() {
+  console.log('\n=== Test: Typing "World" with delays > 300ms ===\n');
+
+  const ops: TextOperation[] = [];
+
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:10',
+      content: 'W',
+      parentId: null,
+      seq: 10,
+      ts: 2000.0,
+    }
+  });
+
+  // 400ms delay - should NOT coalesce
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:11',
+      content: 'o',
+      parentId: 'alice:10',
+      seq: 11,
+      ts: 2000.4,
+    }
+  });
+
+  const coalesced = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+  console.log('Input operations: 2 (400ms apart)');
+  console.log('Coalesced operations:', coalesced.length);
+
+  const success = coalesced.length === 2;
+  console.log('\n' + (success ? '✅ SUCCESS' : '❌ FAILURE') + ': Expected 2 separate operations (delay too long)');
+
+  return success;
+}
+
+// Test: Broken YATA chain should NOT coalesce
+function testBrokenChain() {
+  console.log('\n=== Test: Broken YATA chain (non-sequential parents) ===\n');
+
+  const ops: TextOperation[] = [];
+
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:20',
+      content: 'A',
+      parentId: null,
+      seq: 20,
+      ts: 3000.0,
+    }
+  });
+
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:21',
+      content: 'B',
+      parentId: 'alice:20',
+      seq: 21,
+      ts: 3000.1,
+    }
+  });
+
+  // This operation's parent is NOT alice:21, breaking the chain
+  ops.push({
+    type: 'insert',
+    op: {
+      id: 'alice:22',
+      content: 'C',
+      parentId: 'alice:15', // Different parent!
+      seq: 22,
+      ts: 3000.2,
+    }
+  });
+
+  const coalesced = coalesceTextOperations(ops, { thresholdMs: 300 });
+
+  console.log('Input operations: 3 (third has wrong parent)');
+  console.log('Coalesced operations:', coalesced.length);
+
+  const success = coalesced.length === 2; // First two should merge, third separate
+  console.log('\n' + (success ? '✅ SUCCESS' : '❌ FAILURE') + ': Expected 2 operations (AB merged, C separate)');
+
+  return success;
+}
+
+// Run all tests
+const results = [
+  testHelloCoalescence(),
+  testWorldNoCoalescence(),
+  testBrokenChain(),
+];
+
+console.log('\n=== SUMMARY ===');
+console.log(`Passed: ${results.filter(r => r).length}/${results.length}`);
+console.log(results.every(r => r) ? '✅ ALL TESTS PASSED' : '❌ SOME TESTS FAILED');
+
+process.exit(results.every(r => r) ? 0 : 1);

package/tests/client/actions.test.ts

@@ -795,4 +795,160 @@ describe('Client Actions', () => {
       expect(getText(alice.graph.nodes['doc']?.content)).toBe('Hello');
     });
   });
+
+  describe('coalescence metadata preservation', () => {
+    it('should preserve CRDT metadata in journal after commit', () => {
+      // Create a text document
+      let s = createInitialState('test-session');
+      s = onEdit(s, {
+        key: '',
+        otype: 'node.insert',
+        path: 'children',
+        value: { key: 'doc', tag: 'Text' },
+      });
+      const { state: s1 } = commitEdits(s);
+      s = s1;
+
+      // Initialize text
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.init',
+        path: 'content',
+        value: '',
+      } as any);
+      const { state: s2 } = commitEdits(s);
+      s = s2;
+
+      // Type multiple characters rapidly (simulating coalescence scenario)
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.insert',
+        path: 'content',
+        position: 0,
+        value: 'a',
+      } as any);
+
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.insert',
+        path: 'content',
+        position: 1,
+        value: 'b',
+      } as any);
+
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.insert',
+        path: 'content',
+        position: 2,
+        value: 'c',
+      } as any);
+
+      // Commit - this triggers coalescence
+      const { state: s3, msg } = commitEdits(s);
+      s = s3;
+
+      // Verify message was created
+      expect(msg).not.toBeNull();
+      expect(msg!.ops).toHaveLength(3); // Each op should be separate (not coalesced due to CRDT metadata)
+
+      // Verify all operations in the message have CRDT metadata
+      for (const op of msg!.ops) {
+        if (op.otype === 'text.insert') {
+          expect((op as any).id).toBeDefined();
+          expect(typeof (op as any).id).toBe('string');
+          expect((op as any).id).toMatch(/:/); // String format: "agent:seq"
+          expect((op as any).content).toBeDefined();
+          expect((op as any).seq).toBeDefined();
+          expect((op as any).ts).toBeDefined();
+          // parentId can be null for first operation
+          expect((op as any).parentId !== undefined).toBe(true);
+        }
+      }
+
+      // Verify journal has the operations with metadata
+      const journalEntry = s.journal[s.journal.length - 1];
+      expect(journalEntry.msg.ops).toHaveLength(3);
+
+      for (const op of journalEntry.msg.ops) {
+        if (op.otype === 'text.insert') {
+          expect((op as any).id).toBeDefined();
+          expect((op as any).content).toBeDefined();
+          expect((op as any).seq).toBeDefined();
+        }
+      }
+    });
+
+    it('should preserve metadata when receiving own message back from server', () => {
+      // This tests the full round-trip: send → server ACK → journal update
+      let s = createInitialState('test-session');
+
+      // Create text document
+      s = onEdit(s, {
+        key: '',
+        otype: 'node.insert',
+        path: 'children',
+        value: { key: 'doc', tag: 'Text' },
+      });
+      const { state: s1 } = commitEdits(s);
+      s = s1;
+
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.init',
+        path: 'content',
+        value: '',
+      } as any);
+      const { state: s2 } = commitEdits(s);
+      s = s2;
+
+      // Type two characters
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.insert',
+        path: 'content',
+        position: 0,
+        value: 'x',
+      } as any);
+
+      s = onEdit(s, {
+        key: 'doc',
+        otype: 'text.insert',
+        path: 'content',
+        position: 1,
+        value: 'y',
+      } as any);
+
+      // Commit
+      const { state: s3, msg } = commitEdits(s);
+      s = s3;
+
+      // Verify the message has metadata before it's sent
+      expect(msg).not.toBeNull();
+      const firstOp = msg!.ops[0];
+      if (firstOp.otype === 'text.insert') {
+        expect((firstOp as any).id).toBeDefined();
+      }
+
+      // Simulate server ACK by receiving the same message back
+      // (in real system, server would broadcast this to all clients including sender)
+      const journalBefore = s.journal.length;
+      s = onRemoteMessage(s, msg!);
+
+      // Journal shouldn't grow (duplicate message)
+      expect(s.journal.length).toBe(journalBefore);
+
+      // But verify the existing journal entry still has metadata
+      const journalEntry = s.journal.find(e => e.msg.id === msg!.id);
+      expect(journalEntry).toBeDefined();
+
+      for (const op of journalEntry!.msg.ops) {
+        if (op.otype === 'text.insert') {
+          expect((op as any).id).toBeDefined();
+          expect((op as any).content).toBeDefined();
+          expect((op as any).seq).toBeDefined();
+        }
+      }
+    });
+  });
 });

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

@@ -0,0 +1,321 @@
+/**
+ * End-to-end tests for graph operation coalescence
+ *
+ * Verifies that text.insert and text.delete operations are properly coalesced
+ * when using createGraph with coalescingEnabled.
+ */
+
+import { describe, it, expect, jest } from '@jest/globals';
+import { createGraph } from '../../src/client/createGraph.js';
+import type { CRDTMessage, Operation } from '../../src/operations/OperationTypes.js';
+
+describe('Graph Operation Coalescence (end-to-end)', () => {
+  describe('text.insert coalescence', () => {
+    it('should coalesce consecutive text.insert operations when coalescingEnabled', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50, // Short delay for testing
+        coalescingThresholdMs: 300, // 300ms threshold
+      });
+
+      // Create node first (insert as child of root '')
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+
+      // Initialize a text property
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+
+      // Simulate typing "Hello" quickly (within 300ms)
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+
+      // Wait for coalescing timer to fire
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should have sent ONE coalesced message (init + coalesced inserts)
+      expect(messages.length).toBe(1);
+
+      // The message should contain coalesced text.insert operations
+      const msg = messages[0];
+      const textInserts = msg.ops.filter(op => op.otype === 'text.insert');
+
+      // All 5 inserts should be coalesced into 1 operation
+      expect(textInserts.length).toBeLessThan(5);
+
+      // The coalesced operation should have content "Hello"
+      const firstInsert = textInserts[0];
+      expect(firstInsert.content).toBe('Hello');
+    });
+
+    it('should NOT coalesce when coalescingEnabled is false', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: false, // Disabled
+      });
+
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+
+      // Type "Hi" and commit immediately
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
+      store.commit('typing');
+
+      // Should send ONE message with init and 2 separate insert operations (not coalesced)
+      expect(messages.length).toBe(1);
+      const textInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
+
+      // Should have 2 separate operations
+      expect(textInserts.length).toBe(2);
+      expect(textInserts[0].content).toBe('H');
+      expect(textInserts[1].content).toBe('i');
+    });
+
+    it('should respect time threshold and create separate operations for slow typing', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50,
+        coalescingThresholdMs: 100, // 100ms threshold
+      });
+
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+
+      // Type "H" and "e" quickly
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+
+      // Wait for first batch to be sent
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Type "l" and "l" quickly (after threshold)
+      await new Promise(resolve => setTimeout(resolve, 150)); // Exceed threshold
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+
+      // Wait for second batch
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should have sent TWO messages: one with "He", one with "ll"
+      expect(messages.length).toBe(2);
+
+      const firstInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
+      const secondInserts = messages[1].ops.filter(op => op.otype === 'text.insert');
+
+      expect(firstInserts.length).toBe(1);
+      expect(firstInserts[0].content).toBe('He');
+
+      expect(secondInserts.length).toBe(1);
+      expect(secondInserts[0].content).toBe('ll');
+    });
+  });
+
+  describe('text.delete coalescence', () => {
+    it('should coalesce consecutive text.delete operations', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50,
+        coalescingThresholdMs: 300,
+      });
+
+      // Create node and initialize with some text
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: 'Hello World' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+      messages.length = 0; // Clear init message
+
+      // Delete "World" one character at a time (positions 6-10)
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'W'
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'o'
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'r'
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'l'
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 6, length: 1 }); // Delete 'd'
+
+      // Wait for coalescing timer
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should have ONE coalesced delete message
+      expect(messages.length).toBe(1);
+
+      const deleteOps = messages[0].ops.filter(op => op.otype === 'text.delete');
+
+      // Should be coalesced into fewer operations
+      expect(deleteOps.length).toBeLessThan(5);
+
+      // If coalesced into 1 operation, it should have a deletions array
+      if (deleteOps.length === 1) {
+        const firstDelete = deleteOps[0] as any;
+        expect(firstDelete.deletions).toBeDefined();
+        expect(firstDelete.deletions.length).toBeGreaterThanOrEqual(1);
+      }
+    });
+
+    it('should handle mixed insert and delete operations', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50,
+        coalescingThresholdMs: 300,
+      });
+
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+
+      // Type "Hello", then delete "lo", then type "p"
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'l'
+      store.edit({ otype: 'text.delete', key: 'doc', path: 'content', position: 3, length: 1 }); // Delete 'o'
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'p' });
+
+      // Wait for coalescing timer
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should have ONE message with coalesced operations
+      expect(messages.length).toBe(1);
+
+      const msg = messages[0];
+      const inserts = msg.ops.filter(op => op.otype === 'text.insert');
+      const deletes = msg.ops.filter(op => op.otype === 'text.delete');
+
+      // Should have some coalesced inserts and deletes
+      expect(inserts.length).toBeGreaterThan(0);
+      expect(deletes.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('explicit commit with coalescence', () => {
+    it('should coalesce operations when explicitly committing with coalescingEnabled', () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingThresholdMs: 300,
+      });
+
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'H' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
+
+      // Explicitly commit (should clear timer and coalesce immediately)
+      store.commit('typing');
+
+      // Should send ONE message immediately with coalesced operations
+      expect(messages.length).toBe(1);
+
+      const textInserts = messages[0].ops.filter(op => op.otype === 'text.insert');
+      expect(textInserts.length).toBe(1);
+      expect(textInserts[0].content).toBe('Hi');
+    });
+  });
+
+  describe('multi-document coalescence', () => {
+    it('should coalesce operations on different documents independently', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50,
+        coalescingThresholdMs: 300,
+      });
+
+      // Edit doc1
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc1', tag: 'Doc', name: 'Document 1' } });
+      store.edit({ otype: 'text.init', key: 'doc1', path: 'content', value: '' });
+      store.edit({ otype: 'text.insert', key: 'doc1', path: 'content', position: 0, value: 'A' });
+      store.edit({ otype: 'text.insert', key: 'doc1', path: 'content', position: 1, value: 'B' });
+
+      // Edit doc2
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc2', tag: 'Doc', name: 'Document 2' } });
+      store.edit({ otype: 'text.init', key: 'doc2', path: 'content', value: '' });
+      store.edit({ otype: 'text.insert', key: 'doc2', path: 'content', position: 0, value: 'X' });
+      store.edit({ otype: 'text.insert', key: 'doc2', path: 'content', position: 1, value: 'Y' });
+
+      // Wait for coalescing
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should send ONE message with operations from both docs
+      expect(messages.length).toBe(1);
+
+      const msg = messages[0];
+      const doc1Inserts = msg.ops.filter(op => op.otype === 'text.insert' && op.key === 'doc1');
+      const doc2Inserts = msg.ops.filter(op => op.otype === 'text.insert' && op.key === 'doc2');
+
+      // Each document's operations should be coalesced independently
+      expect(doc1Inserts.length).toBe(1);
+      expect(doc1Inserts[0].content).toBe('AB');
+
+      expect(doc2Inserts.length).toBe(1);
+      expect(doc2Inserts[0].content).toBe('XY');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle rapid commits without losing operations', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 100,
+        coalescingThresholdMs: 300,
+      });
+
+      store.edit({ otype: 'node.insert', key: '', path: 'children', value: { key: 'doc', tag: 'Doc', name: 'Document' } });
+      store.edit({ otype: 'text.init', key: 'doc', path: 'content', value: '' });
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'A' });
+      store.commit('first');
+
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'B' });
+      store.commit('second');
+
+      store.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'C' });
+      store.commit('third');
+
+      // Should have 3 messages (one per commit)
+      expect(messages.length).toBe(3);
+
+      // Each message should contain the expected operation
+      expect(messages[0].ops.some(op => op.otype === 'text.insert' && op.content === 'A')).toBe(true);
+      expect(messages[1].ops.some(op => op.otype === 'text.insert' && op.content === 'B')).toBe(true);
+      expect(messages[2].ops.some(op => op.otype === 'text.insert' && op.content === 'C')).toBe(true);
+    });
+
+    it('should handle empty edits gracefully', async () => {
+      const messages: CRDTMessage[] = [];
+      const store = createGraph({
+        sessionId: 'alice',
+        onSend: (msg) => messages.push(msg),
+        coalescingEnabled: true,
+        coalescingDelayMs: 50,
+      });
+
+      // Wait for timer without any edits
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should not send any messages
+      expect(messages.length).toBe(0);
+    });
+  });
+});