@vuer-ai/vuer-rtc-server 0.2.0 → 0.2.2

package/tests/journal/multi-session-coalescing.test.ts

@@ -0,0 +1,871 @@
+/**
+ * Multi-Session Coalescing Test
+ *
+ * Tests the critical bug fix: Operations from DIFFERENT sessions must never
+ * be merged into a single message during coalescing. This preserves CRDT
+ * metadata (sessionId, clock, lamportTime) which is essential for correct
+ * conflict resolution.
+ *
+ * The Bug (Fixed):
+ * - Coalescing was merging operations from alice and bob into one message
+ * - This broke CRDT semantics because the merged message had wrong metadata
+ * - Last-Write-Wins (LWW) and other conflict resolution relied on this metadata
+ *
+ * The Fix:
+ * - Operations are now coalesced separately per session
+ * - Each session gets its own message with correct metadata
+ * - Operations within a session are still coalesced (text inserts, set ops, etc)
+ *
+ * ⚠️  MongoDB Replica Set Required
+ * These tests require MongoDB to be running with replica set enabled because
+ * Prisma uses transactions for atomic operations. To run these tests:
+ *
+ * 1. Start MongoDB with replica set:
+ *    docker compose -f docker/docker-compose.yml up -d mongo
+ *
+ * 2. Verify replica set is initialized:
+ *    docker exec vuer-rtc-mongo mongosh --eval "rs.status().set"
+ *    (should output: rs0)
+ *
+ * 3. Ensure .env has replica set configuration:
+ *    DATABASE_URL="mongodb://localhost:27017/vuer?replicaSet=rs0&directConnection=true"
+ *
+ * 4. Run tests:
+ *    npm test -- multi-session-coalescing.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import type { CRDTMessage, Operation } from '@vuer-ai/vuer-rtc';
+import { JournalService } from '../../src/journal/JournalService.js';
+import { PrismaClient } from '@prisma/client';
+
+describe('Multi-Session Coalescing', () => {
+  let service: JournalService;
+  let prisma: PrismaClient;
+  let documentId: string;
+
+  beforeEach(async () => {
+    prisma = new PrismaClient();
+    await prisma.$connect();
+
+    // Clean up test data
+    await prisma.journalBatch.deleteMany({});
+    await prisma.document.deleteMany({});
+
+    service = new JournalService(prisma);
+    documentId = await service.createDocument('test-doc', 'test-user');
+  });
+
+  afterEach(async () => {
+    await prisma.$disconnect();
+  });
+
+  it('should keep operations from different sessions in separate messages', async () => {
+    // Create text node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'text-doc',
+            tag: 'Text',
+            name: 'Text Doc',
+          },
+        } as Operation,
+        {
+          key: 'text-doc',
+          otype: 'text.init',
+          path: 'content',
+          value: '',
+        } as Operation,
+      ],
+    };
+
+    await service.processMessage(documentId, initMsg);
+
+    // Alice types "hello" (5 separate messages)
+    for (let i = 0; i < 5; i++) {
+      const char = 'hello'[i];
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 1 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: Date.now() / 1000 + i * 0.1,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: i,
+            value: char,
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Bob types "world" (5 separate messages)
+    for (let i = 0; i < 5; i++) {
+      const char = 'world'[i];
+      const msg: CRDTMessage = {
+        id: `msg-bob-${i}`,
+        sessionId: 'bob',
+        clock: { bob: 1 + i, alice: 5, system: 1 },
+        lamportTime: 7 + i,
+        timestamp: Date.now() / 1000 + 0.5 + i * 0.1,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: 5 + i,
+            value: char,
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Before compaction: verify we have 11 batches (1 init + 5 alice + 5 bob)
+    const batchesBefore = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+    expect(batchesBefore.length).toBe(11);
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: should have 3 batches (1 system + 1 alice + 1 bob)
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+
+    expect(batchesAfter.length).toBe(3);
+
+    // Verify sessions are preserved
+    const sessionIds = batchesAfter.map(b => b.sessionId).sort();
+    expect(sessionIds).toEqual(['alice', 'bob', 'system']);
+
+    // Verify alice's batch
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    expect(aliceBatch).toBeDefined();
+    expect(aliceBatch!.sessionId).toBe('alice');
+    const aliceOps = aliceBatch!.operations as any[];
+    expect(aliceOps.length).toBe(1); // Should be coalesced into one text.insert
+    expect(aliceOps[0].otype).toBe('text.insert');
+    expect(aliceOps[0].value).toBe('hello');
+    expect(aliceOps[0].position).toBe(0);
+
+    // Verify bob's batch
+    const bobBatch = batchesAfter.find(b => b.sessionId === 'bob');
+    expect(bobBatch).toBeDefined();
+    expect(bobBatch!.sessionId).toBe('bob');
+    const bobOps = bobBatch!.operations as any[];
+    expect(bobOps.length).toBe(1); // Should be coalesced into one text.insert
+    expect(bobOps[0].otype).toBe('text.insert');
+    expect(bobOps[0].value).toBe('world');
+    expect(bobOps[0].position).toBe(5);
+
+    // Verify vector clocks are preserved
+    expect(aliceBatch!.vectorClock).toBeDefined();
+    expect(bobBatch!.vectorClock).toBeDefined();
+  });
+
+  it('should preserve metadata for each session', async () => {
+    // Create a node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'cube',
+            tag: 'Mesh',
+            name: 'Cube',
+          },
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    const baseTime = Date.now() / 1000;
+
+    // Alice modifies position multiple times
+    const aliceOps = [
+      { position: [1, 0, 0], time: baseTime + 0.1 },
+      { position: [2, 0, 0], time: baseTime + 0.2 },
+      { position: [3, 0, 0], time: baseTime + 0.3 },
+    ];
+
+    for (let i = 0; i < aliceOps.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 2 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: aliceOps[i].time,
+        ops: [
+          {
+            key: 'cube',
+            otype: 'vector3.set',
+            path: 'position',
+            value: aliceOps[i].position as [number, number, number],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Bob modifies rotation multiple times
+    const bobOps = [
+      { rotation: [0, 1, 0], time: baseTime + 1.0 },
+      { rotation: [0, 2, 0], time: baseTime + 1.1 },
+      { rotation: [0, 3, 0], time: baseTime + 1.2 },
+    ];
+
+    for (let i = 0; i < bobOps.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-bob-${i}`,
+        sessionId: 'bob',
+        clock: { bob: 1 + i, alice: 4, system: 1 },
+        lamportTime: 5 + i,
+        timestamp: bobOps[i].time,
+        ops: [
+          {
+            key: 'cube',
+            otype: 'vector3.set',
+            path: 'rotation',
+            value: bobOps[i].rotation as [number, number, number],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: verify metadata is preserved per session
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+
+    // Should have 3 batches: system, alice, bob
+    expect(batchesAfter.length).toBe(3);
+
+    // Check alice's batch metadata
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    expect(aliceBatch).toBeDefined();
+    expect(aliceBatch!.sessionId).toBe('alice');
+    expect(aliceBatch!.lamportTime).toBe(4); // Last alice lamportTime
+    expect((aliceBatch!.vectorClock as any).alice).toBeDefined();
+    // Should have only the last position (LWW coalescing)
+    const aliceOpsAfter = aliceBatch!.operations as any[];
+    expect(aliceOpsAfter.length).toBe(1);
+    expect(aliceOpsAfter[0].value).toEqual([3, 0, 0]);
+
+    // Check bob's batch metadata
+    const bobBatch = batchesAfter.find(b => b.sessionId === 'bob');
+    expect(bobBatch).toBeDefined();
+    expect(bobBatch!.sessionId).toBe('bob');
+    expect(bobBatch!.lamportTime).toBe(7); // Last bob lamportTime
+    expect((bobBatch!.vectorClock as any).bob).toBeDefined();
+    // Should have only the last rotation (LWW coalescing)
+    const bobOpsAfter = bobBatch!.operations as any[];
+    expect(bobOpsAfter.length).toBe(1);
+    expect(bobOpsAfter[0].value).toEqual([0, 3, 0]);
+  });
+
+  it('should coalesce text operations within same session but not across sessions', async () => {
+    // Create text node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'text-doc',
+            tag: 'Text',
+            name: 'Text Doc',
+          },
+        } as Operation,
+        {
+          key: 'text-doc',
+          otype: 'text.init',
+          path: 'content',
+          value: '',
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    const baseTime = Date.now() / 1000;
+
+    // Alice types "abc" at position 0
+    for (let i = 0; i < 3; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 1 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: baseTime + i * 0.1,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: i,
+            value: 'abc'[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Bob types "xyz" at position 3
+    for (let i = 0; i < 3; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-bob-${i}`,
+        sessionId: 'bob',
+        clock: { bob: 1 + i, alice: 3, system: 1 },
+        lamportTime: 5 + i,
+        timestamp: baseTime + 1.0 + i * 0.1,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: 3 + i,
+            value: 'xyz'[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Alice types "123" at position 3 (interleaved with bob)
+    for (let i = 0; i < 3; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-second-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 4 + i, bob: 3, system: 1 },
+        lamportTime: 8 + i,
+        timestamp: baseTime + 2.0 + i * 0.1,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: 3 + i,
+            value: '123'[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Before compaction: 10 batches (1 init + 3 alice + 3 bob + 3 alice)
+    const batchesBefore = await prisma.journalBatch.findMany({
+      where: { documentId },
+    });
+    expect(batchesBefore.length).toBe(10);
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: 4 batches (1 system + 2 alice runs + 1 bob)
+    // The new implementation preserves interleaved order, so Alice's two
+    // runs (before and after Bob) are kept separate to maintain causality
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+    expect(batchesAfter.length).toBe(4);
+
+    // Alice's first run: "abc" at position 0
+    const aliceBatch1 = batchesAfter[1]; // After system init
+    expect(aliceBatch1.sessionId).toBe('alice');
+    const aliceOps1 = aliceBatch1.operations as any[];
+    expect(aliceOps1.length).toBe(1);
+    expect(aliceOps1[0].value).toBe('abc');
+    expect(aliceOps1[0].position).toBe(0);
+
+    // Bob's operations: "xyz" at position 3
+    const bobBatch = batchesAfter[2];
+    expect(bobBatch.sessionId).toBe('bob');
+    const bobOps = bobBatch.operations as any[];
+    expect(bobOps.length).toBe(1);
+    expect(bobOps[0].value).toBe('xyz');
+    expect(bobOps[0].position).toBe(3);
+
+    // Alice's second run: "123" at position 3
+    const aliceBatch2 = batchesAfter[3];
+    expect(aliceBatch2.sessionId).toBe('alice');
+    const aliceOps2 = aliceBatch2.operations as any[];
+    expect(aliceOps2.length).toBe(1);
+    expect(aliceOps2[0].value).toBe('123');
+    expect(aliceOps2[0].position).toBe(3);
+  });
+
+  it('should handle multi-session set operations with correct LWW metadata', async () => {
+    // Create a node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'counter',
+            tag: 'Mesh',
+            name: 'Counter',
+          },
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    const baseTime = Date.now() / 1000;
+
+    // Alice sets count rapidly (within coalescing threshold)
+    const aliceValues = [10, 20, 30];
+    for (let i = 0; i < aliceValues.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 1 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: baseTime + i * 0.1, // 100ms apart (within 5s threshold)
+        ops: [
+          {
+            key: 'counter',
+            otype: 'number.set',
+            path: 'count',
+            value: aliceValues[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Bob sets count rapidly (within coalescing threshold)
+    const bobValues = [100, 200, 300];
+    for (let i = 0; i < bobValues.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-bob-${i}`,
+        sessionId: 'bob',
+        clock: { bob: 1 + i, alice: 3, system: 1 },
+        lamportTime: 5 + i,
+        timestamp: baseTime + 1.0 + i * 0.1, // 100ms apart (within 5s threshold)
+        ops: [
+          {
+            key: 'counter',
+            otype: 'number.set',
+            path: 'count',
+            value: bobValues[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: verify each session keeps only its latest set
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+
+    // Should have 3 batches: system, alice, bob
+    expect(batchesAfter.length).toBe(3);
+
+    // Alice's batch should have only the last set (30)
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    expect(aliceBatch).toBeDefined();
+    const aliceOps = aliceBatch!.operations as any[];
+    expect(aliceOps.length).toBe(1);
+    expect(aliceOps[0].otype).toBe('number.set');
+    expect(aliceOps[0].value).toBe(30);
+
+    // Bob's batch should have only the last set (300)
+    const bobBatch = batchesAfter.find(b => b.sessionId === 'bob');
+    expect(bobBatch).toBeDefined();
+    const bobOps = bobBatch!.operations as any[];
+    expect(bobOps.length).toBe(1);
+    expect(bobOps[0].otype).toBe('number.set');
+    expect(bobOps[0].value).toBe(300);
+
+    // CRITICAL: LWW resolution should use timestamps/lamportTime from metadata
+    // Bob's lamportTime (7) > Alice's lamportTime (4), so bob should win
+    expect(bobBatch!.lamportTime).toBeDefined();
+    expect(aliceBatch!.lamportTime).toBeDefined();
+    expect(bobBatch!.lamportTime!).toBeGreaterThan(aliceBatch!.lamportTime!);
+  });
+
+  it('should handle complex multi-session scenario with mixed operation types', async () => {
+    // Create scene with multiple nodes
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'cube',
+            tag: 'Mesh',
+            name: 'Cube',
+          },
+        } as Operation,
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'text-doc',
+            tag: 'Text',
+            name: 'Text Doc',
+          },
+        } as Operation,
+        {
+          key: 'text-doc',
+          otype: 'text.init',
+          path: 'content',
+          value: '',
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    const baseTime = Date.now() / 1000;
+
+    // Alice: modifies cube position (set ops) + types text
+    const aliceMessages = [
+      // Position updates
+      {
+        ops: [{ key: 'cube', otype: 'vector3.set', path: 'position', value: [1, 0, 0] }],
+        time: baseTime + 0.1,
+      },
+      {
+        ops: [{ key: 'cube', otype: 'vector3.set', path: 'position', value: [2, 0, 0] }],
+        time: baseTime + 0.2,
+      },
+      // Text inserts
+      {
+        ops: [{ key: 'text-doc', otype: 'text.insert', path: 'content', position: 0, value: 'a' }],
+        time: baseTime + 0.3,
+      },
+      {
+        ops: [{ key: 'text-doc', otype: 'text.insert', path: 'content', position: 1, value: 'b' }],
+        time: baseTime + 0.4,
+      },
+    ];
+
+    for (let i = 0; i < aliceMessages.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 2 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: aliceMessages[i].time,
+        ops: aliceMessages[i].ops as Operation[],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Bob: modifies cube rotation (set ops) + types text
+    const bobMessages = [
+      // Rotation updates
+      {
+        ops: [{ key: 'cube', otype: 'vector3.set', path: 'rotation', value: [0, 1, 0] }],
+        time: baseTime + 1.0,
+      },
+      {
+        ops: [{ key: 'cube', otype: 'vector3.set', path: 'rotation', value: [0, 2, 0] }],
+        time: baseTime + 1.1,
+      },
+      // Text inserts
+      {
+        ops: [{ key: 'text-doc', otype: 'text.insert', path: 'content', position: 2, value: 'x' }],
+        time: baseTime + 1.2,
+      },
+      {
+        ops: [{ key: 'text-doc', otype: 'text.insert', path: 'content', position: 3, value: 'y' }],
+        time: baseTime + 1.3,
+      },
+    ];
+
+    for (let i = 0; i < bobMessages.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-bob-${i}`,
+        sessionId: 'bob',
+        clock: { bob: 1 + i, alice: 5, system: 1 },
+        lamportTime: 6 + i,
+        timestamp: bobMessages[i].time,
+        ops: bobMessages[i].ops as Operation[],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Before compaction: 9 batches (1 init + 4 alice + 4 bob)
+    const batchesBefore = await prisma.journalBatch.findMany({
+      where: { documentId },
+    });
+    expect(batchesBefore.length).toBe(9);
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: 3 batches (1 system + 1 alice + 1 bob)
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+    expect(batchesAfter.length).toBe(3);
+
+    // Verify alice's batch
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    expect(aliceBatch).toBeDefined();
+    const aliceOps = aliceBatch!.operations as any[];
+    // Should have 2 ops: 1 position.set (last one) + 1 text.insert (coalesced "ab")
+    expect(aliceOps.length).toBe(2);
+
+    const alicePosOp = aliceOps.find((op: any) => op.path === 'position');
+    expect(alicePosOp).toBeDefined();
+    expect(alicePosOp.value).toEqual([2, 0, 0]);
+
+    const aliceTextOp = aliceOps.find((op: any) => op.otype === 'text.insert');
+    expect(aliceTextOp).toBeDefined();
+    expect(aliceTextOp.value).toBe('ab');
+    expect(aliceTextOp.position).toBe(0);
+
+    // Verify bob's batch
+    const bobBatch = batchesAfter.find(b => b.sessionId === 'bob');
+    expect(bobBatch).toBeDefined();
+    const bobOps = bobBatch!.operations as any[];
+    // Should have 2 ops: 1 rotation.set (last one) + 1 text.insert (coalesced "xy")
+    expect(bobOps.length).toBe(2);
+
+    const bobRotOp = bobOps.find((op: any) => op.path === 'rotation');
+    expect(bobRotOp).toBeDefined();
+    expect(bobRotOp.value).toEqual([0, 2, 0]);
+
+    const bobTextOp = bobOps.find((op: any) => op.otype === 'text.insert');
+    expect(bobTextOp).toBeDefined();
+    expect(bobTextOp.value).toBe('xy');
+    expect(bobTextOp.position).toBe(2);
+
+    // CRITICAL: Verify sessions are completely separate
+    expect(aliceBatch!.sessionId).not.toBe(bobBatch!.sessionId);
+    expect(aliceBatch!.lamportTime).not.toBe(bobBatch!.lamportTime);
+    expect(aliceBatch!.vectorClock).not.toEqual(bobBatch!.vectorClock);
+  });
+
+  it('should not merge operations even if they are identical across sessions', async () => {
+    // This tests that even if alice and bob perform the EXACT same operation,
+    // they should still be kept in separate messages with separate metadata.
+
+    // Create node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'cube',
+            tag: 'Mesh',
+            name: 'Cube',
+          },
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    const baseTime = Date.now() / 1000;
+
+    // Alice sets position to [1, 1, 1]
+    const aliceMsg: CRDTMessage = {
+      id: 'msg-alice',
+      sessionId: 'alice',
+      clock: { alice: 1, system: 1 },
+      lamportTime: 2,
+      timestamp: baseTime + 0.1,
+      ops: [
+        {
+          key: 'cube',
+          otype: 'vector3.set',
+          path: 'position',
+          value: [1, 1, 1],
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, aliceMsg);
+
+    // Bob ALSO sets position to [1, 1, 1] (identical operation)
+    const bobMsg: CRDTMessage = {
+      id: 'msg-bob',
+      sessionId: 'bob',
+      clock: { bob: 1, alice: 1, system: 1 },
+      lamportTime: 3,
+      timestamp: baseTime + 0.2,
+      ops: [
+        {
+          key: 'cube',
+          otype: 'vector3.set',
+          path: 'position',
+          value: [1, 1, 1], // SAME VALUE
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, bobMsg);
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: should STILL have 3 separate batches
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+    expect(batchesAfter.length).toBe(3);
+
+    // Verify they are kept separate
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    const bobBatch = batchesAfter.find(b => b.sessionId === 'bob');
+
+    expect(aliceBatch).toBeDefined();
+    expect(bobBatch).toBeDefined();
+
+    // Both should have the same operation value
+    const aliceOps = aliceBatch!.operations as any[];
+    const bobOps = bobBatch!.operations as any[];
+    expect(aliceOps[0].value).toEqual([1, 1, 1]);
+    expect(bobOps[0].value).toEqual([1, 1, 1]);
+
+    // But they should have different metadata
+    expect(aliceBatch!.sessionId).toBe('alice');
+    expect(bobBatch!.sessionId).toBe('bob');
+    expect(aliceBatch!.lamportTime).toBe(2);
+    expect(bobBatch!.lamportTime).toBe(3);
+  });
+
+  it('should handle single session coalescing (baseline)', async () => {
+    // This is the baseline test: operations from a SINGLE session
+    // should be coalesced as before.
+
+    // Create text node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      sessionId: 'system',
+      clock: { system: 1 },
+      lamportTime: 1,
+      timestamp: Date.now() / 1000,
+      ops: [
+        {
+          key: 'default-scene',
+          otype: 'node.insert',
+          path: 'children',
+          value: {
+            key: 'text-doc',
+            tag: 'Text',
+            name: 'Text Doc',
+          },
+        } as Operation,
+        {
+          key: 'text-doc',
+          otype: 'text.init',
+          path: 'content',
+          value: '',
+        } as Operation,
+      ],
+    };
+    await service.processMessage(documentId, initMsg);
+
+    // Alice types "hello world" (11 chars)
+    const text = 'hello world';
+    for (let i = 0; i < text.length; i++) {
+      const msg: CRDTMessage = {
+        id: `msg-alice-${i}`,
+        sessionId: 'alice',
+        clock: { alice: 1 + i, system: 1 },
+        lamportTime: 2 + i,
+        timestamp: Date.now() / 1000 + i * 0.05,
+        ops: [
+          {
+            key: 'text-doc',
+            otype: 'text.insert',
+            path: 'content',
+            position: i,
+            value: text[i],
+          } as Operation,
+        ],
+      };
+      await service.processMessage(documentId, msg);
+    }
+
+    // Before compaction: 12 batches (1 init + 11 alice)
+    const batchesBefore = await prisma.journalBatch.findMany({
+      where: { documentId },
+    });
+    expect(batchesBefore.length).toBe(12);
+
+    // Compact
+    await service.compact(documentId);
+
+    // After compaction: 2 batches (1 system + 1 alice)
+    const batchesAfter = await prisma.journalBatch.findMany({
+      where: { documentId },
+      orderBy: { lamportTime: 'asc' },
+    });
+    expect(batchesAfter.length).toBe(2);
+
+    // Alice's batch should have a single coalesced text.insert
+    const aliceBatch = batchesAfter.find(b => b.sessionId === 'alice');
+    expect(aliceBatch).toBeDefined();
+    const aliceOps = aliceBatch!.operations as any[];
+    expect(aliceOps.length).toBe(1);
+    expect(aliceOps[0].otype).toBe('text.insert');
+    expect(aliceOps[0].value).toBe('hello world');
+    expect(aliceOps[0].position).toBe(0);
+  });
+});