@vuer-ai/vuer-rtc 0.7.0 → 0.8.2

package/src/client/actions.ts

@@ -29,12 +29,12 @@ export function generateUUID(): string {
 /**
  * Create initial client state
  */
-export function createInitialState(sessionId: string, initialSnapshot?: Snapshot): ClientState {
+export function createInitialState(client: string, initialSnapshot?: Snapshot): ClientState {
   const emptyGraph = createEmptyGraph();
   const snapshot = initialSnapshot ?? {
     graph: emptyGraph,
     vectorClock: {},
-    lamportTime: 0,
+    lt: 0,
     journalIndex: 0,
   };
 
@@ -43,9 +43,9 @@ export function createInitialState(sessionId: string, initialSnapshot?: Snapshot
     journal: [],
     edits: { ops: [], baseGraph: null },
     snapshot,
-    lamportTime: snapshot.lamportTime ?? 0,
-    vectorClock: clockManager.create(sessionId),
-    sessionId,
+    lt: snapshot.lt ?? 0,
+    vectorClock: clockManager.create(client),
+    client: client,
   };
 }
 
@@ -158,23 +158,26 @@ function reuseUnchangedNodes(oldGraph: SceneGraph, newGraph: SceneGraph): SceneG
 export function rebuildGraph(
   snapshot: Snapshot,
   journal: JournalEntry[],
-  pendingOps: Operation[]
+  pendingOps: Operation[],
+  client: string,
+  vectorClock: VectorClock,
+  lt: number
 ): SceneGraph {
   let graph = cloneSnapshotGraph(snapshot.graph);
 
   // Sort journal by causal order so out-of-order deliveries
   // (e.g. via sync retransmission) are replayed correctly.
   const sorted = [...journal].sort((a, b) => {
-    const dt = a.msg.lamportTime - b.msg.lamportTime;
+    const dt = a.msg.lt - b.msg.lt;
     if (dt !== 0) return dt;
-    return a.msg.sessionId < b.msg.sessionId ? -1 : a.msg.sessionId > b.msg.sessionId ? 1 : 0;
+    return a.msg.client < b.msg.client ? -1 : a.msg.client > b.msg.client ? 1 : 0;
   });
 
   // Apply journal (skip deleted entries and meta ops)
   for (const entry of sorted) {
     if (entry.deletedAt) continue;
 
-    const realOps = entry.msg.ops.filter(op => !op.otype.startsWith('meta.'));
+    const realOps = entry.msg.ops.filter(op => !op.ot.startsWith('meta.'));
     if (realOps.length > 0) {
       graph = applyMessage(graph, { ...entry.msg, ops: realOps });
     }
@@ -184,10 +187,10 @@ export function rebuildGraph(
   if (pendingOps.length > 0) {
     for (const op of pendingOps) {
       applyOperation(graph, op, {
-        sessionId: 'local',
-        clock: {},
-        lamportTime: 0,
-        timestamp: Date.now() / 1000,
+        client,
+        clock: vectorClock,
+        lt,
+        ts: Date.now() / 1000,
       });
     }
   }
@@ -208,8 +211,8 @@ export function onEdit(state: ClientState, op: Operation): ClientState {
 
   if (existingIdx >= 0) {
     const existing = ops[existingIdx];
-    if (existing.otype === op.otype && isAdditiveOp(op.otype)) {
-      const mergedValue = mergeValues(op.otype, (existing as any).value, (op as any).value);
+    if (existing.ot === op.ot && isAdditiveOp(op.ot)) {
+      const mergedValue = mergeValues(op.ot, (existing as any).value, (op as any).value);
       ops[existingIdx] = { ...existing, value: mergedValue } as Operation;
     } else {
       ops[existingIdx] = op;
@@ -226,12 +229,12 @@ export function onEdit(state: ClientState, op: Operation): ClientState {
   if (typeof op.key === 'string' && op.key in graph.nodes) {
     keysToClone.push(op.key);
   }
-  if (op.otype === 'node.move') {
+  if (op.ot === 'node.move') {
     const { nodeKey, newParent } = (op as any).value;
     if (nodeKey && nodeKey in graph.nodes) keysToClone.push(nodeKey);
     if (newParent && newParent in graph.nodes) keysToClone.push(newParent);
   }
-  if (op.otype === 'node.remove') {
+  if (op.ot === 'node.remove') {
     const nodeKey = (op as any).value;
     if (typeof nodeKey === 'string' && nodeKey in graph.nodes) keysToClone.push(nodeKey);
   }
@@ -247,10 +250,10 @@ export function onEdit(state: ClientState, op: Operation): ClientState {
   }
 
   applyOperation(graph, op, {
-    sessionId: state.sessionId,
+    client: state.client,
     clock: state.vectorClock,
-    lamportTime: state.lamportTime + 1,
-    timestamp: Date.now() / 1000,
+    lt: state.lt + 1,
+    ts: Date.now() / 1000,
   });
 
   return {
@@ -276,8 +279,8 @@ export function commitEdits(
     return { state, msg: null };
   }
 
-  const newClock = clockManager.increment(state.vectorClock, state.sessionId);
-  const newLamport = state.lamportTime + 1;
+  const newClock = clockManager.increment(state.vectorClock, state.client);
+  const newLamport = state.lt + 1;
 
   // Coalesce CRDT operations before sending (if threshold specified)
   const coalescedOps = coalescingThresholdMs !== undefined
@@ -285,11 +288,11 @@ export function commitEdits(
     : state.edits.ops;
 
   const msg: CRDTMessage = {
-    id: `${state.sessionId}:${newLamport}`,
-    sessionId: state.sessionId,
+    id: `${state.client}:${newLamport}`,
+    client: state.client,
     clock: newClock,
-    lamportTime: newLamport,
-    timestamp: Date.now() / 1000,
+    lt: newLamport,
+    ts: Date.now() / 1000,
     ops: coalescedOps,
   };
 
@@ -298,7 +301,7 @@ export function commitEdits(
       ...state,
       journal: [...state.journal, { msg, ack: false }],
       edits: { ops: [], baseGraph: null },
-      lamportTime: msg.lamportTime,
+      lt: msg.lt,
       vectorClock: newClock,
     },
     msg,
@@ -343,11 +346,11 @@ export function onRemoteMessage(state: ClientState, msg: CRDTMessage): ClientSta
 
   // Process meta ops (undo/redo) — clone modified entries
   for (const op of msg.ops) {
-    if (op.otype === 'meta.undo') {
+    if (op.ot === 'meta.undo') {
       const targetMsgId = (op as any).targetMsgId;
       const idx = journal.findIndex(e => e.msg.id === targetMsgId);
-      if (idx >= 0) journal[idx] = { ...journal[idx], deletedAt: msg.lamportTime };
-    } else if (op.otype === 'meta.redo') {
+      if (idx >= 0) journal[idx] = { ...journal[idx], deletedAt: msg.lt };
+    } else if (op.ot === 'meta.redo') {
       const targetMsgId = (op as any).targetMsgId;
       const idx = journal.findIndex(e => e.msg.id === targetMsgId);
       if (idx >= 0) {
@@ -358,11 +361,11 @@ export function onRemoteMessage(state: ClientState, msg: CRDTMessage): ClientSta
   }
 
   const vectorClock = clockManager.merge(state.vectorClock, msg.clock);
-  const lamportTime = Math.max(state.lamportTime, msg.lamportTime);
-  const rebuilt = rebuildGraph(state.snapshot, journal, state.edits.ops);
+  const lamportTime = Math.max(state.lt, msg.lt);
+  const rebuilt = rebuildGraph(state.snapshot, journal, state.edits.ops, state.client, vectorClock, lamportTime);
   const graph = reuseUnchangedNodes(state.graph, rebuilt);
 
-  return { ...state, journal, vectorClock, lamportTime, graph };
+  return { ...state, journal, vectorClock, lt: lamportTime, graph };
 }
 
 /**
@@ -382,8 +385,8 @@ export function undo(state: ClientState): { state: ClientState; msg: CRDTMessage
     const lastActive = [...currentState.journal]
       .reverse()
       .find(e => !e.deletedAt
-        && e.msg.sessionId === currentState.sessionId
-        && !e.msg.ops.some(op => op.otype.startsWith('meta.'))
+        && e.msg.client === currentState.client
+        && !e.msg.ops.some(op => op.ot.startsWith('meta.'))
       );
 
     if (!lastActive) return { state: currentState, msg: null };
@@ -391,15 +394,15 @@ export function undo(state: ClientState): { state: ClientState; msg: CRDTMessage
   }
 
   // Create undo message
-  const newClock = clockManager.increment(currentState.vectorClock, currentState.sessionId);
-  const newLamport = currentState.lamportTime + 1;
+  const newClock = clockManager.increment(currentState.vectorClock, currentState.client);
+  const newLamport = currentState.lt + 1;
   const undoMsg: CRDTMessage = {
-    id: `${currentState.sessionId}:${newLamport}`,
-    sessionId: currentState.sessionId,
+    id: `${currentState.client}:${newLamport}`,
+    client: currentState.client,
     clock: newClock,
-    lamportTime: newLamport,
-    timestamp: Date.now() / 1000,
-    ops: [{ otype: 'meta.undo', key: '_meta', path: '_meta', targetMsgId }],
+    lt: newLamport,
+    ts: Date.now() / 1000,
+    ops: [{ ot: 'meta.undo', key: '_meta', path: '_meta', targetMsgId }],
   };
 
   // Build new journal with undo entry + target marked deleted
@@ -407,19 +410,19 @@ export function undo(state: ClientState): { state: ClientState; msg: CRDTMessage
   // can reliably pick the most recently undone entry.
   const journal: JournalEntry[] = currentState.journal.map(e => {
     if (e.msg.id === targetMsgId) {
-      return { ...e, deletedAt: undoMsg.lamportTime, ack: false };
+      return { ...e, deletedAt: undoMsg.lt, ack: false };
     }
     return e;
   });
   journal.push({ msg: undoMsg, ack: false });
 
-  const rebuilt = rebuildGraph(currentState.snapshot, journal, currentState.edits.ops);
+  const rebuilt = rebuildGraph(currentState.snapshot, journal, currentState.edits.ops, currentState.client, currentState.vectorClock, currentState.lt);
   const graph = reuseUnchangedNodes(currentState.graph, rebuilt);
 
   const newState: ClientState = {
     ...currentState,
     journal,
-    lamportTime: undoMsg.lamportTime,
+    lt: undoMsg.lt,
     vectorClock: newClock,
     graph,
   };
@@ -437,8 +440,8 @@ export function redo(state: ClientState): { state: ClientState; msg: CRDTMessage
   for (const e of state.journal) {
     if (
       e.deletedAt &&
-      e.msg.sessionId === state.sessionId &&
-      !e.msg.ops.some(op => op.otype.startsWith('meta.'))
+      e.msg.client === state.client &&
+      !e.msg.ops.some(op => op.ot.startsWith('meta.'))
     ) {
       if (!lastDeleted || e.deletedAt > lastDeleted.deletedAt!) {
         lastDeleted = e;
@@ -449,15 +452,15 @@ export function redo(state: ClientState): { state: ClientState; msg: CRDTMessage
   if (!lastDeleted) return { state, msg: null };
 
   // Create redo message
-  const newClock = clockManager.increment(state.vectorClock, state.sessionId);
-  const newLamport = state.lamportTime + 1;
+  const newClock = clockManager.increment(state.vectorClock, state.client);
+  const newLamport = state.lt + 1;
   const redoMsg: CRDTMessage = {
-    id: `${state.sessionId}:${newLamport}`,
-    sessionId: state.sessionId,
+    id: `${state.client}:${newLamport}`,
+    client: state.client,
     clock: newClock,
-    lamportTime: newLamport,
-    timestamp: Date.now() / 1000,
-    ops: [{ otype: 'meta.redo', key: '_meta', path: '_meta', targetMsgId: lastDeleted.msg.id }],
+    lt: newLamport,
+    ts: Date.now() / 1000,
+    ops: [{ ot: 'meta.redo', key: '_meta', path: '_meta', targetMsgId: lastDeleted.msg.id }],
   };
 
   // Build new journal with redo entry + target un-deleted
@@ -470,13 +473,13 @@ export function redo(state: ClientState): { state: ClientState; msg: CRDTMessage
   });
   journal.push({ msg: redoMsg, ack: false });
 
-  const rebuilt = rebuildGraph(state.snapshot, journal, state.edits.ops);
+  const rebuilt = rebuildGraph(state.snapshot, journal, state.edits.ops, state.client, state.vectorClock, state.lt);
   const graph = reuseUnchangedNodes(state.graph, rebuilt);
 
   const newState: ClientState = {
     ...state,
     journal,
-    lamportTime: redoMsg.lamportTime,
+    lt: redoMsg.lt,
     vectorClock: newClock,
     graph,
   };
@@ -543,7 +546,7 @@ export function compact(state: ClientState): ClientState {
     const entry = state.journal[i];
     if (entry.deletedAt) continue;
 
-    const realOps = entry.msg.ops.filter(op => !op.otype.startsWith('meta.'));
+    const realOps = entry.msg.ops.filter(op => !op.ot.startsWith('meta.'));
     if (realOps.length > 0) {
       snapshotGraph = applyMessage(snapshotGraph, { ...entry.msg, ops: realOps });
     }
@@ -557,7 +560,7 @@ export function compact(state: ClientState): ClientState {
     snapshot: {
       graph: snapshotGraph,
       vectorClock: state.journal[lastAckedIdx].msg.clock,
-      lamportTime: state.journal[lastAckedIdx].msg.lamportTime,
+      lt: state.journal[lastAckedIdx].msg.lt,
       journalIndex: state.snapshot.journalIndex + lastAckedIdx + 1,
     },
     journal: state.journal.slice(lastAckedIdx + 1),
@@ -601,7 +604,7 @@ export function compactToWatermark(state: ClientState, watermark: VectorClock):
     const entry = state.journal[i];
     if (entry.deletedAt) continue;
 
-    const realOps = entry.msg.ops.filter(op => !op.otype.startsWith('meta.'));
+    const realOps = entry.msg.ops.filter(op => !op.ot.startsWith('meta.'));
     if (realOps.length > 0) {
       snapshotGraph = applyMessage(snapshotGraph, { ...entry.msg, ops: realOps });
     }
@@ -612,7 +615,7 @@ export function compactToWatermark(state: ClientState, watermark: VectorClock):
     snapshot: {
       graph: snapshotGraph,
       vectorClock: watermark,
-      lamportTime: state.journal[lastIdx].msg.lamportTime,
+      lt: state.journal[lastIdx].msg.lt,
       journalIndex: state.snapshot.journalIndex + lastIdx + 1,
     },
     journal: state.journal.slice(lastIdx + 1),
@@ -646,13 +649,13 @@ export function getPendingCount(state: ClientState): number {
  * Initialize from server snapshot + journal
  */
 export function initFromServer(
-  sessionId: string,
+  client: string,
   snapshot: Snapshot,
   journal: CRDTMessage[]
 ): ClientState {
   let graph = snapshot.graph;
   const journalEntries: JournalEntry[] = [];
-  let maxLamport = snapshot.lamportTime ?? 0;
+  let maxLamport = snapshot.lt ?? 0;
   let mergedClock: VectorClock = snapshot.vectorClock;
 
   // Filter out journal entries already baked into the snapshot to
@@ -667,11 +670,11 @@ export function initFromServer(
   for (const msg of filteredJournal) {
     // Process meta ops
     for (const op of msg.ops) {
-      if (op.otype === 'meta.undo') {
+      if (op.ot === 'meta.undo') {
         const targetMsgId = (op as any).targetMsgId;
         const target = journalEntries.find(e => e.msg.id === targetMsgId);
-        if (target) target.deletedAt = msg.lamportTime;
-      } else if (op.otype === 'meta.redo') {
+        if (target) target.deletedAt = msg.lt;
+      } else if (op.ot === 'meta.redo') {
         const targetMsgId = (op as any).targetMsgId;
         const target = journalEntries.find(e => e.msg.id === targetMsgId);
         if (target) delete target.deletedAt;
@@ -679,20 +682,21 @@ export function initFromServer(
     }
 
     journalEntries.push({ msg, ack: true });
-    maxLamport = Math.max(maxLamport, msg.lamportTime);
+    maxLamport = Math.max(maxLamport, msg.lt);
     mergedClock = clockManager.merge(mergedClock, msg.clock);
   }
 
   // Rebuild graph
-  graph = rebuildGraph(snapshot, journalEntries, []);
+  const finalClock = clockManager.increment(mergedClock, client);
+  graph = rebuildGraph(snapshot, journalEntries, [], client, finalClock, maxLamport);
 
   return {
     graph,
     journal: journalEntries,
     edits: { ops: [], baseGraph: null },
     snapshot,
-    lamportTime: maxLamport,
-    vectorClock: clockManager.increment(mergedClock, sessionId),
-    sessionId,
+    lt: maxLamport,
+    vectorClock: finalClock,
+    client: client,
   };
 }

package/src/client/coalesceGraphOps.ts

@@ -19,13 +19,13 @@ import { coalesceOperations, type CoalesceOptions } from './coalescence/index.js
  * Example:
  * ```typescript
  * const ops = [
- *   { otype: 'text.insert', id: 'alice:1', content: 'h', ... },
- *   { otype: 'text.insert', id: 'alice:2', content: 'e', ... },
- *   { otype: 'text.insert', id: 'alice:3', content: 'l', ... },
+ *   { ot: 'text.insert', id: 'alice:1', content: 'h', ... },
+ *   { ot: 'text.insert', id: 'alice:2', content: 'e', ... },
+ *   { ot: 'text.insert', id: 'alice:3', content: 'l', ... },
  * ];
  *
  * const coalesced = coalesceGraphOps(ops, { thresholdMs: 300 });
- * // Result: [{ otype: 'text.insert', id: 'alice:1', content: 'hel', ... }]
+ * // Result: [{ ot: 'text.insert', id: 'alice:1', content: 'hel', ... }]
  * ```
  *
  * @param ops - Array of graph operations

package/src/client/coalesceTextOperations.ts

@@ -13,7 +13,7 @@
 
 import type { TextOperation } from './textTypes.js';
 import type { InsertOp, DeleteOp } from '../crdt/Rope.js';
-import { parseItemId } from '../crdt/Rope.js';
+import { parseItemId, createItemId } from '../crdt/Rope.js';
 import { optimizeDeletions, parseItemId as parseId } from './coalescence/utils.js';
 
 export interface CoalesceOptions {
@@ -21,17 +21,18 @@ export interface CoalesceOptions {
   thresholdMs?: number;
 }
 
+
 /**
  * Sort and optimize deletions array.
  * Deletions must be sorted in ascending order for optimizeDeletions to work correctly.
  */
-function sortAndOptimizeDeletions(deletions: Array<{ id: string; length: number }>): Array<{ id: string; length: number }> {
+function sortAndOptimizeDeletions(deletions: Array<[string, number]>): Array<[string, number]> {
   if (deletions.length === 0) return deletions;
 
   // Sort deletions by agent, then by sequence number (ascending)
   const sorted = [...deletions].sort((a, b) => {
-    const aId = parseId(a.id);
-    const bId = parseId(b.id);
+    const aId = parseId(a[0]);  // id is at [0]
+    const bId = parseId(b[0]);  // id is at [0]
     if (aId.agent !== bId.agent) {
       return aId.agent.localeCompare(bId.agent);
     }
@@ -65,11 +66,11 @@ export function coalesceTextOperations(
   let pendingDelete: DeleteOp | null = null;
 
   for (const op of ops) {
-    if (op.otype === 'insert') {
+    if (op.ot === 'insert') {
       // Flush any pending delete before starting new insert
       if (pendingDelete !== null) {
         // Sort and optimize deletions array before flushing
-        pendingDelete.deletions = sortAndOptimizeDeletions(pendingDelete.deletions);
+        pendingDelete.rm = sortAndOptimizeDeletions(pendingDelete.rm);
         result.push(pendingDelete);
         pendingDelete = null;
       }
@@ -87,9 +88,10 @@ export function coalesceTextOperations(
         // Check merge conditions
         const sameAgent = prevId.agent === currId.agent;
 
-        // IDs must be sequential: next ID = prev ID + prev content length
-        // Example: prev="alice:5" content="hel"(3 chars) → next="alice:8"
-        const sequentialIds = currId.seq === prevId.seq + prevOp.content.length;
+        // IDs must be sequential: next ID = prev ID + prev value length
+        // Example: prev="alice:5" value="hel"(3 chars) → next="alice:8"
+        const prevContent = prevOp.value[1]; // content is at [1]
+        const sequentialIds = currId.seq === prevId.seq + prevContent.length;
 
         // Time threshold: operations must be close in time (ts is in seconds)
         const timeDiffMs = (currOp.ts - prevOp.ts) * 1000;
@@ -100,17 +102,19 @@ export function coalesceTextOperations(
         // (not the first ID, which is what prevOp.id contains after merging)
         // OR both should have the same parent (inserting at same position)
         const prevLastId = (prevOp as any)._lastCharId || prevOp.id;
+        const currOpAnchor = currOp.value[0]; // anchor is at [0] (can be null)
+        const prevOpAnchor = prevOp.value[0]; // anchor is at [0] (can be null)
         const formsChain =
-          currOp.parentId === prevLastId ||
-          (prevOp.parentId === currOp.parentId && prevOp.parentId !== null);
+          currOpAnchor === prevLastId ||
+          (prevOpAnchor === currOpAnchor && prevOpAnchor !== null);
 
         if (sameAgent && sequentialIds && withinThreshold && formsChain) {
           // Merge operations
+          const currContent = currOp.value[1]; // content is at [1]
           const mergedOp: InsertOp = {
-            otype: 'insert',
+            ot: 'insert',
             id: prevOp.id, // Keep first ID (anchor point)
-            content: prevOp.content + currOp.content, // Concatenate content
-            parentId: prevOp.parentId, // Keep first parentId
+            value: [prevOpAnchor, prevContent + currContent], // [anchor, merged content]
             seq: Math.max(prevOp.seq, currOp.seq), // Use max Lamport clock for ordering
             ts: prevOp.ts, // Keep first timestamp (when sequence started)
             // Track the last character ID for chain validation in next merge
@@ -120,16 +124,16 @@ export function coalesceTextOperations(
         } else {
           // Debug: Log why merge failed
           if (!sameAgent) console.log('[coalesce] Different agents:', prevId.agent, 'vs', currId.agent);
-          if (!sequentialIds) console.log('[coalesce] Non-sequential IDs:', currId.seq, '!==', prevId.seq + prevOp.content.length);
+          if (!sequentialIds) console.log('[coalesce] Non-sequential IDs:', currId.seq, '!==', prevId.seq + prevContent.length);
           if (!withinThreshold) console.log('[coalesce] Time threshold exceeded:', timeDiffMs, 'ms >', thresholdMs, 'ms');
-          if (!formsChain) console.log('[coalesce] Not a YATA chain:', { currParent: currOp.parentId, prevId: prevOp.id, prevParent: prevOp.parentId, currOp: currOp.id });
+          if (!formsChain) console.log('[coalesce] Not a YATA chain:', { currAnchor: currOpAnchor, prevId: prevOp.id, prevAnchor: prevOpAnchor, currOp: currOp.id });
 
           // Can't merge - flush pending and start new
           result.push(pendingInsert);
           pendingInsert = { ...currOp };
         }
       }
-    } else if (op.otype === 'delete') {
+    } else if (op.ot === 'delete') {
       // Flush any pending insert before handling delete
       if (pendingInsert !== null) {
         result.push(pendingInsert);
@@ -138,7 +142,7 @@ export function coalesceTextOperations(
 
       if (pendingDelete === null) {
         // Start new pending delete
-        pendingDelete = { ...op, deletions: [...op.deletions] };
+        pendingDelete = { ...op, rm: [...op.rm] };
       } else {
         // Try to merge consecutive delete operations
         // Deletes can be merged if they're within the time threshold
@@ -147,11 +151,11 @@ export function coalesceTextOperations(
 
         if (canMerge) {
           // Merge by combining deletions
-          pendingDelete.deletions.push(...op.deletions);
+          pendingDelete.rm.push(...op.rm);
         } else {
           // Can't merge - flush pending and start new
           result.push(pendingDelete);
-          pendingDelete = { ...op, deletions: [...op.deletions] };
+          pendingDelete = { ...op, rm: [...op.rm] };
         }
       }
     } else {
@@ -162,7 +166,7 @@ export function coalesceTextOperations(
       }
       if (pendingDelete !== null) {
         // Sort and optimize deletions array before flushing
-        pendingDelete.deletions = sortAndOptimizeDeletions(pendingDelete.deletions);
+        pendingDelete.rm = sortAndOptimizeDeletions(pendingDelete.rm);
         result.push(pendingDelete);
         pendingDelete = null;
       }
@@ -176,7 +180,7 @@ export function coalesceTextOperations(
   }
   if (pendingDelete !== null) {
     // Sort and optimize deletions array before flushing
-    pendingDelete.deletions = sortAndOptimizeDeletions(pendingDelete.deletions);
+    pendingDelete.rm = sortAndOptimizeDeletions(pendingDelete.rm);
     result.push(pendingDelete);
   }
 

package/src/client/coalescence/lwwOperations.ts

@@ -41,8 +41,8 @@ export type LWWSetOp =
  */
 export function isLWWSetOp(op: Operation): op is LWWSetOp {
   return (
-    typeof op.otype === 'string' &&
-    op.otype.endsWith('.set') &&
+    typeof op.ot === 'string' &&
+    op.ot.endsWith('.set') &&
     (op as any).value !== undefined
   );
 }
@@ -82,7 +82,7 @@ export function coalesceLWWSets(
       const sameTarget =
         pending.key === op.key &&
         pending.path === op.path &&
-        pending.otype === op.otype;
+        pending.ot === op.ot;
 
       if (sameTarget) {
         // LWW: Replace with newer value

package/src/client/coalescence/numberOperations.ts

@@ -16,7 +16,7 @@ export type { NumberAddOp };
  */
 export function isNumberAddOp(op: Operation): op is NumberAddOp {
   return (
-    op.otype === 'number.add' &&
+    op.ot === 'number.add' &&
     typeof (op as any).value === 'number'
   );
 }
@@ -58,7 +58,7 @@ export function coalesceNumberAdds(
       if (sameTarget) {
         // Merge operations by summing values
         pending = {
-          otype: 'number.add',
+          ot: 'number.add',
           key: pending.key,
           path: pending.path,
           value: pending.value + op.value,

package/src/client/coalescence/registry.ts

@@ -5,12 +5,13 @@
  * Allows extensible operation coalescence with a consistent interface.
  */
 
-import type { Operation } from '../../operations/OperationTypes.js';
+import type { Operation, TextInsertOp as GraphTextInsert, TextDeleteOp as GraphTextDelete, TextReplaceOp } from '../../operations/OperationTypes.js';
 import { coalesceTextInserts, isTextInsertOp, type TextInsertOp } from './textInserts.js';
 import { coalesceTextDeletes, isTextDeleteOp, type TextDeleteOp } from './textDeletes.js';
 import { coalesceNumberAdds, isNumberAddOp } from './numberOperations.js';
 import { coalesceVector3Adds, isVector3AddOp } from './vector3Operations.js';
 import { coalesceLWWSets, isLWWSetOp } from './lwwOperations.js';
+import { parseItemId } from '../../crdt/Rope.js';
 
 export interface CoalesceOptions {
   /** Time threshold in milliseconds (default: 1000ms = 1 second) */
@@ -47,11 +48,11 @@ const registry = new Map<string, RegistryEntry>();
  * Register a coalescence handler for an operation type
  */
 export function registerCoalescer<T extends Operation>(
-  otype: string,
+  ot: string,
   guard: TypeGuard<T>,
   handler: CoalesceHandler<T>
 ): void {
-  registry.set(otype, {
+  registry.set(ot, {
     guard: guard as unknown as TypeGuard,
     handler: handler as unknown as CoalesceHandler
   });
@@ -60,15 +61,15 @@ export function registerCoalescer<T extends Operation>(
 /**
  * Get coalescence handler for an operation type
  */
-export function getCoalescer(otype: string): RegistryEntry | undefined {
-  return registry.get(otype);
+export function getCoalescer(ot: string): RegistryEntry | undefined {
+  return registry.get(ot);
 }
 
 /**
  * Check if an operation type has a registered coalescer
  */
-export function hasCoalescer(otype: string): boolean {
-  return registry.has(otype);
+export function hasCoalescer(ot: string): boolean {
+  return registry.has(ot);
 }
 
 /**
@@ -89,11 +90,11 @@ export function coalesceOperations(
   let currentType: string | null = null;
 
   for (const op of ops) {
-    const entry = registry.get(op.otype);
+    const entry = registry.get(op.ot);
 
     if (entry && entry.guard(op)) {
       // Operation has a coalescer
-      if (currentType === op.otype) {
+      if (currentType === op.ot) {
         // Same type - add to pending group
         pendingGroup.push(op);
       } else {
@@ -105,7 +106,7 @@ export function coalesceOperations(
             result.push(...coalesced);
           }
         }
-        currentType = op.otype;
+        currentType = op.ot;
         pendingGroup = [op];
       }
     } else {
@@ -154,6 +155,6 @@ const LWW_SET_OPERATIONS = [
   'object.set',
 ] as const;
 
-for (const otype of LWW_SET_OPERATIONS) {
-  registerCoalescer(otype, isLWWSetOp as TypeGuard<any>, coalesceLWWSets as CoalesceHandler<any>);
+for (const ot of LWW_SET_OPERATIONS) {
+  registerCoalescer(ot, isLWWSetOp as TypeGuard<any>, coalesceLWWSets as CoalesceHandler<any>);
 }