@vuer-ai/vuer-rtc 0.0.1

package/examples/03-scene-building.ts

@@ -0,0 +1,258 @@
+/**
+ * Example 03: Scene Building
+ *
+ * Demonstrates building a complete scene with batched operations,
+ * reparenting, and node deletion.
+ * Run with: npx tsx examples/03-scene-building.ts
+ */
+
+import { createEmptyGraph, applyMessage, applyMessages } from '../src/operations/index.js';
+import type { CRDTMessage } from '../src/operations/index.js';
+
+console.log('🎬 Example 03: Scene Building\n');
+
+// ============================================
+// Step 1: Create initial scene structure
+// ============================================
+
+console.log('--- Step 1: Create Scene with Multiple Objects ---\n');
+
+const initScene: CRDTMessage = {
+  id: 'init',
+  sessionId: 'server',
+  clock: { server: 1 },
+  lamportTime: 1,
+  timestamp: Date.now(),
+  ops: [
+    // Scene root (no parent - it's the root)
+    {
+      key: 'scene',
+      otype: 'node.insert',
+      path: 'scene',
+      value: {
+        id: 'uuid-scene',
+        tag: 'Scene',
+        name: 'Game Level',
+        background: '#1a1a2e',
+      },
+    },
+    // Player (parent: scene)
+    {
+      key: 'player',
+      otype: 'node.insert',
+      path: 'player',
+      parent: 'scene',
+      value: {
+        id: 'uuid-player',
+        tag: 'Mesh',
+        name: 'Player',
+        color: '#00ff00',
+        health: 100,
+        'transform.position': [0, 1, 0],
+        'transform.scale': [1, 2, 1],
+      },
+    },
+    // Enemy 1 (parent: scene)
+    {
+      key: 'enemy-1',
+      otype: 'node.insert',
+      path: 'enemy-1',
+      parent: 'scene',
+      value: {
+        id: 'uuid-enemy-1',
+        tag: 'Mesh',
+        name: 'Goblin',
+        color: '#ff0000',
+        health: 50,
+        'transform.position': [10, 1, 5],
+      },
+    },
+    // Enemy 2 (parent: scene)
+    {
+      key: 'enemy-2',
+      otype: 'node.insert',
+      path: 'enemy-2',
+      parent: 'scene',
+      value: {
+        id: 'uuid-enemy-2',
+        tag: 'Mesh',
+        name: 'Orc',
+        color: '#880000',
+        health: 100,
+        'transform.position': [-10, 1, 5],
+      },
+    },
+  ],
+};
+
+let graph = applyMessage(createEmptyGraph(), initScene);
+
+console.log('Created nodes:', Object.keys(graph.nodes));
+console.log('Scene children:', graph.nodes['scene'].children);
+
+// ============================================
+// Step 2: Create a group and reparent enemies
+// ============================================
+
+console.log('\n--- Step 2: Reparent Enemies into Group ---\n');
+
+const reparent: CRDTMessage = {
+  id: 'reparent',
+  sessionId: 'alice',
+  clock: { alice: 1 },
+  lamportTime: 2,
+  timestamp: Date.now(),
+  ops: [
+    // Create enemies group (parent: scene)
+    {
+      key: 'enemies',
+      otype: 'node.insert',
+      path: 'enemies',
+      parent: 'scene',
+      value: {
+        id: 'uuid-enemies',
+        tag: 'Group',
+        name: 'Enemies',
+        'transform.position': [0, 0, 0],
+      },
+    },
+    // Remove enemies from scene and add to group
+    {
+      key: 'scene',
+      otype: 'array.remove',
+      path: 'children',
+      value: 'enemy-1',
+    },
+    {
+      key: 'scene',
+      otype: 'array.remove',
+      path: 'children',
+      value: 'enemy-2',
+    },
+    {
+      key: 'enemies',
+      otype: 'array.set',
+      path: 'children',
+      value: ['enemy-1', 'enemy-2'],
+    },
+  ],
+};
+
+graph = applyMessage(graph, reparent);
+
+console.log('Scene children:', graph.nodes['scene'].children);
+console.log('Enemies group children:', graph.nodes['enemies'].children);
+
+// ============================================
+// Step 3: Batch update - damage all enemies
+// ============================================
+
+console.log('\n--- Step 3: Batch Update - Damage All Enemies ---\n');
+
+const damageAll: CRDTMessage = {
+  id: 'damage',
+  sessionId: 'player',
+  clock: { player: 1 },
+  lamportTime: 3,
+  timestamp: Date.now(),
+  ops: [
+    {
+      key: 'enemy-1',
+      otype: 'number.add',
+      path: 'health',
+      value: -30, // Take 30 damage
+    },
+    {
+      key: 'enemy-2',
+      otype: 'number.add',
+      path: 'health',
+      value: -30, // Take 30 damage
+    },
+  ],
+};
+
+graph = applyMessage(graph, damageAll);
+
+console.log('Enemy 1 health:', graph.nodes['enemy-1'].health);
+console.log('Enemy 2 health:', graph.nodes['enemy-2'].health);
+
+// ============================================
+// Step 4: Delete dead enemy
+// ============================================
+
+console.log('\n--- Step 4: Kill Enemy 1 ---\n');
+
+// More damage to enemy-1
+const killEnemy1: CRDTMessage = {
+  id: 'kill',
+  sessionId: 'player',
+  clock: { player: 2 },
+  lamportTime: 4,
+  timestamp: Date.now(),
+  ops: [
+    {
+      key: 'enemy-1',
+      otype: 'number.add',
+      path: 'health',
+      value: -20, // Now at 0
+    },
+  ],
+};
+
+graph = applyMessage(graph, killEnemy1);
+console.log('Enemy 1 health after damage:', graph.nodes['enemy-1'].health);
+
+// Remove dead enemy
+const removeEnemy1: CRDTMessage = {
+  id: 'remove-enemy',
+  sessionId: 'server',
+  clock: { server: 2 },
+  lamportTime: 5,
+  timestamp: Date.now(),
+  ops: [
+    {
+      key: 'enemies',
+      otype: 'array.remove',
+      path: 'children',
+      value: 'enemy-1',
+    },
+    {
+      key: 'enemy-1',
+      otype: 'node.remove',
+      path: 'enemy-1',
+    },
+  ],
+};
+
+graph = applyMessage(graph, removeEnemy1);
+
+console.log('Enemy 1 deleted:', graph.nodes['enemy-1'].deletedAt !== undefined);
+console.log('Enemies group children:', graph.nodes['enemies'].children);
+
+// ============================================
+// Final Scene Tree
+// ============================================
+
+console.log('\n📊 Final Scene Tree:\n');
+
+function printTree(key: string, indent = 0) {
+  const node = graph.nodes[key];
+  if (!node || node.deletedAt) return;
+
+  const prefix = '  '.repeat(indent);
+  const health = node.health !== undefined ? ` (health: ${node.health})` : '';
+  console.log(`${prefix}├─ ${node.name} [${node.tag}]${health}`);
+
+  for (const childKey of node.children || []) {
+    printTree(childKey, indent + 1);
+  }
+}
+
+console.log('scene');
+printTree('scene');
+
+console.log('\n📊 All nodes (including tombstones):');
+for (const [key, node] of Object.entries(graph.nodes)) {
+  const status = node.deletedAt ? '❌ DELETED' : '✅ ACTIVE';
+  console.log(`  ${key}: ${status}`);
+}

