@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

package/examples/04-conflict-resolution.ts

@@ -16,13 +16,13 @@ console.log('🎬 Example 04: Conflict Resolution\n');
 
 let graph = applyMessage(createEmptyGraph(), {
   id: 'setup',
-  sessionId: 'server',
+  client: 'server',
   clock: { server: 1 },
-  lamportTime: 0,
-  timestamp: Date.now() / 1000,
+  lt: 0,
+  ts: Date.now() / 1000,
   ops: [{
     key: 'cube',
-    otype: 'node.insert',
+    ot: 'node.insert',
     path: 'cube',
     value: {
       id: 'uuid-cube',
@@ -49,22 +49,22 @@ 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',
+  client: 'bob',
   clock: { bob: 1 },
-  lamportTime: 11,
-  timestamp: Date.now() / 1000,
-  ops: [{ key: 'cube', otype: 'color.set', path: 'color', value: '#0000ff' }],
+  lt: 11,
+  ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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',
+  client: 'alice',
   clock: { alice: 1 },
-  lamportTime: 10,
-  timestamp: Date.now() / 1000,
-  ops: [{ key: 'cube', otype: 'color.set', path: 'color', value: '#ff0000' }],
+  lt: 10,
+  ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: 'color.set', path: 'color', value: '#ff0000' }],
 });
 console.log('After Alice (lamport 10):', graph.nodes['cube'].color);
 
@@ -81,41 +81,41 @@ console.log('Messages can arrive in any order, result is the same.\n');
 // Reset position
 graph = applyMessage(graph, {
   id: 'reset',
-  sessionId: 'server',
+  client: 'server',
   clock: { server: 2 },
-  lamportTime: 20,
-  timestamp: Date.now() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.set', path: 'transform.position', value: [0, 0, 0] }],
+  lt: 20,
+  ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [1, 0, 0] }],
+  id: 'alice-move', client: 'alice', clock: { alice: 2 }, lt: 21, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 2, 0] }],
+  id: 'bob-move', client: 'bob', clock: { bob: 2 }, lt: 22, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 0, 3] }],
+  id: 'charlie-move', client: 'charlie', clock: { charlie: 1 }, lt: 23, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 0, 3] }],
+  id: 'charlie-move', client: 'charlie', clock: { charlie: 1 }, lt: 23, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [0, 2, 0] }],
+  id: 'bob-move', client: 'bob', clock: { bob: 2 }, lt: 22, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: '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() / 1000,
-  ops: [{ key: 'cube', otype: 'vector3.add', path: 'transform.position', value: [1, 0, 0] }],
+  id: 'alice-move', client: 'alice', clock: { alice: 2 }, lt: 21, ts: Date.now() / 1000,
+  ops: [{ key: 'cube', ot: 'vector3.add', path: 'transform.position', value: [1, 0, 0] }],
 });
 
 console.log('Order 1 (Alice → Bob → Charlie):', graph1.nodes['cube']['transform.position']);
