@vuer-ai/vuer-rtc 0.8.1 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuer-ai/vuer-rtc",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": false,
   "type": "module",
   "description": "CRDT-based real-time collaborative data structures",

package/tests/operations/operation-ordering.test.ts

@@ -0,0 +1,406 @@
+/**
+ * Test: Operation ordering bug that caused IME divergence
+ *
+ * This test reproduces the exact scenario from message-log-1772398431392.json
+ * where operations arrived with non-monotonic sequence numbers:
+ * seq: 40, 50, 59, 62, 46, 56, 64, 60, 63
+ *
+ * The fix ensures operations are sorted by Lamport timestamp before applying.
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { applyMessage, createEmptyGraph } from '../../src/operations/dispatcher.js';
+import type { CRDTMessage } from '../../src/operations/OperationTypes.js';
+
+describe('Operation Ordering - IME Divergence Bug', () => {
+  it('should apply operations in Lamport order when array has non-monotonic seq', () => {
+    // Create initial graph with text node
+    let graph = createEmptyGraph();
+
+    // Initialize root and text node
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      client: 'Misaka-08330-hy6',
+      clock: { 'Misaka-08330-hy6': 1 },
+      lt: 1,
+      ts: 1000.0,
+      ops: [
+        {
+          ot: 'node.insert',
+          key: '',
+          path: 'children',
+          value: { key: 'default-scene', tag: 'Scene', name: 'Scene' },
+        },
+        {
+          ot: 'node.insert',
+          key: 'default-scene',
+          path: 'children',
+          value: { key: 'text-doc', tag: 'Text', name: 'Text' },
+        },
+        {
+          ot: 'text.init',
+          key: 'text-doc',
+          path: 'content',
+          value: '',
+        } as any,
+      ],
+    };
+    graph = applyMessage(graph, initMsg);
+
+    // Simulate operations arriving in non-monotonic seq order
+    // This reproduces entry #21 from the divergence log
+    const msg: CRDTMessage = {
+      id: 'msg-ime',
+      client: 'Misaka-08330-hy6',
+      clock: { 'Misaka-08330-hy6': 2 },
+      lt: 64,
+      ts: 1001.0,
+      ops: [
+        // Op #1: seq:40
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:7',
+          value: [null, 'wo z'],
+          seq: 40,
+          ts: 1001.0,
+        } as any,
+        // Op #2: seq:50
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:24',
+          value: ['Misaka-08330-hy6:7', 'ch'],
+          seq: 50,
+          ts: 1001.1,
+        } as any,
+        // Op #3: seq:59 - creates ID that will be deleted
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:37',
+          value: ['Misaka-08330-hy6:24', 's'],
+          seq: 59,
+          ts: 1001.2,
+        } as any,
+        // Op #4: seq:62
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:39',
+          value: ['Misaka-08330-hy6:37', 'u r'],
+          seq: 62,
+          ts: 1001.3,
+        } as any,
+        // Op #5: seq:46 - GOES BACKWARDS!
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:17',
+          value: ['Misaka-08330-hy6:7', ' l'],
+          seq: 46,
+          ts: 1001.05,
+        } as any,
+        // Op #6: seq:56
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:33',
+          value: ['Misaka-08330-hy6:24', 'i'],
+          seq: 56,
+          ts: 1001.15,
+        } as any,
+        // Op #7: seq:64 - replace that deletes id:37 from op #3
+        {
+          ot: 'text.replace',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          length: 6,
+          value: [null, '输入'],
+          rm: [['Misaka-08330-hy6:37', 6]],
+          id: 'Misaka-08330-hy6:43',
+          seq: 64,
+          ts: 1001.4,
+        } as any,
+        // Op #8: seq:60
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:38',
+          value: ['Misaka-08330-hy6:37', 'h'],
+          seq: 60,
+          ts: 1001.25,
+        } as any,
+        // Op #9: delete (no seq shown in log, using 65)
+        {
+          ot: 'text.delete',
+          key: 'text-doc',
+          path: 'content',
+          position: 0,
+          length: 1,
+          rm: [['Misaka-08330-hy6:36', 1]],
+          seq: 65,
+          ts: 1001.45,
+        } as any,
+        // Op #10: seq:63
+        {
+          ot: 'text.insert',
+          key: 'text-doc',
+          path: 'content',
+          id: 'Misaka-08330-hy6:42',
+          value: ['Misaka-08330-hy6:38', 'u'],
+          seq: 63,
+          ts: 1001.35,
+        } as any,
+      ],
+    };
+
+    // Apply the message - operations should be sorted before applying
+    const result = applyMessage(graph, msg);
+
+    // The key test: operations should have been applied in seq order
+    // (40, 46, 50, 56, 59, 60, 62, 63, 64, 65) NOT array order
+    // This should produce consistent text without the CRDT throwing errors
+    expect(result.nodes['text-doc']).toBeDefined();
+    expect(result.nodes['text-doc'].content).toBeDefined();
+
+    // The exact text content depends on the CRDT merge logic,
+    // but it should not throw errors and should be deterministic
+    const text = String(result.nodes['text-doc'].content);
+    expect(text).toBeTruthy();
+
+    // Most importantly: this should NOT throw an error about missing IDs
+    // The replace operation (seq:64) that deletes id:37 should be applied
+    // AFTER the insert operation (seq:59) that creates id:37
+  });
+
+  it('should sort operations with only seq metadata', () => {
+    let graph = createEmptyGraph();
+
+    // Create nodes first
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      client: 'alice',
+      clock: { alice: 0 },
+      lt: 0,
+      ts: 999.0,
+      ops: [
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-1' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-2' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-3' } },
+      ],
+    };
+    graph = applyMessage(graph, initMsg);
+
+    const msg: CRDTMessage = {
+      id: 'msg-1',
+      client: 'alice',
+      clock: { alice: 1 },
+      lt: 50,
+      ts: 1000.0,
+      ops: [
+        {
+          ot: 'number.set',
+          key: 'node-1',
+          path: 'value',
+          value: 40,
+          seq: 40,
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-2',
+          path: 'value',
+          value: 30,
+          seq: 30,
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-3',
+          path: 'value',
+          value: 50,
+          seq: 50,
+        } as any,
+      ],
+    };
+
+    // Operations should be applied in seq order: 30, 40, 50
+    const result = applyMessage(graph, msg);
+    expect(result.nodes['node-1'].value).toBe(40);
+    expect(result.nodes['node-2'].value).toBe(30);
+    expect(result.nodes['node-3'].value).toBe(50);
+  });
+
+  it('should handle operations without seq/ts/id gracefully', () => {
+    let graph = createEmptyGraph();
+
+    // Create nodes first
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      client: 'alice',
+      clock: { alice: 0 },
+      lt: 0,
+      ts: 999.0,
+      ops: [
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-1' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-2' } },
+      ],
+    };
+    graph = applyMessage(graph, initMsg);
+
+    const msg: CRDTMessage = {
+      id: 'msg-1',
+      client: 'alice',
+      clock: { alice: 1 },
+      lt: 10,
+      ts: 1000.0,
+      ops: [
+        {
+          ot: 'number.set',
+          key: 'node-1',
+          path: 'value',
+          value: 1,
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-2',
+          path: 'value',
+          value: 2,
+        } as any,
+      ],
+    };
+
+    // Should not throw even without seq/ts/id
+    const result = applyMessage(graph, msg);
+    expect(result.nodes['node-1'].value).toBe(1);
+    expect(result.nodes['node-2'].value).toBe(2);
+  });
+
+  it('should use ts as tiebreaker when seq is equal', () => {
+    let graph = createEmptyGraph();
+
+    // Create nodes first
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      client: 'alice',
+      clock: { alice: 0 },
+      lt: 0,
+      ts: 999.0,
+      ops: [
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-1' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-2' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-3' } },
+      ],
+    };
+    graph = applyMessage(graph, initMsg);
+
+    const msg: CRDTMessage = {
+      id: 'msg-1',
+      client: 'alice',
+      clock: { alice: 1 },
+      lt: 40,
+      ts: 1000.0,
+      ops: [
+        {
+          ot: 'number.set',
+          key: 'node-1',
+          path: 'value',
+          value: 1,
+          seq: 40,
+          ts: 1000.2,
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-2',
+          path: 'value',
+          value: 2,
+          seq: 40,
+          ts: 1000.1,
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-3',
+          path: 'value',
+          value: 3,
+          seq: 40,
+          ts: 1000.3,
+        } as any,
+      ],
+    };
+
+    // Should sort by ts when seq is equal: 1000.1, 1000.2, 1000.3
+    const result = applyMessage(graph, msg);
+    expect(result.nodes['node-1'].value).toBe(1);
+    expect(result.nodes['node-2'].value).toBe(2);
+    expect(result.nodes['node-3'].value).toBe(3);
+  });
+
+  it('should use id as final tiebreaker', () => {
+    let graph = createEmptyGraph();
+
+    // Create nodes first
+    const initMsg: CRDTMessage = {
+      id: 'msg-init',
+      client: 'alice',
+      clock: { alice: 0 },
+      lt: 0,
+      ts: 999.0,
+      ops: [
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-1' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-2' } },
+        { ot: 'node.insert', key: '', path: 'children', value: { key: 'node-3' } },
+      ],
+    };
+    graph = applyMessage(graph, initMsg);
+
+    const msg: CRDTMessage = {
+      id: 'msg-1',
+      client: 'alice',
+      clock: { alice: 1 },
+      lt: 40,
+      ts: 1000.0,
+      ops: [
+        {
+          ot: 'number.set',
+          key: 'node-1',
+          path: 'value',
+          value: 1,
+          seq: 40,
+          ts: 1000.0,
+          id: 'charlie:1',
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-2',
+          path: 'value',
+          value: 2,
+          seq: 40,
+          ts: 1000.0,
+          id: 'alice:1',
+        } as any,
+        {
+          ot: 'number.set',
+          key: 'node-3',
+          path: 'value',
+          value: 3,
+          seq: 40,
+          ts: 1000.0,
+          id: 'bob:1',
+        } as any,
+      ],
+    };
+
+    // Should sort by id when seq and ts are equal: alice, bob, charlie
+    const result = applyMessage(graph, msg);
+    expect(result.nodes['node-1'].value).toBe(1);
+    expect(result.nodes['node-2'].value).toBe(2);
+    expect(result.nodes['node-3'].value).toBe(3);
+  });
+});