@vuer-ai/vuer-rtc-server 0.1.1

package/tests/e2e/text-sync.test.ts

@@ -0,0 +1,199 @@
+/**
+ * E2E: Text CRDT sync through the server.
+ *
+ * Verifies that text operations (init, insert) propagate correctly
+ * between clients through the RTCServer relay, including recovery
+ * from packet loss and convergence of concurrent edits.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { createTestServer, type TestServer } from './helpers/createTestServer.js';
+import { waitForConvergence, assertGraphsEqual } from './helpers/assertions.js';
+import type { GraphStore } from '@vuer-ai/vuer-rtc';
+
+// ── Helpers ───────────────────────────────────────────────────
+
+/** Insert a scene root + a text node so text ops have a target. */
+function seedTextGraph(store: GraphStore): void {
+  store.edit({
+    otype: 'node.insert',
+    key: '',
+    path: 'children',
+    value: { key: 'scene', tag: 'Scene', name: 'Scene' },
+  });
+  store.edit({
+    otype: 'node.insert',
+    key: 'scene',
+    path: 'children',
+    value: { key: 'text-doc', tag: 'Text', name: 'Doc' },
+  });
+  store.commit('seed scene');
+}
+
+/** Small delay to let async message delivery happen. */
+const tick = (ms = 50) => new Promise((r) => setTimeout(r, ms));
+
+// ── Tests ─────────────────────────────────────────────────────
+
+describe('text-sync', () => {
+  let ts: TestServer;
+
+  beforeEach(() => {
+    ts = createTestServer();
+  });
+
+  afterEach(() => {
+    ts.close();
+  });
+
+  // ── 1. Text edits propagate between clients ─────────────────
+
+  it('text edits propagate between clients', async () => {
+    const clientA = ts.connectClient('room-1', 'session-a');
+    const clientB = ts.connectClient('room-1', 'session-b');
+
+    // Seed the graph from A and wait for B to catch up
+    seedTextGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    // Init text on the text-doc node
+    clientA.store.edit({
+      otype: 'text.init',
+      key: 'text-doc',
+      path: 'content',
+      value: '',
+    } as any);
+    clientA.store.commit('init text');
+    await tick();
+
+    // Insert "Hello"
+    clientA.store.edit({
+      otype: 'text.insert',
+      key: 'text-doc',
+      path: 'content',
+      position: 0,
+      value: 'Hello',
+    } as any);
+    clientA.store.commit('type hello');
+
+    // Wait for B to converge
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+
+    assertGraphsEqual(graphA, graphB);
+    expect(graphA.nodes['text-doc'].content).toBe('Hello');
+    expect(graphB.nodes['text-doc'].content).toBe('Hello');
+  });
+
+  // ── 2. Text edits recover via sync after packet loss ────────
+
+  it('text edits recover via sync after packet loss', async () => {
+    const clientA = ts.connectClient('room-1', 'session-a');
+    const clientB = ts.connectClient('room-1', 'session-b', { dropRate: 1.0 });
+
+    // Seed the graph — B will miss this due to 100% drop
+    seedTextGraph(clientA.store);
+    await tick(100);
+
+    // B should have nothing
+    expect(Object.keys(clientB.store.getState().graph.nodes).length).toBe(0);
+
+    // Alice inits text and types while Bob has 100% drop rate
+    clientA.store.edit({
+      otype: 'text.init',
+      key: 'text-doc',
+      path: 'content',
+      value: '',
+    } as any);
+    clientA.store.commit('init text');
+    await tick();
+
+    clientA.store.edit({
+      otype: 'text.insert',
+      key: 'text-doc',
+      path: 'content',
+      position: 0,
+      value: 'Hello',
+    } as any);
+    clientA.store.commit('type hello');
+    await tick(100);
+
+    // Bob still has nothing
+    expect(Object.keys(clientB.store.getState().graph.nodes).length).toBe(0);
+
+    // Disable drop, retry unacked, and send sync to recover
+    clientB.disableDrop();
+    clientA.retryUnacked();
+    await tick(100);
+    clientB.sendSync();
+
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+
+    assertGraphsEqual(graphA, graphB);
+    expect(graphB.nodes['text-doc'].content).toBe('Hello');
+  });
+
+  // ── 3. Concurrent text edits converge ─────────────────────
+
+  it('concurrent text edits converge', async () => {
+    const clientA = ts.connectClient('room-1', 'session-a');
+    const clientB = ts.connectClient('room-1', 'session-b');
+
+    // Seed the graph from A and wait for B to catch up
+    seedTextGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    // Both clients init text
+    clientA.store.edit({
+      otype: 'text.init',
+      key: 'text-doc',
+      path: 'content',
+      value: '',
+    } as any);
+    clientA.store.commit('A init text');
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    // Both clients type concurrently (before seeing each other's edits)
+    clientA.store.edit({
+      otype: 'text.insert',
+      key: 'text-doc',
+      path: 'content',
+      position: 0,
+      value: 'AAA',
+    } as any);
+
+    clientB.store.edit({
+      otype: 'text.insert',
+      key: 'text-doc',
+      path: 'content',
+      position: 0,
+      value: 'BBB',
+    } as any);
+
+    // Both commit before either receives the other's edit
+    clientA.store.commit('A types AAA');
+    clientB.store.commit('B types BBB');
+
+    // Wait for all messages to be delivered and graphs to converge
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+
+    // Graphs should be identical — the text CRDT resolves the conflict
+    assertGraphsEqual(graphA, graphB);
+
+    // Both "AAA" and "BBB" should be present in the final text
+    const textA = graphA.nodes['text-doc'].content as string;
+    const textB = graphB.nodes['text-doc'].content as string;
+    expect(textA).toBe(textB);
+    expect(textA).toContain('AAA');
+    expect(textA).toContain('BBB');
+    expect(textA.length).toBe(6);
+  });
+});