@@ -135,13 +135,13 @@ console.log('Simulating two users editing simultaneously...\n');
 // Start fresh
 graph = applyMessage(createEmptyGraph(), {
   id: 'init',
-  sessionId: 'server',
+  client: 'server',
   clock: { server: 1 },
-  lamportTime: 0,
-  timestamp: Date.now() / 1000,
+  lt: 0,
+  ts: Date.now() / 1000,
   ops: [{
     key: 'box',
-    otype: 'node.insert',
+    ot: 'node.insert',
     path: 'box',
     value: {
       id: 'uuid-box',
@@ -158,26 +158,26 @@ console.log('Initial: color=#888888, position=[0,0,0]');
 // Alice drags and changes color
 const aliceMsg: CRDTMessage = {
   id: 'alice-edit',
-  sessionId: 'alice',
+  client: 'alice',
   clock: { alice: 1 },
-  lamportTime: 5,
-  timestamp: Date.now() / 1000,
+  lt: 5,
+  ts: Date.now() / 1000,
   ops: [
-    { key: 'box', otype: 'vector3.add', path: 'transform.position', value: [10, 0, 0] },
-    { key: 'box', otype: 'color.set', path: 'color', value: '#ff0000' },
+    { key: 'box', ot: 'vector3.add', path: 'transform.position', value: [10, 0, 0] },
+    { key: 'box', ot: 'color.set', path: 'color', value: '#ff0000' },
   ],
 };
 
 // Bob drags and changes color (higher lamport)
 const bobMsg: CRDTMessage = {
   id: 'bob-edit',
-  sessionId: 'bob',
+  client: 'bob',
   clock: { bob: 1 },
-  lamportTime: 6,
-  timestamp: Date.now() / 1000,
+  lt: 6,
+  ts: Date.now() / 1000,
   ops: [
-    { key: 'box', otype: 'vector3.add', path: 'transform.position', value: [0, 5, 0] },
-    { key: 'box', otype: 'color.set', path: 'color', value: '#00ff00' },
+    { key: 'box', ot: 'vector3.add', path: 'transform.position', value: [0, 5, 0] },
+    { key: 'box', ot: 'color.set', path: 'color', value: '#00ff00' },
   ],
 };
 
@@ -251,8 +251,8 @@ function processMessage(s: State, msg: CRDTMessage): State {
 
 // Init
 state.graph = applyMessage(state.graph, {
-  id: 'init', sessionId: 'server', clock: { server: 1 }, lamportTime: 0, timestamp: Date.now() / 1000,
-  ops: [{ key: 'obj', otype: 'node.insert', path: 'obj', value: { key: 'uuid', tag: 'Mesh', name: 'Object', color: '#ffffff' }}],
+  id: 'init', client: 'server', clock: { server: 1 }, lt: 0, ts: Date.now() / 1000,
+  ops: [{ key: 'obj', ot: 'node.insert', path: 'obj', value: { key: 'uuid', tag: 'Mesh', name: 'Object', color: '#ffffff' }}],
 });
 
 console.log('\n📖 State = { graph, journal }');
@@ -266,18 +266,18 @@ for (let i = 0; i < messages.length; i++) {
 
   const msg: CRDTMessage = {
     id: `msg-${m.lamport}`,
-    sessionId: m.name,
+    client: m.name,
     clock: { [m.name]: 1 },
-    lamportTime: m.lamport,
-    timestamp: Date.now() / 1000,
-    ops: [{ key: 'obj', otype: 'color.set', path: 'color', value: m.color }],
+    lt: m.lamport,
+    ts: Date.now() / 1000,
+    ops: [{ key: 'obj', ot: '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']._crdt.lamportTime;
+  const maxLamport = state.graph.nodes['obj']._crdt.lt;
   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}`);
@@ -285,7 +285,7 @@ for (let i = 0; i < messages.length; i++) {
 
 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']._crdt.lamportTime})`);
+console.log(`  state.graph:   color = ${state.graph.nodes['obj'].color} (maxLamport = ${state.graph.nodes['obj']._crdt.lt})`);
 
 const isCorrect = state.graph.nodes['obj'].color === '#ffff00';
 console.log(`\n${isCorrect ? '✅' : '❌'} Result: ${isCorrect ? 'CORRECT' : 'WRONG'}`);
@@ -304,19 +304,19 @@ 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() / 1000,
-    ops: [{ key: 'obj', otype: 'node.insert', path: 'obj', value: { key: 'uuid', tag: 'Mesh', name: 'Object', color: '#ffffff' }}],
+    id: 'init', client: 'server', clock: { server: 1 }, lt: 0, ts: Date.now() / 1000,
+    ops: [{ key: 'obj', ot: '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,
+      client: msg.name,
       clock: { [msg.name]: 1 },
-      lamportTime: msg.lamport,
-      timestamp: Date.now() / 1000,
-      ops: [{ key: 'obj', otype: 'color.set', path: 'color', value: msg.color }],
+      lt: msg.lamport,
+      ts: Date.now() / 1000,
+      ops: [{ key: 'obj', ot: 'color.set', path: 'color', value: msg.color }],
     });
   }
 

package/examples/05-coalescence-usage.ts

@@ -26,17 +26,17 @@ console.log('--- Example 1: No Coalescence ---\n');
 
 const messages1: CRDTMessage[] = [];
 const store1 = createGraph({
-  sessionId: 'session-1',
+  client: 'session-1',
   coalescingEnabled: false,  // No auto-commit
   onSend: (msg) => messages1.push(msg),
 });
 
 // User types "hello"
-store1.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
-store1.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
-store1.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
-store1.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
-store1.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+store1.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
+store1.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+store1.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+store1.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+store1.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
 
 // Manual commit (no coalescence since coalescingEnabled = false)
 store1.commit();
@@ -53,7 +53,7 @@ console.log('--- Example 2: Batching Only ---\n');
 
 const messages2: CRDTMessage[] = [];
 const store2 = createGraph({
-  sessionId: 'session-2',
+  client: 'session-2',
   coalescingEnabled: true,      // Enable auto-commit
   coalescingDelayMs: 100,       // Wait 100ms before sending
   coalescingThresholdMs: 0,     // Don't merge operations (0 threshold)
@@ -61,11 +61,11 @@ const store2 = createGraph({
 });
 
 // User types "hello" quickly
-store2.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
-store2.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
-store2.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
-store2.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
-store2.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+store2.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
+store2.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+store2.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+store2.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+store2.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
 
 // Wait for auto-commit
 await new Promise(resolve => setTimeout(resolve, 150));
@@ -82,7 +82,7 @@ console.log('--- Example 3: Full Coalescence ---\n');
 
 const messages3: CRDTMessage[] = [];
 const store3 = createGraph({
-  sessionId: 'session-3',
+  client: 'session-3',
   coalescingEnabled: true,      // Enable auto-commit
   coalescingDelayMs: 100,       // Wait 100ms before sending
   coalescingThresholdMs: 1000,  // Merge ops within 1 second
@@ -91,15 +91,15 @@ const store3 = createGraph({
 
 // User types "hello" quickly
 const startTime = Date.now();
-store3.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
+store3.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
 await sleep(10);
-store3.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
+store3.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'e' });
 await sleep(10);
-store3.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
+store3.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 2, value: 'l' });
 await sleep(10);
-store3.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
+store3.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 3, value: 'l' });
 await sleep(10);
-store3.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
+store3.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 4, value: 'o' });
 const endTime = Date.now();
 const typingDuration = endTime - startTime;
 
@@ -109,7 +109,7 @@ await new Promise(resolve => setTimeout(resolve, 150));
 console.log(`Typing duration: ${typingDuration}ms (< 1000ms threshold)`);
 console.log(`Messages sent: ${messages3.length}`);
 console.log(`Operations in message: ${messages3[0].ops.length}`);
-if (messages3[0].ops[0].otype === 'text.insert') {
+if (messages3[0].ops[0].ot === 'text.insert') {
   const op = messages3[0].ops[0] as any;
   console.log(`Operation content: "${op.content}"`);
   console.log('Result: 1 message with 1 operation (fully coalesced!)\n');
@@ -123,7 +123,7 @@ console.log('--- Example 4: Dynamic Configuration ---\n');
 
 const messages4: CRDTMessage[] = [];
 const store4 = createGraph({
-  sessionId: 'session-4',
+  client: 'session-4',
   coalescingEnabled: false,
   onSend: (msg) => messages4.push(msg),
 });
@@ -144,15 +144,15 @@ console.log(`  Delay: ${store4.getCoalescingDelay()}ms`);
 console.log(`  Threshold: ${store4.getCoalescingThreshold()}ms\n`);
 
 // Type with new settings
-store4.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
+store4.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 0, value: 'h' });
 await sleep(10);
-store4.edit({ otype: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
+store4.edit({ ot: 'text.insert', key: 'doc', path: 'content', position: 1, value: 'i' });
 
 // Wait for auto-commit
 await sleep(150);
 
 console.log(`Messages sent: ${messages4.length}`);
-if (messages4.length > 0 && messages4[0].ops[0].otype === 'text.insert') {
+if (messages4.length > 0 && messages4[0].ops[0].ot === 'text.insert') {
   const op = messages4[0].ops[0] as any;
   console.log(`Coalesced content: "${op.content}"`);
 }

package/examples/README.md

@@ -45,19 +45,19 @@ Demonstrates conflict resolution:
 
 ```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
+  id: string;        // Message ID
+  client: string;    // Who sent this
+  clock: VectorClock;// For causal ordering
+  lt: number;        // Lamport time for total ordering (LWW)
+  ts: number;        // Wall-clock timestamp
+  ops: Operation[];  // Batch of operations
 }
 ```
 
 ### Operation Types
 
-| otype | Merge Behavior | Use Case |
-|-------|---------------|----------|
+| ot | Merge Behavior | Use Case |
+|----|---------------|----------|
 | `node.insert` | Idempotent | Create node (use `parent` field to auto-add to parent's children) |
 | `node.remove` | Tombstone | Delete node |
 | `node.move` | Reparent | Move node to new parent |
@@ -83,9 +83,9 @@ Bob:   position += [0, 3, 0]
 Result: position += [5, 3, 0] ✅
 ```
 
-**LWW** (`*.set`): Higher lamportTime wins
+**LWW** (`*.set`): Higher lt wins
 ```
-Alice: color = red   (lamport: 10)
-Bob:   color = blue  (lamport: 11)
-Result: color = blue ✅ (Bob's lamport is higher)
+Alice: color = red   (lt: 10)
+Bob:   color = blue  (lt: 11)
+Result: color = blue ✅ (Bob's lt is higher)
 ```

package/package.json

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

package/src/client/EditBuffer.ts

@@ -21,30 +21,30 @@ import type { Operation } from '../operations/OperationTypes.js';
  * separately (coalesced later in commitEdits).
  */
 export function opDedupKey(op: Operation): string {
-  if (op.otype === 'node.insert') return `${op.key}:${op.path}:insert:${(op as any).value.key}`;
-  if (op.otype === 'node.remove') return `${op.key}:${op.path}:remove:${(op as any).value}`;
-  if (op.otype === 'node.move')   return `${op.key}:${op.path}:move:${(op as any).value.nodeKey}`;
+  if (op.ot === 'node.insert') return `${op.key}:${op.path}:insert:${(op as any).value.key}`;
+  if (op.ot === 'node.remove') return `${op.key}:${op.path}:remove:${(op as any).value}`;
+  if (op.ot === 'node.move')   return `${op.key}:${op.path}:move:${(op as any).value.nodeKey}`;
   // Text operations: include position so consecutive inserts aren't deduped
-  if (op.otype === 'text.insert') return `${op.key}:${op.path}:text.insert:${(op as any).position}`;
-  if (op.otype === 'text.delete') return `${op.key}:${op.path}:text.delete:${(op as any).position}:${(op as any).length}`;
+  if (op.ot === 'text.insert') return `${op.key}:${op.path}:text.insert:${(op as any).position}`;
+  if (op.ot === 'text.delete') return `${op.key}:${op.path}:text.delete:${(op as any).position}:${(op as any).length}`;
   return `${op.key}:${op.path}`;
 }
 
 /**
  * Check if an operation type is additive (can be merged)
  */
-export function isAdditiveOp(otype: string): boolean {
-  return otype === 'vector3.add' ||
-         otype === 'number.add' ||
-         otype === 'number.multiply' ||
-         otype === 'quaternion.multiply';
+export function isAdditiveOp(ot: string): boolean {
+  return ot === 'vector3.add' ||
+         ot === 'number.add' ||
+         ot === 'number.multiply' ||
+         ot === 'quaternion.multiply';
 }
 
 /**
  * Type for position-based text insert (used locally before CRDT conversion)
  */
 interface PositionTextInsertOp {
-  otype: 'text.insert';
+  ot: 'text.insert';
   key: string;
   path: string;
   position: number;
@@ -55,7 +55,7 @@ interface PositionTextInsertOp {
  * Check if an operation is a position-based text insert
  */
 export function isPositionTextInsertOp(op: Operation): op is PositionTextInsertOp {
-  return op.otype === 'text.insert' &&
+  return op.ot === 'text.insert' &&
     typeof (op as any).position === 'number' &&
     typeof (op as any).value === 'string';
 }
@@ -64,7 +64,7 @@ export function isPositionTextInsertOp(op: Operation): op is PositionTextInsertO
  * Type for position-based text delete
  */
 interface PositionTextDeleteOp {
-  otype: 'text.delete';
+  ot: 'text.delete';
   key: string;
   path: string;
   position: number;
@@ -75,7 +75,7 @@ interface PositionTextDeleteOp {
  * Check if an operation is a text delete with position
  */
 export function isPositionTextDeleteOp(op: Operation): op is PositionTextDeleteOp {
-  return op.otype === 'text.delete' &&
+  return op.ot === 'text.delete' &&
     typeof (op as any).position === 'number' &&
     typeof (op as any).length === 'number';
 }
@@ -144,7 +144,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
       if (pendingInsert === null) {
         // Start new pending insert
         pendingInsert = {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: op.key,
           path: op.path,
           position: op.position,
@@ -157,7 +157,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
       ) {
         // Sequential insert - merge values
         pendingInsert = {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: pendingInsert.key,
           path: pendingInsert.path,
           position: pendingInsert.position,
@@ -167,7 +167,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
         // Different target or non-sequential - flush pending and start new
         result.push(pendingInsert as unknown as Operation);
         pendingInsert = {
-          otype: 'text.insert',
+          ot: 'text.insert',
           key: op.key,
           path: op.path,
           position: op.position,
@@ -176,7 +176,8 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
       }
     } else if (isPositionTextDeleteOp(op)) {
       // Check if operation has CRDT metadata - if so, don't coalesce it
-      const hasCRDTMetadata = (op as any).deletions !== undefined;
+      // Support both old (deletions) and new (value) field names
+      const hasCRDTMetadata = (op as any).deletions !== undefined || (op as any).value !== undefined;
 
       if (hasCRDTMetadata) {
         // Flush any pending operations
@@ -202,7 +203,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
       // Coalesce deletes (only for position-based operations without CRDT metadata)
       if (pendingDelete === null) {
         pendingDelete = {
-          otype: 'text.delete',
+          ot: 'text.delete',
           key: op.key,
           path: op.path,
           position: op.position,
@@ -219,7 +220,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
         if (isForwardDelete) {
           // Forward delete: accumulate lengths at same position
           pendingDelete = {
-            otype: 'text.delete',
+            ot: 'text.delete',
             key: pendingDelete.key,
             path: pendingDelete.path,
             position: pendingDelete.position,
@@ -228,7 +229,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
         } else if (isBackwardDelete) {
           // Backward delete: position moves left, accumulate lengths
           pendingDelete = {
-            otype: 'text.delete',
+            ot: 'text.delete',
             key: pendingDelete.key,
             path: pendingDelete.path,
             position: op.position, // use new (leftmost) position
@@ -238,7 +239,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
           // Non-consecutive - flush and start new
           result.push(pendingDelete as unknown as Operation);
           pendingDelete = {
-            otype: 'text.delete',
+            ot: 'text.delete',
             key: op.key,
             path: op.path,
             position: op.position,
@@ -249,7 +250,7 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
         // Different key/path - flush and start new
         result.push(pendingDelete as unknown as Operation);
         pendingDelete = {
-          otype: 'text.delete',
+          ot: 'text.delete',
           key: op.key,
           path: op.path,
           position: op.position,
@@ -284,8 +285,8 @@ export function coalesceTextOps(ops: Operation[]): Operation[] {
 /**
  * Merge two values for additive operations
  */
-export function mergeValues(otype: string, a: unknown, b: unknown): unknown {
-  switch (otype) {
+export function mergeValues(ot: string, a: unknown, b: unknown): unknown {
+  switch (ot) {
     case 'vector3.add': {
       const va = a as [number, number, number];
       const vb = b as [number, number, number];
@@ -325,9 +326,9 @@ export class EditBufferImpl {
     const key = opDedupKey(op);
     const existing = this.opsMap.get(key);
 
-    if (existing && existing.otype === op.otype && isAdditiveOp(op.otype)) {
+    if (existing && existing.ot === op.ot && isAdditiveOp(op.ot)) {
       // Merge additive ops
-      const mergedValue = mergeValues(op.otype, (existing as any).value, (op as any).value);
+      const mergedValue = mergeValues(op.ot, (existing as any).value, (op as any).value);
       this.opsMap.set(key, { ...existing, value: mergedValue } as Operation);
     } else {
       // New op or LWW replacement

package/src/client/TEXT_DOCUMENT_API.md

@@ -18,7 +18,7 @@ import { createTextDocument } from '@vuer-ai/vuer-rtc';
 
 // Create a text document
 const doc = createTextDocument({
-  sessionId: 'alice-123',
+  client: 'alice-123',
   onSend: (msg) => websocket.send(JSON.stringify(msg)),
 });
 
@@ -64,7 +64,7 @@ function createTextDocument(options: CreateTextDocumentOptions): TextDocumentSto
 
 | Option | Type | Required | Default | Description |
 |--------|------|----------|---------|-------------|
-| `sessionId` | `string` | ✓ | - | Unique session identifier |
+| `client` | `string` | ✓ | - | Unique client identifier |
 | `initialSnapshot` | `TextSnapshot` | - | `undefined` | Initialize from server snapshot |
 | `onSend` | `(msg: TextMessage) => void` | - | `undefined` | Callback when messages are ready to send |
 | `onStateChange` | `(state: TextDocumentState) => void` | - | `undefined` | Callback on every state change |
@@ -78,7 +78,7 @@ function createTextDocument(options: CreateTextDocumentOptions): TextDocumentSto
 
 ```typescript
 const doc = createTextDocument({
-  sessionId: 'user-123',
+  client: 'user-123',
   coalescingEnabled: true,
   coalescingDelayMs: 500,
   onSend: (msg) => {
@@ -116,7 +116,7 @@ function createTextDocumentFromServer(
 const { snapshot, journal } = await fetch('/api/doc/123').then(r => r.json());
 
 const doc = createTextDocumentFromServer({
-  sessionId: 'user-123',
+  client: 'user-123',
   snapshot,
   journal,
   onSend: (msg) => ws.send(JSON.stringify(msg)),
@@ -507,7 +507,7 @@ interface TextDocumentState {
   snapshot: TextSnapshot;             // Checkpoint
   lamportTime: number;                // Logical clock
   vectorClock: VectorClock;           // Causality tracking
-  sessionId: string;                  // This session's ID
+  client: string;                     // This client's ID
 }
 ```
 
@@ -518,7 +518,7 @@ A message containing text operations.
 ```typescript
 interface TextMessage {
   msgId: string;                      // Unique message ID
-  sessionId: string;                  // Sender's session ID
+  client: string;                     // Sender's client ID
   operations: TextOperation[];         // Operations in this message
   vectorClock: VectorClock;           // Causal ordering
   lamportTime: number;                // Total ordering
@@ -579,7 +579,7 @@ interface TextSnapshot {
 import { createTextDocument } from '@vuer-ai/vuer-rtc';
 
 const doc = createTextDocument({
-  sessionId: 'local-user',
+  client: 'local-user',
 });
 
 // Edit
@@ -602,7 +602,7 @@ import { createTextDocument } from '@vuer-ai/vuer-rtc';
 
 const ws = new WebSocket('ws://server.com/doc/123');
 const doc = createTextDocument({
-  sessionId: generateSessionId(),
+  client: generateClientId(),
   coalescingEnabled: true,
   coalescingDelayMs: 300,
   onSend: (msg) => {
@@ -652,7 +652,7 @@ function useTextDocument(docId: string) {
   useEffect(() => {
     const ws = new WebSocket(`ws://server/doc/${docId}`);
     const doc = createTextDocument({
-      sessionId: generateSessionId(),
+      client: generateClientId(),
       coalescingEnabled: true,
       onSend: (msg) => ws.send(JSON.stringify(msg)),
     });