@vuer-ai/vuer-rtc 0.0.1

package/tests/client/actions.test.ts

@@ -0,0 +1,371 @@
+/**
+ * Tests for client actions
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import {
+  createInitialState,
+  onEdit,
+  commitEdits,
+  cancelEdits,
+  undo,
+  redo,
+  onRemoteMessage,
+  onServerAck,
+  compact,
+  rebuildGraph,
+} from '../../src/client/actions.js';
+import type { ClientState } from '../../src/client/types.js';
+import type { Operation, CRDTMessage } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Helper to load JSONL fixtures
+function loadFixtures<T>(filename: string): T[] {
+  const filepath = join(__dirname, '../fixtures', filename);
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+describe('Client Actions', () => {
+  let state: ClientState;
+
+  beforeEach(() => {
+    state = createInitialState('test-session');
+    // Add a test node (key=parent, path='children', value.key=new node)
+    state = onEdit(state, {
+      key: '',  // No parent for root node
+      otype: 'node.insert',
+      path: 'children',
+      value: {
+        key: 'cube-1',
+        id: 'uuid-cube-1',
+        tag: 'Mesh',
+        name: 'Cube',
+        position: [0, 0, 0],
+        opacity: 1,
+        visible: true,
+        score: 0,
+      },
+    });
+    const { state: committed } = commitEdits(state);
+    state = committed;
+  });
+
+  describe('createInitialState', () => {
+    it('should create empty state with session ID', () => {
+      const s = createInitialState('my-session');
+      expect(s.sessionId).toBe('my-session');
+      expect(s.journal).toHaveLength(0);
+      expect(s.edits.ops).toHaveLength(0);
+      expect(s.lamportTime).toBe(0);
+    });
+  });
+
+  describe('onEdit', () => {
+    it('should add operation to edit buffer', () => {
+      const op: Operation = {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      };
+      const newState = onEdit(state, op);
+      expect(newState.edits.ops).toHaveLength(1);
+      expect(newState.edits.ops[0]).toEqual(op);
+    });
+
+    it('should apply operation to graph immediately', () => {
+      const op: Operation = {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      };
+      const newState = onEdit(state, op);
+      expect(newState.graph.nodes['cube-1']?.opacity).toBe(0.5);
+    });
+
+    it('should save start graph on first edit', () => {
+      const op: Operation = {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      };
+      const newState = onEdit(state, op);
+      expect(newState.edits.startGraph).not.toBeNull();
+    });
+
+    it('should merge additive operations', () => {
+      let s = state;
+      s = onEdit(s, {
+        key: 'cube-1',
+        otype: 'vector3.add',
+        path: 'position',
+        value: [1, 0, 0],
+      });
+      s = onEdit(s, {
+        key: 'cube-1',
+        otype: 'vector3.add',
+        path: 'position',
+        value: [0, 1, 0],
+      });
+      s = onEdit(s, {
+        key: 'cube-1',
+        otype: 'vector3.add',
+        path: 'position',
+        value: [0, 0, 1],
+      });
+
+      // Should merge into single op
+      expect(s.edits.ops).toHaveLength(1);
+      expect((s.edits.ops[0] as any).value).toEqual([1, 1, 1]);
+    });
+  });
+
+  describe('commitEdits', () => {
+    it('should create message from edit buffer', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+      const { state: newState, msg } = commitEdits(s);
+
+      expect(msg).not.toBeNull();
+      expect(msg!.sessionId).toBe('test-session');
+      expect(msg!.ops).toHaveLength(1);
+    });
+
+    it('should add message to journal', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+      const { state: newState } = commitEdits(s);
+
+      // Journal should have 2 entries (node.insert + opacity)
+      expect(newState.journal.length).toBeGreaterThan(state.journal.length);
+    });
+
+    it('should clear edit buffer after commit', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+      const { state: newState } = commitEdits(s);
+
+      expect(newState.edits.ops).toHaveLength(0);
+      expect(newState.edits.startGraph).toBeNull();
+    });
+
+    it('should return null message if no edits', () => {
+      const { state: newState, msg } = commitEdits(state);
+      expect(msg).toBeNull();
+      expect(newState).toBe(state);
+    });
+  });
+
+  describe('cancelEdits', () => {
+    it('should revert to start graph', () => {
+      const originalOpacity = state.graph.nodes['cube-1']?.opacity;
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.1,
+      });
+      expect(s.graph.nodes['cube-1']?.opacity).toBe(0.1);
+
+      s = cancelEdits(s);
+      expect(s.graph.nodes['cube-1']?.opacity).toBe(originalOpacity);
+      expect(s.edits.ops).toHaveLength(0);
+    });
+  });
+
+  describe('undo/redo', () => {
+    it('should undo committed edit', () => {
+      const originalPosition = state.graph.nodes['cube-1']?.position;
+
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'vector3.set',
+        path: 'position',
+        value: [5, 5, 5],
+      });
+      const { state: committed } = commitEdits(s);
+      s = committed;
+
+      expect(s.graph.nodes['cube-1']?.position).toEqual([5, 5, 5]);
+
+      const { state: undone } = undo(s);
+      expect(undone.graph.nodes['cube-1']?.position).toEqual(originalPosition);
+    });
+
+    it('should redo after undo', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'vector3.set',
+        path: 'position',
+        value: [5, 5, 5],
+      });
+      const { state: committed } = commitEdits(s);
+      s = committed;
+
+      const { state: undone } = undo(s);
+      const { state: redone } = redo(undone);
+
+      expect(redone.graph.nodes['cube-1']?.position).toEqual([5, 5, 5]);
+    });
+
+    it('should commit and undo uncommitted edits', () => {
+      const originalPosition = state.graph.nodes['cube-1']?.position;
+
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'vector3.set',
+        path: 'position',
+        value: [5, 5, 5],
+      });
+
+      // Undo without committing first - should commit then undo
+      const { state: undone, msg } = undo(s);
+
+      expect(msg).not.toBeNull();
+      expect(undone.graph.nodes['cube-1']?.position).toEqual(originalPosition);
+    });
+  });
+
+  describe('onRemoteMessage', () => {
+    it('should apply remote message to graph', () => {
+      const remoteMsg: CRDTMessage = {
+        id: 'remote-1',
+        sessionId: 'other-session',
+        clock: { 'other-session': 1 },
+        lamportTime: 10,
+        timestamp: Date.now(),
+        ops: [
+          {
+            key: 'cube-1',
+            otype: 'number.set',
+            path: 'opacity',
+            value: 0.3,
+          },
+        ],
+      };
+
+      const newState = onRemoteMessage(state, remoteMsg);
+      expect(newState.graph.nodes['cube-1']?.opacity).toBe(0.3);
+    });
+
+    it('should skip duplicate messages', () => {
+      const remoteMsg: CRDTMessage = {
+        id: 'remote-1',
+        sessionId: 'other-session',
+        clock: { 'other-session': 1 },
+        lamportTime: 10,
+        timestamp: Date.now(),
+        ops: [
+          {
+            key: 'cube-1',
+            otype: 'number.set',
+            path: 'opacity',
+            value: 0.3,
+          },
+        ],
+      };
+
+      let s = onRemoteMessage(state, remoteMsg);
+      const journalLength = s.journal.length;
+
+      s = onRemoteMessage(s, remoteMsg);
+      expect(s.journal.length).toBe(journalLength);
+    });
+
+    it('should handle remote undo', () => {
+      // First add a message
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'vector3.set',
+        path: 'position',
+        value: [5, 5, 5],
+      });
+      const { state: committed, msg } = commitEdits(s);
+      s = onServerAck(committed, msg!.id);
+
+      expect(s.graph.nodes['cube-1']?.position).toEqual([5, 5, 5]);
+
+      // Receive remote undo
+      const undoMsg: CRDTMessage = {
+        id: 'undo-1',
+        sessionId: 'other-session',
+        clock: { 'other-session': 1 },
+        lamportTime: 20,
+        timestamp: Date.now(),
+        ops: [
+          {
+            key: '_meta',
+            otype: 'meta.undo',
+            path: '_meta',
+            targetMsgId: msg!.id,
+          },
+        ],
+      };
+
+      const undone = onRemoteMessage(s, undoMsg);
+      // Position should revert to original
+      expect(undone.graph.nodes['cube-1']?.position).toEqual([0, 0, 0]);
+    });
+  });
+
+  describe('onServerAck', () => {
+    it('should mark message as acknowledged', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+      const { state: committed, msg } = commitEdits(s);
+      s = committed;
+
+      const lastEntry = s.journal[s.journal.length - 1];
+      expect(lastEntry.ack).toBe(false);
+
+      s = onServerAck(s, msg!.id);
+      const ackedEntry = s.journal.find((e) => e.msg.id === msg!.id);
+      expect(ackedEntry?.ack).toBe(true);
+    });
+  });
+
+  describe('compact', () => {
+    it('should bake acknowledged entries into snapshot', () => {
+      let s = onEdit(state, {
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+      const { state: committed, msg } = commitEdits(s);
+      s = onServerAck(committed, msg!.id);
+
+      const journalLengthBefore = s.journal.length;
+      s = compact(s);
+
+      expect(s.journal.length).toBeLessThan(journalLengthBefore);
+      expect(s.snapshot.graph.nodes['cube-1']?.opacity).toBe(0.5);
+    });
+  });
+});

package/tests/client/edit-buffer.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Tests for EditBuffer merging logic
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { isAdditiveOp, mergeValues, EditBufferImpl } from '../../src/client/EditBuffer.js';
+import type { Operation } from '../../src/operations/OperationTypes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface EditBufferFixture {
+  name: string;
+  ops: Operation[];
+  expected_merged?: any;
+  expected_count?: number;
+}
+
+function loadFixtures(): EditBufferFixture[] {
+  const filepath = join(__dirname, '../fixtures/edit-buffer.jsonl');
+  const content = readFileSync(filepath, 'utf-8');
+  return content
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line));
+}
+
+describe('EditBuffer', () => {
+  describe('isAdditiveOp', () => {
+    it('should identify additive operations', () => {
+      expect(isAdditiveOp('vector3.add')).toBe(true);
+      expect(isAdditiveOp('number.add')).toBe(true);
+      expect(isAdditiveOp('quaternion.multiply')).toBe(true);
+    });
+
+    it('should identify non-additive operations', () => {
+      expect(isAdditiveOp('vector3.set')).toBe(false);
+      expect(isAdditiveOp('number.set')).toBe(false);
+      expect(isAdditiveOp('boolean.set')).toBe(false);
+    });
+  });
+
+  describe('mergeValues', () => {
+    it('should merge vector3.add values', () => {
+      const result = mergeValues('vector3.add', [1, 0, 0], [0, 1, 0]);
+      expect(result).toEqual([1, 1, 0]);
+    });
+
+    it('should merge number.add values', () => {
+      const result = mergeValues('number.add', 10, 5);
+      expect(result).toBe(15);
+    });
+
+    it('should replace non-additive values', () => {
+      const result = mergeValues('number.set', 10, 20);
+      expect(result).toBe(20);
+    });
+  });
+
+  describe('EditBufferImpl', () => {
+    it('should merge additive ops from fixture', () => {
+      const fixtures = loadFixtures();
+      const mergeFixture = fixtures.find((f) => f.name === 'merge_additive_ops');
+
+      const buffer = new EditBufferImpl();
+      for (const op of mergeFixture!.ops) {
+        buffer.add(op);
+      }
+
+      const ops = buffer.getOps();
+      expect(ops).toHaveLength(1);
+      expect((ops[0] as any).value).toEqual(mergeFixture!.expected_merged.value);
+    });
+
+    it('should replace LWW ops from fixture', () => {
+      const fixtures = loadFixtures();
+      const replaceFixture = fixtures.find((f) => f.name === 'replace_lww_ops');
+
+      const buffer = new EditBufferImpl();
+      for (const op of replaceFixture!.ops) {
+        buffer.add(op);
+      }
+
+      const ops = buffer.getOps();
+      expect(ops).toHaveLength(1);
+      expect((ops[0] as any).value).toBe(replaceFixture!.expected_merged.value);
+    });
+
+    it('should handle multiple properties from fixture', () => {
+      const fixtures = loadFixtures();
+      const multiFixture = fixtures.find((f) => f.name === 'multiple_properties');
+
+      const buffer = new EditBufferImpl();
+      for (const op of multiFixture!.ops) {
+        buffer.add(op);
+      }
+
+      const ops = buffer.getOps();
+      expect(ops).toHaveLength(multiFixture!.expected_count!);
+    });
+
+    it('should clear buffer', () => {
+      const buffer = new EditBufferImpl();
+      buffer.add({
+        key: 'cube-1',
+        otype: 'number.set',
+        path: 'opacity',
+        value: 0.5,
+      });
+
+      buffer.clear();
+      expect(buffer.getOps()).toHaveLength(0);
+    });
+  });
+});

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/node-ops.jsonl

@@ -0,0 +1,6 @@
+{"name": "node_insert_root", "op": {"key": "", "otype": "node.insert", "path": "children", "value": {"key": "scene", "id": "uuid-scene", "tag": "Scene", "name": "Root Scene"}}}
+{"name": "node_insert_mesh", "op": {"key": "scene", "otype": "node.insert", "path": "children", "value": {"key": "cube-1", "id": "uuid-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", "id": "uuid-group-1", "tag": "Group", "name": "Group"}}}
+{"name": "node_insert_nested", "op": {"key": "group-1", "otype": "node.insert", "path": "children", "value": {"key": "sphere-1", "id": "uuid-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]}}