package/examples/04-conflict-resolution.ts

@@ -0,0 +1,339 @@
+/**
+ * Example 04: Conflict Resolution
+ *
+ * Demonstrates how CRDT resolves conflicts when messages arrive out-of-order.
+ * Run with: npx tsx examples/04-conflict-resolution.ts
+ */
+
+import { createEmptyGraph, applyMessage } from '../src/operations/index.js';
+import type { CRDTMessage } from '../src/operations/index.js';
+
+console.log('🎬 Example 04: Conflict Resolution\n');
+
+// ============================================
+// Setup: Create a cube
+// ============================================
+
+let graph = applyMessage(createEmptyGraph(), {
+  id: 'setup',
+  sessionId: 'server',
+  clock: { server: 1 },
+  lamportTime: 0,
+  timestamp: Date.now(),
+  ops: [{
+    key: 'cube',
+    otype: 'node.insert',
+    path: 'cube',
+    value: {
+      id: 'uuid-cube',
+      tag: 'Mesh',
+      name: 'Cube',
+      color: '#ffffff',
+      'transform.position': [0, 0, 0],
+    },
+  }],
+});
+
+console.log('Initial state:');
+console.log('  color:', graph.nodes['cube'].color);
+console.log('  position:', graph.nodes['cube']['transform.position']);
+
+// ============================================
+// Scenario 1: LWW - Out-of-order arrival
+// ============================================
+
+console.log('\n--- Scenario 1: LWW with Out-of-Order Arrival ---\n');
+console.log('Bob sets color to blue (lamport: 11)');
+console.log('Alice sets color to red (lamport: 10) - arrives AFTER Bob\n');
+
+// Bob's message arrives first (higher lamport)
+graph = applyMessage(graph, {
+  id: 'bob-color',
+  sessionId: 'bob',
+  clock: { bob: 1 },
+  lamportTime: 11,
+  timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'color.set', path: 'color', value: '#0000ff' }],
+});
+console.log('After Bob (lamport 11):', graph.nodes['cube'].color);
+
+// Alice's message arrives later (lower lamport - should be ignored)
+graph = applyMessage(graph, {
+  id: 'alice-color',
+  sessionId: 'alice',
+  clock: { alice: 1 },
+  lamportTime: 10,
+  timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'color.set', path: 'color', value: '#ff0000' }],
+});
+console.log('After Alice (lamport 10):', graph.nodes['cube'].color);
+
+console.log('\n✅ Result: Bob wins! (lamport 11 > 10)');
+console.log('   Alice\'s late message was correctly ignored.');
+
+// ============================================
+// Scenario 2: Additive - Order doesn't matter
+// ============================================
+
+console.log('\n--- Scenario 2: Additive Operations ---\n');
+console.log('Messages can arrive in any order, result is the same.\n');
+
+// Reset position
+graph = applyMessage(graph, {
+  id: 'reset',
+  sessionId: 'server',
+  clock: { server: 2 },
+  lamportTime: 20,
+  timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.set', path: 'transform.position', value: [0, 0, 0] }],
+});
+
+console.log('Position reset to [0, 0, 0]');
+
+// Apply in order: Alice, Bob, Charlie
+let graph1 = applyMessage(graph, {
+  id: 'alice-move', sessionId: 'alice', clock: { alice: 2 }, lamportTime: 21, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [1, 0, 0] }],
+});
+graph1 = applyMessage(graph1, {
+  id: 'bob-move', sessionId: 'bob', clock: { bob: 2 }, lamportTime: 22, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 2, 0] }],
+});
+graph1 = applyMessage(graph1, {
+  id: 'charlie-move', sessionId: 'charlie', clock: { charlie: 1 }, lamportTime: 23, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 0, 3] }],
+});
+
+// Apply in reverse order: Charlie, Bob, Alice
+let graph2 = applyMessage(graph, {
+  id: 'charlie-move', sessionId: 'charlie', clock: { charlie: 1 }, lamportTime: 23, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 0, 3] }],
+});
+graph2 = applyMessage(graph2, {
+  id: 'bob-move', sessionId: 'bob', clock: { bob: 2 }, lamportTime: 22, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 2, 0] }],
+});
+graph2 = applyMessage(graph2, {
+  id: 'alice-move', sessionId: 'alice', clock: { alice: 2 }, lamportTime: 21, timestamp: Date.now(),
+  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [1, 0, 0] }],
+});
+
+console.log('Order 1 (Alice → Bob → Charlie):', graph1.nodes['cube']['transform.position']);
+console.log('Order 2 (Charlie → Bob → Alice):', graph2.nodes['cube']['transform.position']);
+
+const pos1 = JSON.stringify(graph1.nodes['cube']['transform.position']);
+const pos2 = JSON.stringify(graph2.nodes['cube']['transform.position']);
+console.log('\n✅ Result:', pos1 === pos2 ? 'Same! Order doesn\'t matter for additive ops.' : '❌ Different!');
+
+// ============================================
+// Scenario 3: Mixed operations
+// ============================================
+
+console.log('\n--- Scenario 3: Mixed Operations in Real-time ---\n');
+console.log('Simulating two users editing simultaneously...\n');
+
+// Start fresh
+graph = applyMessage(createEmptyGraph(), {
+  id: 'init',
+  sessionId: 'server',
+  clock: { server: 1 },
+  lamportTime: 0,
+  timestamp: Date.now(),
+  ops: [{
+    key: 'box',
+    otype: 'node.insert',
+    path: 'box',
+    value: {
+      id: 'uuid-box',
+      tag: 'Mesh',
+      name: 'Box',
+      color: '#888888',
+      'transform.position': [0, 0, 0],
+    },
+  }],
+});
+
+console.log('Initial: color=#888888, position=[0,0,0]');
+
+// Alice drags and changes color
+const aliceMsg: CRDTMessage = {
+  id: 'alice-edit',
+  sessionId: 'alice',
+  clock: { alice: 1 },
+  lamportTime: 5,
+  timestamp: Date.now(),
+  ops: [
+    { key: 'box', otype: 'vector3.add', path: 'transform.position', value: [10, 0, 0] },
+    { key: 'box', otype: 'color.set', path: 'color', value: '#ff0000' },
+  ],
+};
+
+// Bob drags and changes color (higher lamport)
+const bobMsg: CRDTMessage = {
+  id: 'bob-edit',
+  sessionId: 'bob',
+  clock: { bob: 1 },
+  lamportTime: 6,
+  timestamp: Date.now(),
+  ops: [
+    { key: 'box', otype: 'vector3.add', path: 'transform.position', value: [0, 5, 0] },
+    { key: 'box', otype: 'color.set', path: 'color', value: '#00ff00' },
+  ],
+};
+
+// Apply Bob first, then Alice (out of order)
+graph = applyMessage(graph, bobMsg);
+console.log('After Bob:  color=%s, position=%s', graph.nodes['box'].color, JSON.stringify(graph.nodes['box']['transform.position']));
+
+graph = applyMessage(graph, aliceMsg);
+console.log('After Alice: color=%s, position=%s', graph.nodes['box'].color, JSON.stringify(graph.nodes['box']['transform.position']));
+
+console.log('\n✅ Final result:');
+console.log('   Position: [10, 5, 0] - Both drags applied (additive)');
+console.log('   Color: #00ff00 - Bob wins (LWW, lamport 6 > 5)');
+
+// ============================================
+// Scenario 4: Complex interleaved out-of-order
+// ============================================
+
+console.log('\n--- Scenario 4: Complex Interleaved Out-of-Order ---\n');
+console.log('This scenario breaks naive approaches:\n');
+console.log('  ❌ Simple set: Always overwrites → last arrival wins (wrong)');
+console.log('  ❌ 1-step lookahead: Compare with previous op only (wrong)');
+console.log('  ✅ Full LWW: Compare with node\'s max lamport (correct)\n');
+
+// Timeline of when operations were CREATED:
+// t=1: Alice sets color to red    (lamport 10)
+// t=2: Bob sets color to blue     (lamport 20)
+// t=3: Alice sets color to green  (lamport 30)
+// t=4: Charlie sets color to yellow (lamport 40)
+// t=5: Bob sets color to purple   (lamport 25) - Bob was offline, clock behind
+
+// But network delivers them in scrambled order:
+const messages = [
+  { name: 'Bob (purple)',   lamport: 25, color: '#800080' },
+  { name: 'Alice (green)',  lamport: 30, color: '#00ff00' },
+  { name: 'Charlie (yellow)', lamport: 40, color: '#ffff00' },
+  { name: 'Alice (red)',    lamport: 10, color: '#ff0000' },
+  { name: 'Bob (blue)',     lamport: 20, color: '#0000ff' },
+];
+
+console.log('Messages arrive in scrambled order:');
+messages.forEach((m, i) => console.log(`  ${i + 1}. ${m.name} (lamport: ${m.lamport})`));
+
+// ========================================
+// Architecture: State = { graph, journal }
+// ========================================
+// - graph: Current materialized state
+// - journal: Log of all messages (for replay/debugging)
+//
+// On each message:
+//   1. state.journal.push(msg)
+//   2. state.graph = applyMessage(state.graph, msg)
+
+interface State {
+  graph: ReturnType<typeof createEmptyGraph>;
+  journal: CRDTMessage[];
+}
+
+const state: State = {
+  graph: createEmptyGraph(),
+  journal: [],
+};
+
+// Helper: process a message (append + apply)
+function processMessage(s: State, msg: CRDTMessage): State {
+  return {
+    journal: [...s.journal, msg],
+    graph: applyMessage(s.graph, msg),
+  };
+}
+
+// Init
+state.graph = applyMessage(state.graph, {
+  id: 'init', sessionId: 'server', clock: { server: 1 }, lamportTime: 0, timestamp: Date.now(),
+  ops: [{ key: 'obj', otype: 'node.insert', path: 'obj', value: { key: 'uuid', tag: 'Mesh', name: 'Object', color: '#ffffff' }}],
+});
+
+console.log('\n📖 State = { graph, journal }');
+console.log('─'.repeat(65));
+console.log('  #  Message           Lamport  MaxLamport  State     Applied?');
+console.log('─'.repeat(65));
+
+for (let i = 0; i < messages.length; i++) {
+  const m = messages[i];
+  const prevColor = state.graph.nodes['obj'].color;
+
+  const msg: CRDTMessage = {
+    id: `msg-${m.lamport}`,
+    sessionId: m.name,
+    clock: { [m.name]: 1 },
+    lamportTime: m.lamport,
+    timestamp: Date.now(),
+    ops: [{ key: 'obj', otype: 'color.set', path: 'color', value: m.color }],
+  };
+
+  // Process: append to journal + apply to graph
+  Object.assign(state, processMessage(state, msg));
+
+  const applied = state.graph.nodes['obj'].color !== prevColor;
+  const maxLamport = state.graph.nodes['obj'].lamportTime;
+  const appliedStr = applied ? '✓ applied' : '✗ ignored';
+
+  console.log(`  ${i + 1}  ${m.name.padEnd(16)} ${String(m.lamport).padStart(3)}      ${String(maxLamport).padStart(3)}         ${state.graph.nodes['obj'].color}  ${appliedStr}`);
+}
+
+console.log('─'.repeat(65));
+console.log(`\n  state.journal: ${state.journal.length} messages`);
+console.log(`  state.graph:   color = ${state.graph.nodes['obj'].color} (maxLamport = ${state.graph.nodes['obj'].lamportTime})`);
+
+const isCorrect = state.graph.nodes['obj'].color === '#ffff00';
+console.log(`\n${isCorrect ? '✅' : '❌'} Result: ${isCorrect ? 'CORRECT' : 'WRONG'}`);
+
+// Verify convergence - apply same messages in different order
+console.log('\n--- Verifying convergence with different arrival orders ---\n');
+
+const orders = [
+  [0, 1, 2, 3, 4],  // Original scrambled
+  [4, 3, 2, 1, 0],  // Reverse
+  [2, 0, 4, 1, 3],  // Random shuffle 1
+  [3, 1, 4, 0, 2],  // Random shuffle 2
+];
+
+const results: string[] = [];
+
+for (let i = 0; i < orders.length; i++) {
+  let g = applyMessage(createEmptyGraph(), {
+    id: 'init', sessionId: 'server', clock: { server: 1 }, lamportTime: 0, timestamp: Date.now(),
+    ops: [{ key: 'obj', otype: 'node.insert', path: 'obj', value: { key: 'uuid', tag: 'Mesh', name: 'Object', color: '#ffffff' }}],
+  });
+
+  for (const idx of orders[i]) {
+    const msg = messages[idx];
+    g = applyMessage(g, {
+      id: `msg-${msg.lamport}`,
+      sessionId: msg.name,
+      clock: { [msg.name]: 1 },
+      lamportTime: msg.lamport,
+      timestamp: Date.now(),
+      ops: [{ key: 'obj', otype: 'color.set', path: 'color', value: msg.color }],
+    });
+  }
+
+  results.push(g.nodes['obj'].color);
+  console.log(`Order ${i + 1}: [${orders[i].join(', ')}] → ${g.nodes['obj'].color}`);
+}
+
+const allSame = results.every(r => r === results[0]);
+console.log(`\n${allSame ? '✅' : '❌'} All orders converge to same result: ${allSame ? 'YES' : 'NO'}`);
+
+// ============================================
+// Summary
+// ============================================
+
+console.log('\n📊 Summary:');
+console.log('─'.repeat(50));
+console.log('LWW (*.set): Higher lamport wins, regardless of arrival order');
+console.log('Additive (*.add): All values accumulate, order doesn\'t matter');
+console.log('─'.repeat(50));
+console.log('\nClients converge to the same state without coordination!');