package/tests/e2e/tombstone-convergence.test.ts

@@ -0,0 +1,356 @@
+/**
+ * E2E: Operations on tombstoned nodes must still converge.
+ *
+ * Regression tests for the bug where `node._crdt?.deletedAt` guards in
+ * property operation handlers (number.add, vector3.set, etc.) caused
+ * operations to be silently dropped when a node was already tombstoned
+ * in one client's journal but not another's.
+ *
+ * The fix: property operations always apply regardless of `deletedAt`.
+ * Only `node.move` checks `deletedAt` (moving a deleted node is no-op).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { createTestServer, type TestServer } from './helpers/createTestServer.js';
+import { waitForConvergence, assertGraphsEqual } from './helpers/assertions.js';
+import type { GraphStore } from '@vuer-ai/vuer-rtc';
+
+// ── Helpers ───────────────────────────────────────────────────
+
+function seedGraph(store: GraphStore): void {
+  store.edit({
+    otype: 'node.insert',
+    key: '',
+    path: 'children',
+    value: { key: 'scene', tag: 'Scene', name: 'Scene' },
+  });
+  store.edit({
+    otype: 'node.insert',
+    key: 'scene',
+    path: 'children',
+    value: {
+      key: 'cube-1',
+      tag: 'Mesh',
+      name: 'Cube',
+      position: [0, 0, 0],
+      opacity: 1,
+      counter: 0,
+    },
+  });
+  store.commit('seed scene');
+}
+
+// ── Tests ─────────────────────────────────────────────────────
+
+describe('tombstone convergence', () => {
+  let ts: TestServer;
+
+  beforeEach(() => {
+    ts = createTestServer();
+  });
+
+  afterEach(() => {
+    ts.close();
+  });
+
+  // ── 1. number.add after node.remove (the original bug) ──────
+
+  it('number.add on deleted node converges', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice');
+    const clientB = ts.connectClient('room-1', 'Bob');
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    // Bob increments counter several times
+    for (let i = 0; i < 5; i++) {
+      clientB.store.edit({
+        otype: 'number.add',
+        key: 'cube-1',
+        path: 'counter',
+        value: 1,
+      });
+      clientB.store.commit(`counter +1 (${i})`);
+    }
+
+    // Alice deletes the node concurrently (before receiving all of Bob's adds)
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+
+    // Both should have counter = 5 on the tombstoned node
+    expect(graphA.nodes['cube-1'].counter).toBe(5);
+    expect(graphA.nodes['cube-1']._crdt?.deletedAt).toBeDefined();
+  });
+
+  // ── 2. vector3.set after node.remove ─────────────────────────
+
+  it('vector3.set on deleted node converges', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice');
+    const clientB = ts.connectClient('room-1', 'Bob');
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    // Bob sets position
+    clientB.store.edit({
+      otype: 'vector3.set',
+      key: 'cube-1',
+      path: 'position',
+      value: [99, 99, 99],
+    });
+    clientB.store.commit('set position');
+
+    // Alice deletes concurrently
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+
+    // Position should be [99, 99, 99] on both even though node is tombstoned
+    expect(graphA.nodes['cube-1'].position).toEqual([99, 99, 99]);
+  });
+
+  // ── 3. number.add with latency (forces different journal orderings) ──
+
+  it('number.add + delete with latency converges', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice', { latencyMs: 50 });
+    const clientB = ts.connectClient('room-1', 'Bob', { latencyMs: 50 });
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    // Bob sends 5 counter increments
+    for (let i = 0; i < 5; i++) {
+      clientB.store.edit({
+        otype: 'number.add',
+        key: 'cube-1',
+        path: 'counter',
+        value: 1,
+      });
+      clientB.store.commit(`counter +1 (${i})`);
+    }
+
+    // Alice deletes after a short delay (overlapping with Bob's adds in flight)
+    await new Promise((r) => setTimeout(r, 20));
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store], 5000);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+
+    expect(graphA.nodes['cube-1'].counter).toBe(5);
+  });
+
+  // ── 4. Multiple property types on deleted node ──────────────
+
+  it('mixed ops on deleted node converge', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice');
+    const clientB = ts.connectClient('room-1', 'Bob');
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    // Bob edits multiple properties
+    clientB.store.edit({
+      otype: 'number.add',
+      key: 'cube-1',
+      path: 'counter',
+      value: 10,
+    });
+    clientB.store.edit({
+      otype: 'number.set',
+      key: 'cube-1',
+      path: 'opacity',
+      value: 0.5,
+    });
+    clientB.store.edit({
+      otype: 'vector3.set',
+      key: 'cube-1',
+      path: 'position',
+      value: [1, 2, 3],
+    });
+    clientB.store.commit('multi-edit');
+
+    // Alice deletes concurrently
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+
+    expect(graphA.nodes['cube-1'].counter).toBe(10);
+    expect(graphA.nodes['cube-1'].opacity).toBe(0.5);
+    expect(graphA.nodes['cube-1'].position).toEqual([1, 2, 3]);
+  });
+
+  // ── 5. Three clients: two edit, one deletes ─────────────────
+
+  it('three clients: edits + delete converge', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice');
+    const clientB = ts.connectClient('room-1', 'Bob');
+    const clientC = ts.connectClient('room-1', 'Charlie');
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store, clientC.store]);
+
+    // Bob and Charlie both increment counter
+    clientB.store.edit({
+      otype: 'number.add',
+      key: 'cube-1',
+      path: 'counter',
+      value: 3,
+    });
+    clientB.store.commit('Bob +3');
+
+    clientC.store.edit({
+      otype: 'number.add',
+      key: 'cube-1',
+      path: 'counter',
+      value: 7,
+    });
+    clientC.store.commit('Charlie +7');
+
+    // Alice deletes
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store, clientC.store]);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    const graphC = clientC.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+    assertGraphsEqual(graphA, graphC);
+
+    // counter: 0 + 3 + 7 = 10
+    expect(graphA.nodes['cube-1'].counter).toBe(10);
+    expect(graphA.nodes['cube-1']._crdt?.deletedAt).toBeDefined();
+  });
+
+  // ── 6. Delete then edit from same client ────────────────────
+
+  it('edit after own delete still converges', async () => {
+    const clientA = ts.connectClient('room-1', 'Alice');
+    const clientB = ts.connectClient('room-1', 'Bob');
+
+    seedGraph(clientA.store);
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    // Alice deletes the cube
+    clientA.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    clientA.store.commit('delete cube');
+
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    // Now Bob (who received the delete) still increments the counter
+    // This tests that operations on tombstoned nodes work even from
+    // clients that know the node is deleted
+    clientB.store.edit({
+      otype: 'number.add',
+      key: 'cube-1',
+      path: 'counter',
+      value: 42,
+    });
+    clientB.store.commit('counter +42 on deleted');
+
+    await waitForConvergence([clientA.store, clientB.store]);
+
+    const graphA = clientA.store.getState().graph;
+    const graphB = clientB.store.getState().graph;
+    assertGraphsEqual(graphA, graphB);
+
+    expect(graphA.nodes['cube-1'].counter).toBe(42);
+  });
+
+  // ── 7. Latency + 4 clients (reproducing the debug trace) ───
+
+  it('4-client counter + delete with latency (debug trace repro)', async () => {
+    const alice = ts.connectClient('room-1', 'Alice', { latencyMs: 30 });
+    const bob = ts.connectClient('room-1', 'Bob', { latencyMs: 30 });
+    const charlie = ts.connectClient('room-1', 'Charlie', { latencyMs: 30 });
+    const diana = ts.connectClient('room-1', 'Diana', { latencyMs: 30 });
+
+    const stores = [alice.store, bob.store, charlie.store, diana.store];
+
+    seedGraph(alice.store);
+    await waitForConvergence(stores, 5000);
+
+    // Bob sends 5 counter increments
+    for (let i = 0; i < 5; i++) {
+      bob.store.edit({
+        otype: 'number.add',
+        key: 'cube-1',
+        path: 'counter',
+        value: 1,
+      });
+      bob.store.commit(`Bob counter +1 (${i})`);
+    }
+
+    // Alice deletes the node (may interleave with Bob's adds)
+    await new Promise((r) => setTimeout(r, 10));
+    alice.store.edit({
+      otype: 'node.remove',
+      key: 'scene',
+      path: 'children',
+      value: 'cube-1',
+    });
+    alice.store.commit('Alice delete cube');
+
+    await waitForConvergence(stores, 5000);
+
+    const graphs = stores.map((s) => s.getState().graph);
+    assertGraphsEqual(graphs[0], graphs[1]);
+    assertGraphsEqual(graphs[0], graphs[2]);
+    assertGraphsEqual(graphs[0], graphs[3]);
+
+    // All clients must see counter = 5
+    expect(graphs[0].nodes['cube-1'].counter).toBe(5);
+    expect(graphs[0].nodes['cube-1']._crdt?.deletedAt).toBeDefined();
+  });
+});

package/tests/fixtures/array-ops.jsonl

@@ -0,0 +1,6 @@
+{"name": "array_set", "op": {"key": "node-1", "otype": "array.set", "path": "tags", "value": ["enemy", "active"]}}
+{"name": "array_set_empty", "op": {"key": "node-1", "otype": "array.set", "path": "tags", "value": []}}
+{"name": "array_push", "op": {"key": "node-1", "otype": "array.push", "path": "tags", "value": "new-tag"}}
+{"name": "array_push_number", "op": {"key": "node-1", "otype": "array.push", "path": "scores", "value": 100}}
+{"name": "array_union", "op": {"key": "node-1", "otype": "array.union", "path": "tags", "value": ["tag-a", "tag-b"]}}
+{"name": "array_remove", "op": {"key": "node-1", "otype": "array.remove", "path": "tags", "value": "enemy"}}

package/tests/fixtures/boolean-ops.jsonl

@@ -0,0 +1,6 @@
+{"name": "boolean_set_true", "op": {"key": "node-1", "otype": "boolean.set", "path": "visible", "value": true}}
+{"name": "boolean_set_false", "op": {"key": "node-1", "otype": "boolean.set", "path": "visible", "value": false}}
+{"name": "boolean_or_true", "op": {"key": "node-1", "otype": "boolean.or", "path": "enabled", "value": true}}
+{"name": "boolean_or_false", "op": {"key": "node-1", "otype": "boolean.or", "path": "enabled", "value": false}}
+{"name": "boolean_and_true", "op": {"key": "node-1", "otype": "boolean.and", "path": "active", "value": true}}
+{"name": "boolean_and_false", "op": {"key": "node-1", "otype": "boolean.and", "path": "active", "value": false}}

package/tests/fixtures/color-ops.jsonl

@@ -0,0 +1,4 @@
+{"name": "color_set_red", "op": {"key": "node-1", "otype": "color.set", "path": "color", "value": "#ff0000"}}
+{"name": "color_set_green", "op": {"key": "node-1", "otype": "color.set", "path": "color", "value": "#00ff00"}}
+{"name": "color_set_rgb", "op": {"key": "node-1", "otype": "color.set", "path": "color", "value": "#336699"}}
+{"name": "color_blend", "op": {"key": "node-1", "otype": "color.blend", "path": "color", "value": "#ffffff"}}

package/tests/fixtures/edit-buffer.jsonl

@@ -0,0 +1,3 @@
+{"name": "merge_additive_ops", "ops": [{"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [1, 0, 0]}, {"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [0, 1, 0]}, {"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [0, 0, 1]}], "expected_merged": {"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [1, 1, 1]}}
+{"name": "replace_lww_ops", "ops": [{"key": "cube-1", "otype": "number.set", "path": "opacity", "value": 0.3}, {"key": "cube-1", "otype": "number.set", "path": "opacity", "value": 0.7}], "expected_merged": {"key": "cube-1", "otype": "number.set", "path": "opacity", "value": 0.7}}
+{"name": "multiple_properties", "ops": [{"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [1, 0, 0]}, {"key": "cube-1", "otype": "number.set", "path": "opacity", "value": 0.5}], "expected_count": 2}

package/tests/fixtures/messages.jsonl

@@ -0,0 +1,4 @@
+{"name": "simple_edit", "msg": {"id": "msg-1", "sessionId": "session-1", "clock": {"session-1": 1}, "lamportTime": 1, "timestamp": 1700000000000, "ops": [{"key": "cube-1", "otype": "vector3.set", "path": "position", "value": [1, 2, 3]}]}}
+{"name": "additive_edit", "msg": {"id": "msg-2", "sessionId": "session-1", "clock": {"session-1": 2}, "lamportTime": 2, "timestamp": 1700000001000, "ops": [{"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [0.1, 0.2, 0.3]}]}}
+{"name": "undo_edit", "msg": {"id": "msg-3", "sessionId": "session-1", "clock": {"session-1": 3}, "lamportTime": 3, "timestamp": 1700000002000, "ops": [{"key": "_meta", "otype": "meta.undo", "path": "_meta", "targetMsgId": "msg-1"}]}}
+{"name": "redo_edit", "msg": {"id": "msg-4", "sessionId": "session-1", "clock": {"session-1": 4}, "lamportTime": 4, "timestamp": 1700000003000, "ops": [{"key": "_meta", "otype": "meta.redo", "path": "_meta", "targetMsgId": "msg-1"}]}}

package/tests/fixtures/node-ops.jsonl

@@ -0,0 +1,6 @@
+{"name": "node_insert_root", "op": {"key": "", "otype": "node.insert", "path": "children", "value": {"key": "scene", "tag": "Scene", "name": "Root Scene"}}}
+{"name": "node_insert_mesh", "op": {"key": "scene", "otype": "node.insert", "path": "children", "value": {"key": "cube-1", "tag": "Mesh", "name": "Cube", "position": [0, 0, 0], "scale": [1, 1, 1]}}}
+{"name": "node_insert_group", "op": {"key": "scene", "otype": "node.insert", "path": "children", "value": {"key": "group-1", "tag": "Group", "name": "Group"}}}
+{"name": "node_insert_nested", "op": {"key": "group-1", "otype": "node.insert", "path": "children", "value": {"key": "sphere-1", "tag": "Mesh", "name": "Sphere"}}}
+{"name": "node_remove", "op": {"key": "scene", "otype": "node.remove", "path": "children", "value": "cube-1"}}
+{"name": "node_remove_nested", "op": {"key": "group-1", "otype": "node.remove", "path": "children", "value": "sphere-1"}}

package/tests/fixtures/number-ops.jsonl

@@ -0,0 +1,7 @@
+{"name": "number_set", "op": {"key": "node-1", "otype": "number.set", "path": "opacity", "value": 0.5}}
+{"name": "number_add", "op": {"key": "node-1", "otype": "number.add", "path": "score", "value": 10}}
+{"name": "number_multiply", "op": {"key": "node-1", "otype": "number.multiply", "path": "scale", "value": 2}}
+{"name": "number_min", "op": {"key": "node-1", "otype": "number.min", "path": "health", "value": 50}}
+{"name": "number_max", "op": {"key": "node-1", "otype": "number.max", "path": "damage", "value": 25}}
+{"name": "number_add_negative", "op": {"key": "node-1", "otype": "number.add", "path": "score", "value": -5}}
+{"name": "number_multiply_fraction", "op": {"key": "node-1", "otype": "number.multiply", "path": "scale", "value": 0.5}}

package/tests/fixtures/object-ops.jsonl

@@ -0,0 +1,4 @@
+{"name": "object_set", "op": {"key": "node-1", "otype": "object.set", "path": "metadata", "value": {"author": "user-1", "version": 1}}}
+{"name": "object_set_empty", "op": {"key": "node-1", "otype": "object.set", "path": "metadata", "value": {}}}
+{"name": "object_merge", "op": {"key": "node-1", "otype": "object.merge", "path": "metadata", "value": {"tags": ["a", "b"]}}}
+{"name": "object_merge_nested", "op": {"key": "node-1", "otype": "object.merge", "path": "config", "value": {"settings": {"enabled": true}}}}

package/tests/fixtures/operations.jsonl

@@ -0,0 +1,7 @@
+{"name": "number.set", "op": {"key": "cube-1", "otype": "number.set", "path": "opacity", "value": 0.5}, "expected": {"opacity": 0.5}}
+{"name": "number.add", "op": {"key": "cube-1", "otype": "number.add", "path": "score", "value": 10}, "expected": {"score": 10}}
+{"name": "vector3.set", "op": {"key": "cube-1", "otype": "vector3.set", "path": "position", "value": [1, 2, 3]}, "expected": {"position": [1, 2, 3]}}
+{"name": "vector3.add", "op": {"key": "cube-1", "otype": "vector3.add", "path": "position", "value": [0.1, 0.2, 0.3]}, "initial": {"position": [1, 2, 3]}, "expected": {"position": [1.1, 2.2, 3.3]}}
+{"name": "boolean.set", "op": {"key": "cube-1", "otype": "boolean.set", "path": "visible", "value": false}, "expected": {"visible": false}}
+{"name": "string.set", "op": {"key": "cube-1", "otype": "string.set", "path": "name", "value": "MyCube"}, "expected": {"name": "MyCube"}}
+{"name": "node.insert", "op": {"key": "sphere-1", "otype": "node.insert", "path": "sphere-1", "value": {"id": "uuid-sphere", "tag": "Mesh", "name": "Sphere"}}, "expected": {"nodes": {"sphere-1": {"id": "uuid-sphere", "tag": "Mesh", "name": "Sphere"}}}}

package/tests/fixtures/string-ops.jsonl

@@ -0,0 +1,4 @@
+{"name": "string_set", "op": {"key": "node-1", "otype": "string.set", "path": "name", "value": "Player"}}
+{"name": "string_set_empty", "op": {"key": "node-1", "otype": "string.set", "path": "name", "value": ""}}
+{"name": "string_concat", "op": {"key": "node-1", "otype": "string.concat", "path": "tags", "value": "active"}}
+{"name": "string_concat_separator", "op": {"key": "node-1", "otype": "string.concat", "path": "tags", "value": "enemy", "separator": ","}}

package/tests/fixtures/undo-redo.jsonl

@@ -0,0 +1,3 @@
+{"name": "undo_single_edit", "steps": [{"action": "edit", "op": {"key": "cube-1", "otype": "vector3.set", "path": "position", "value": [5, 5, 5]}}, {"action": "commit"}, {"action": "undo"}], "expected": {"position": [0, 0, 0]}}
+{"name": "redo_after_undo", "steps": [{"action": "edit", "op": {"key": "cube-1", "otype": "vector3.set", "path": "position", "value": [5, 5, 5]}}, {"action": "commit"}, {"action": "undo"}, {"action": "redo"}], "expected": {"position": [5, 5, 5]}}
+{"name": "undo_uncommitted", "steps": [{"action": "edit", "op": {"key": "cube-1", "otype": "vector3.set", "path": "position", "value": [5, 5, 5]}}, {"action": "undo"}], "expected": {"position": [0, 0, 0]}}

package/tests/fixtures/vector-ops.jsonl

@@ -0,0 +1,9 @@
+{"name": "vector3_set", "op": {"key": "node-1", "otype": "vector3.set", "path": "position", "value": [1, 2, 3]}}
+{"name": "vector3_set_zero", "op": {"key": "node-1", "otype": "vector3.set", "path": "position", "value": [0, 0, 0]}}
+{"name": "vector3_add", "op": {"key": "node-1", "otype": "vector3.add", "path": "position", "value": [0.5, 0.5, 0.5]}}
+{"name": "vector3_add_negative", "op": {"key": "node-1", "otype": "vector3.add", "path": "position", "value": [-1, -1, -1]}}
+{"name": "vector3_multiply", "op": {"key": "node-1", "otype": "vector3.multiply", "path": "scale", "value": [2, 2, 2]}}
+{"name": "vector3_multiply_non_uniform", "op": {"key": "node-1", "otype": "vector3.multiply", "path": "scale", "value": [1, 2, 3]}}
+{"name": "quaternion_set", "op": {"key": "node-1", "otype": "quaternion.set", "path": "rotation", "value": [0, 0, 0, 1]}}
+{"name": "quaternion_set_rotated", "op": {"key": "node-1", "otype": "quaternion.set", "path": "rotation", "value": [0, 0.7071, 0, 0.7071]}}
+{"name": "quaternion_multiply", "op": {"key": "node-1", "otype": "quaternion.multiply", "path": "rotation", "value": [0, 0.3827, 0, 0.9239]}}