package/examples/README.md

@@ -0,0 +1,86 @@
+# CRDT Examples
+
+This folder contains examples demonstrating how the CRDT system works.
+
+## Running Examples
+
+```bash
+cd packages/server
+npx tsx examples/01-basic-usage.ts
+npx tsx examples/02-concurrent-edits.ts
+npx tsx examples/03-scene-building.ts
+npx tsx examples/04-conflict-resolution.ts
+```
+
+## Examples
+
+### 01-basic-usage.ts
+Basic usage of the CRDT system:
+- Creating an empty scene graph
+- Inserting nodes
+- Applying operations
+- Moving objects (additive)
+- Changing properties
+
+### 02-concurrent-edits.ts
+Demonstrates concurrent edit resolution:
+- **Additive operations** (`vector3.add`, `number.add`): Values are summed
+- **LWW operations** (`color.set`, `vector3.set`): Last write wins (by lamport time)
+
+### 03-scene-building.ts
+Building a complete scene:
+- Batch operations (multiple ops in one message)
+- Reparenting nodes
+- Node deletion (tombstones)
+
+### 04-conflict-resolution.ts
+Demonstrates conflict resolution:
+- LWW with out-of-order message arrival
+- Additive operations are order-independent
+- Mixed operations in real-time editing
+
+## Core Concepts
+
+### CRDTMessage Structure
+
+```typescript
+interface CRDTMessage {
+  id: string;           // Message ID
+  sessionId: string;    // Who sent this
+  clock: VectorClock;   // For causal ordering
+  lamportTime: number;  // For total ordering (LWW)
+  timestamp: number;    // Wall-clock time
+  ops: Operation[];     // Batch of operations
+}
+```
+
+### Operation Types
+
+| otype | Merge Behavior | Use Case |
+|-------|---------------|----------|
+| `node.insert` | Idempotent | Create node (use `parent` field to auto-add to parent's children) |
+| `node.remove` | Tombstone | Delete node |
+| `number.set` | LWW | Absolute number |
+| `number.add` | Sum | Counter, delta |
+| `vector3.set` | LWW | Absolute position |
+| `vector3.add` | Component sum | Drag movement |
+| `color.set` | LWW | Material color |
+| `array.set` | LWW | Replace array |
+| `array.push` | Append | Add child |
+| `array.remove` | Remove | Remove child |
+
+### Additive vs LWW
+
+**Additive** (`*.add`): Order doesn't matter, values accumulate
+```
+Alice: position += [5, 0, 0]
+Bob:   position += [0, 3, 0]
+Result: position += [5, 3, 0] ✅
+```
+
+**LWW** (`*.set`): Higher lamportTime wins
+```
+Alice: color = red   (lamport: 10)
+Bob:   color = blue  (lamport: 11)
+Result: color = blue ✅ (Bob's lamport is higher)
+```

package/jest.config.js

@@ -0,0 +1,19 @@
+/** @type {import('jest').Config} */
+export default {
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts', '.tsx'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        useESM: true,
+        tsconfig: 'tsconfig.test.json',
+      },
+    ],
+  },
+  testMatch: ['**/tests/**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};