@datalayer/lexical-loro 1.0.3 → 1.0.5

package/lib/collab/loro/servers/ws/utils.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { LoroDoc, EphemeralStore } from 'loro-crdt';
@@ -20,13 +20,13 @@ const persistenceDir = process.env.YPERSISTENCE;
 // Helper function to log tree structure for debugging
 const logTreeStructure = (doc, context) => {
     try {
-        console.log(`[Server] ${context} - Tree Structure Debug:`);
+        console.log(`[LORO] ${context} - Tree Structure Debug:`);
         // Try to get the tree container using getTree method
         try {
             const tree = doc.getTree('tree');
             if (tree) {
                 const nodes = tree.nodes();
-                console.log(`[Server] Total nodes in tree: ${nodes.length}`);
+                console.log(`[LORO] Total nodes in tree: ${nodes.length}`);
                 // Helper function to recursively log tree structure
                 const logTreeStructureRecursive = (node, prefix = '', isLast = true, depth = 0) => {
                     const data = Object.fromEntries(node.data.entries());
@@ -34,7 +34,7 @@ const logTreeStructure = (doc, context) => {
                     const elementType = data.elementType || 'no-type';
                     const connector = depth === 0 ? '' : (isLast ? '└── ' : '├── ');
                     const nodeInfo = `TreeID(${treeId.slice(0, 8)}...) [${elementType}]`;
-                    console.log(`[Server] ${prefix}${connector}${nodeInfo}`);
+                    console.log(`[LORO] ${prefix}${connector}${nodeInfo}`);
                     const children = node.children();
                     if (children && children.length > 0) {
                         children.forEach((child, index) => {
@@ -50,10 +50,10 @@ const logTreeStructure = (doc, context) => {
                     const data = Object.fromEntries(node.data.entries());
                     return !parent || data.isRoot;
                 });
-                console.log(`[Server] Root nodes: ${rootNodes.length}`);
+                console.log(`[LORO] Root nodes: ${rootNodes.length}`);
                 console.log('');
                 if (rootNodes.length === 0) {
-                    console.log('[Server] ⚠️  No root nodes found!');
+                    console.log('[LORO]   No root nodes found!');
                 }
                 else {
                     rootNodes.forEach((root, index) => {
@@ -63,25 +63,25 @@ const logTreeStructure = (doc, context) => {
                 }
             }
             else {
-                console.log(`[Server] No tree container found`);
+                console.log(`[LORO] No tree container found`);
             }
         }
         catch (treeError) {
-            console.log(`[Server] Error accessing tree container:`, treeError.message);
+            console.log(`[LORO] Error accessing tree container:`, treeError.message);
         }
         // Try export with different modes for debugging
         try {
             const snapshot = doc.export({ mode: 'snapshot' });
-            console.log(`[Server] Snapshot size: ${snapshot.length} bytes`);
+            console.log(`[LORO] Snapshot size: ${snapshot.length} bytes`);
             const update = doc.export({ mode: 'update' });
-            console.log(`[Server] Update size: ${update.length} bytes`);
+            console.log(`[LORO] Update size: ${update.length} bytes`);
         }
         catch (exportError) {
-            console.log(`[Server] Error exporting:`, exportError.message);
+            console.log(`[LORO] Error exporting:`, exportError.message);
         }
     }
     catch (error) {
-        console.warn(`[Server] Error logging tree structure:`, error);
+        console.warn(`[LORO] Error logging tree structure:`, error);
     }
 };
 /**
@@ -193,7 +193,7 @@ const messageListener = (conn, doc, message) => {
                 messageStr = decoder.decode(message);
             }
             catch (decodeError) {
-                console.warn(`[Server] messageListener - Failed to decode ArrayBuffer as string, treating as binary Loro update`);
+                console.warn(`[LORO] messageListener - Failed to decode ArrayBuffer as string, treating as binary Loro update`);
                 // If decoding fails, treat as raw binary Loro update
                 const updateBytes = new Uint8Array(message);
                 doc.doc.import(updateBytes);
@@ -212,7 +212,7 @@ const messageListener = (conn, doc, message) => {
                 messageStr = decoder.decode(message);
             }
             catch (decodeError) {
-                console.warn(`[Server] messageListener - Failed to decode Uint8Array as string, treating as binary Loro update`);
+                console.warn(`[LORO] messageListener - Failed to decode Uint8Array as string, treating as binary Loro update`);
                 // If decoding fails, treat as raw binary Loro update
                 doc.doc.import(message);
                 // Broadcast the update to other connections
@@ -225,7 +225,7 @@ const messageListener = (conn, doc, message) => {
             }
         }
         else {
-            console.warn(`[Server] messageListener - Unknown message type:`, typeof message);
+            console.warn(`[LORO] messageListener - Unknown message type:`, typeof message);
             return;
         }
         if (!messageStr || messageStr.length === 0) {
@@ -235,31 +235,31 @@ const messageListener = (conn, doc, message) => {
             messageData = JSON.parse(messageStr);
         }
         catch (parseError) {
-            console.warn(`[Server] messageListener - JSON parse error:`, parseError.message);
-            console.warn(`[Server] messageListener - Raw message:`, messageStr.substring(0, 500));
+            console.warn(`[LORO] messageListener - JSON parse error:`, parseError.message);
+            console.warn(`[LORO] messageListener - Raw message:`, messageStr.substring(0, 500));
             return;
         }
-        console.log(`[Server] Received message type: ${messageData.type} for doc: ${doc.name}`);
+        console.log(`[LORO] Received message type: ${messageData.type} for doc: ${doc.name}`);
         switch (messageData.type) {
             case messageQuerySnapshot:
                 // Client is requesting a snapshot - send current document state
                 const requestId = Math.random().toString(36).substr(2, 9);
-                console.log(`[Server] Client requesting snapshot for doc: ${doc.name} (Request ID: ${requestId})`);
+                console.log(`[LORO] Client requesting snapshot for doc: ${doc.name} (Request ID: ${requestId})`);
                 // Log tree structure before creating snapshot
                 // logTreeStructure(doc.doc, `Before creating snapshot (Request ID: ${requestId})`)
                 try {
                     const snapshot = doc.doc.export({ mode: 'snapshot' });
-                    console.log(`[Server] Sending snapshot response: ${snapshot.length} bytes (Request ID: ${requestId})`);
+                    console.log(`[LORO] Sending snapshot response: ${snapshot.length} bytes (Request ID: ${requestId})`);
                     // Verify the snapshot contains expected content
                     const tree = doc.doc.getTree('tree');
                     const nodes = tree.nodes();
-                    console.log(`[Server] Snapshot contains ${nodes.length} nodes from server document`);
+                    console.log(`[LORO] Snapshot contains ${nodes.length} nodes from server document`);
                     // Send binary snapshot data directly instead of wrapped message
                     conn.send(snapshot);
                 }
                 catch (snapshotError) {
-                    console.error(`[Server] ERROR creating/sending snapshot:`, snapshotError.message);
-                    console.error(`[Server] Stack:`, snapshotError.stack);
+                    console.error(`[LORO] ERROR creating/sending snapshot:`, snapshotError.message);
+                    console.error(`[LORO] Stack:`, snapshotError.stack);
                 }
                 break;
             case messageEphemeral:
@@ -273,7 +273,7 @@ const messageListener = (conn, doc, message) => {
                     doc.ephemeralStore.apply(ephemeralBytes);
                     const afterStates = doc.ephemeralStore.getAllStates();
                     const afterKeys = Object.keys(afterStates);
-                    console.log(`📡 SERVER DEBUG - Applied ephemeral update from ${conn.id}:`, {
+                    console.log(` SERVER DEBUG - Applied ephemeral update from ${conn.id}:`, {
                         bytesLength: ephemeralBytes.length,
                         beforeKeys,
                         afterKeys,
@@ -293,7 +293,7 @@ const messageListener = (conn, doc, message) => {
                     const allStates = doc.ephemeralStore.getAllStates();
                     const allKeys = Object.keys(allStates);
                     const ephemeralUpdate = doc.ephemeralStore.encodeAll();
-                    console.log(`📡 SERVER DEBUG - Client ${conn.id} requesting ephemeral state:`, {
+                    console.log(` SERVER DEBUG - Client ${conn.id} requesting ephemeral state:`, {
                         allKeysAvailable: allKeys,
                         encodedLength: ephemeralUpdate.length,
                         totalConnections: doc.conns.size
@@ -306,7 +306,7 @@ const messageListener = (conn, doc, message) => {
                     sendMessage(doc, conn, ephemeralResponse);
                 }
                 catch (error) {
-                    console.warn('[Server] messageQueryEphemeral - ERROR encoding/sending ephemeral state:', error);
+                    console.warn('[LORO] messageQueryEphemeral - ERROR encoding/sending ephemeral state:', error);
                 }
                 break;
             case messageUpdate:
@@ -359,16 +359,16 @@ const closeConn = (doc, conn) => {
         if (doc.conns.size === 0) {
             if (persistence !== null) {
                 // if persisted, we store state and cleanup document
-                console.log(`[Server] Persisting document ${doc.name} before cleanup`);
+                console.log(`[LORO] Persisting document ${doc.name} before cleanup`);
                 persistence.writeState(doc.name, doc).then(() => {
                     // Cleanup WSSharedDoc resources (no destroy method needed for Loro)
-                    console.log(`[Server] Document ${doc.name} persisted and cleaned up`);
+                    console.log(`[LORO] Document ${doc.name} persisted and cleaned up`);
                 });
                 docs.delete(doc.name);
             }
             else {
                 // No persistence configured - keep document in memory for reconnections
-                console.log(`[Server] No persistence configured - keeping document ${doc.name} in memory for future connections`);
+                console.log(`[LORO] No persistence configured - keeping document ${doc.name} in memory for future connections`);
                 // logTreeStructure(doc.doc, `Document ${doc.name} structure before keeping in memory`)
             }
         }
@@ -425,17 +425,17 @@ export const setupWSConnection = (conn, req, { docName = (req.url || '').slice(1
         // logTreeStructure(doc.doc, `Before creating initial snapshot for new client ${conn.id}`)
         try {
             const snapshot = doc.doc.export({ mode: 'snapshot' });
-            console.log(`[Server] Sending initial snapshot to new client: ${snapshot.length} bytes`);
+            console.log(`[LORO] Sending initial snapshot to new client: ${snapshot.length} bytes`);
             // Verify the snapshot contains expected content
             const tree = doc.doc.getTree('tree');
             const nodes = tree.nodes();
-            console.log(`[Server] Initial snapshot contains ${nodes.length} nodes from server document`);
+            console.log(`[LORO] Initial snapshot contains ${nodes.length} nodes from server document`);
             // Send binary snapshot data directly instead of wrapped message
             conn.send(snapshot);
         }
         catch (snapshotError) {
-            console.error(`[Server] ERROR creating/sending initial snapshot:`, snapshotError.message);
-            console.error(`[Server] Stack:`, snapshotError.stack);
+            console.error(`[LORO] ERROR creating/sending initial snapshot:`, snapshotError.message);
+            console.error(`[LORO] Stack:`, snapshotError.stack);
         }
         // Send current ephemeral state if any
         const ephemeralUpdate = doc.ephemeralStore.encodeAll();
@@ -461,7 +461,7 @@ export class WSSharedDoc {
         this.name = name;
         this.doc = new LoroDoc();
         // Initialize the document with default Lexical content
-        console.log(`[Server] Initializing document '${name}' with default content`);
+        console.log(`[LORO] Initializing document '${name}' with default content`);
         initializeLoroDocWithLexicalContent(this.doc);
         /**
          * Maps from conn to set of controlled ephemeral keys. Delete all keys when this conn is closed
@@ -503,7 +503,7 @@ export class WSSharedDoc {
                     this.lastEphemeralSender = null;
                 }
                 catch (broadcastError) {
-                    console.warn(`[Server] ephemeralChangeIntegrator - ERROR broadcasting:`, {
+                    console.warn(`[LORO] ephemeralChangeIntegrator - ERROR broadcasting:`, {
                         error: broadcastError.message,
                         stack: broadcastError.stack
                     });

package/lib/collab/loro/sync/SyncCursors.js

@@ -1,9 +1,37 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { $getNodeByKey, $getSelection, $isElementNode, $isLineBreakNode, $isRangeSelection, $isTextNode, } from 'lexical';
 import { createDOMRange, createRectsFromDOMRange } from '@lexical/selection';
+function getDisplayNameFromAwareness(awareness) {
+    const awarenessData = awareness.awarenessData;
+    if (!awarenessData || typeof awarenessData !== 'object') {
+        return awareness.name;
+    }
+    const data = awarenessData;
+    const user = data.user;
+    const userRecord = user && typeof user === 'object' ? user : undefined;
+    const candidates = [
+        userRecord?.display_name,
+        userRecord?.displayName,
+        userRecord?.name,
+        userRecord?.username,
+        userRecord?.handle,
+        data.display_name,
+        data.displayName,
+        data.name,
+        data.username,
+        data.handle,
+        awareness.name,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim().length > 0) {
+            return candidate;
+        }
+    }
+    return awareness.name;
+}
 /*****************************************************************************/
 // Helper function to find Loro tree node for a Lexical NodeKey (read-only lookup)
 function findLoroTreeNodeForLexicalKey(nodeKey, binding) {
@@ -151,19 +179,8 @@ function createCollabCursor(name, color) {
 }
 function createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset, isCurrentUser = false) {
     const color = cursor.color;
-    // Helper function to convert color to rgba with opacity
-    const getColorWithOpacity = (color, opacity) => {
-        if (color.startsWith('#')) {
-            const hex = color.slice(1);
-            const r = parseInt(hex.slice(0, 2), 16);
-            const g = parseInt(hex.slice(2, 4), 16);
-            const b = parseInt(hex.slice(4, 6), 16);
-            return `rgba(${r}, ${g}, ${b}, ${opacity})`;
-        }
-        return color;
-    };
-    const caretColor = isCurrentUser ? getColorWithOpacity(color, 0.6) : color;
-    const nameBackgroundColor = isCurrentUser ? getColorWithOpacity(color, 0.7) : color;
+    const caretColor = color;
+    const nameBackgroundColor = color;
     const caret = document.createElement('span');
     caret.style.cssText = `position:absolute;top:0;bottom:0;right:-1px;width:2px;background-color:${caretColor};z-index:10;${isCurrentUser ? 'opacity:0.8;' : ''}`;
     const name = document.createElement('span');
@@ -210,16 +227,25 @@ export function syncCursorPositions(binding, provider, options) {
         const awarenessState = awarenessStates[i];
         const [clientID, awareness] = awarenessState;
         visitedClientIDs.add(clientID);
-        const { name, color, focusing } = awareness;
+        const { color } = awareness;
+        const displayName = getDisplayNameFromAwareness(awareness);
         const isCurrentUser = clientID === localClientID;
         let selection = null;
         let cursor = cursors.get(clientID);
         if (cursor === undefined) {
             // Add "(Me)" label for current user's cursor
-            const cursorName = isCurrentUser ? `${name} (Me)` : name;
+            const cursorName = isCurrentUser ? `${displayName} (Me)` : displayName;
             cursor = createCollabCursor(cursorName, color);
             cursors.set(clientID, cursor);
         }
+        else if (cursor.name !== displayName) {
+            cursor.name = displayName;
+            if (cursor.selection) {
+                cursor.selection.name.textContent = isCurrentUser
+                    ? `${displayName} (Me)`
+                    : displayName;
+            }
+        }
         // Render cursor/selection whenever valid anchorPos/focusPos exist.
         // We intentionally do NOT gate on `focusing` because the FOCUS_COMMAND
         // and selection-update can race — the selection update may broadcast

package/lib/collab/loro/sync/SyncLexicalToLoro.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { RootNode, ElementNode, TextNode, LineBreakNode, DecoratorNode, $getSelection, $getNodeByKey } from 'lexical';
@@ -14,6 +14,13 @@ import { syncLexicalSelectionToLoro } from './SyncCursors';
 // import { syncCursorPositions, SyncCursorPositionsFn } from './SyncCursors';
 export function syncLexicalToLoro(binding, provider, update) {
     const { mutatedNodes, prevEditorState, editorState: currEditorState, } = update;
+    let __seedDebugMutationCount = 0;
+    if (mutatedNodes) {
+        mutatedNodes.forEach((nodeMap) => {
+            __seedDebugMutationCount += nodeMap.size;
+        });
+    }
+    console.log('[SEED-DEBUG] syncLexicalToLoro: mutatedNodes=', mutatedNodes ? 'map' : 'null', 'totalMutations=', __seedDebugMutationCount, 'tags=', Array.from(update.tags));
     // Process node mutations if present.
     // NOTE: mutatedNodes is null for selection-only updates (no DOM mutations).
     // See Lexical docs: "Will be null if no DOM was mutated, such as when only
@@ -53,50 +60,82 @@ export function syncLexicalToLoro(binding, provider, update) {
                     });
                 }
             });
-            // Phase 2: Collect all ElementNode mutations, sort by depth, then propagate
-            const elementMutations = [];
+            const collected = [];
             mutatedNodes.forEach((nodeMap, Klass) => {
-                if (isClassExtending(Klass, ElementNode) && !isClassExtending(Klass, RootNode)) {
-                    nodeMap.forEach((mutation, nodeKey) => {
-                        // Compute depth in Lexical tree (root=0, paragraph=1, tablecell=3, etc.)
-                        let depth = 0;
-                        currEditorState.read(() => {
-                            const node = $getNodeByKey(nodeKey);
-                            if (node) {
-                                let current = node.getParent();
-                                while (current) {
-                                    depth++;
-                                    current = current.getParent();
-                                }
-                            }
-                        });
-                        elementMutations.push({ mutation, nodeKey, depth });
-                    });
+                let category = null;
+                if (isClassExtending(Klass, RootNode)) {
+                    return; // handled in Phase 1
                 }
-            });
-            // Sort by depth ascending → parents (depth 1) are propagated before children (depth 2, 3, …)
-            elementMutations.sort((a, b) => a.depth - b.depth);
-            for (const { mutation, nodeKey } of elementMutations) {
-                propagateElementNode(update, mutation, nodeKey, mutatorOptions);
-            }
-            // Phase 3: Process leaf children (their parents are now guaranteed to be mapped)
-            mutatedNodes.forEach((nodeMap, Klass) => {
-                if (isClassExtending(Klass, TextNode)) {
-                    nodeMap.forEach((mutation, nodeKey) => {
-                        propagateTextNode(update, mutation, nodeKey, mutatorOptions);
-                    });
+                else if (isClassExtending(Klass, ElementNode)) {
+                    category = 'element';
+                }
+                else if (isClassExtending(Klass, TextNode)) {
+                    category = 'text';
                 }
                 else if (isClassExtending(Klass, LineBreakNode)) {
-                    nodeMap.forEach((mutation, nodeKey) => {
-                        propagateLineBreakNode(update, mutation, nodeKey, mutatorOptions);
-                    });
+                    category = 'linebreak';
                 }
                 else if (isClassExtending(Klass, DecoratorNode)) {
-                    nodeMap.forEach((mutation, nodeKey) => {
-                        propagateDecoratorNode(update, mutation, nodeKey, mutatorOptions);
-                    });
+                    category = 'decorator';
+                }
+                if (category === null) {
+                    return;
                 }
+                const resolvedCategory = category;
+                nodeMap.forEach((mutation, nodeKey) => {
+                    // Compute depth (root=0, paragraph=1, inline element=2, …) and the
+                    // node's index within its parent from the current editor state.
+                    let depth = 0;
+                    let index = 0;
+                    currEditorState.read(() => {
+                        const node = $getNodeByKey(nodeKey);
+                        if (node) {
+                            index = node.getIndexWithinParent();
+                            let current = node.getParent();
+                            while (current) {
+                                depth++;
+                                current = current.getParent();
+                            }
+                        }
+                    });
+                    collected.push({ mutation, nodeKey, depth, index, category: resolvedCategory });
+                });
             });
+            const dispatch = (info) => {
+                switch (info.category) {
+                    case 'element':
+                        propagateElementNode(update, info.mutation, info.nodeKey, mutatorOptions);
+                        break;
+                    case 'text':
+                        propagateTextNode(update, info.mutation, info.nodeKey, mutatorOptions);
+                        break;
+                    case 'linebreak':
+                        propagateLineBreakNode(update, info.mutation, info.nodeKey, mutatorOptions);
+                        break;
+                    case 'decorator':
+                        propagateDecoratorNode(update, info.mutation, info.nodeKey, mutatorOptions);
+                        break;
+                }
+            };
+            // Destroys first, deepest-first (children before parents), to avoid
+            // re-create/update races during bulk deletes.
+            collected
+                .filter(m => m.mutation === 'destroyed')
+                .sort((a, b) => b.depth - a.depth)
+                .forEach(dispatch);
+            // Creates next, shallow-first then ascending sibling index (see rationale
+            // above) so every Loro insertion index stays within range.
+            collected
+                .filter(m => m.mutation === 'created')
+                .sort((a, b) => a.depth - b.depth || a.index - b.index)
+                .forEach(dispatch);
+            // Updates last, parents-first for determinism. Updates never call
+            // createLoroNode (the mapping already exists) so their order is not
+            // index-sensitive.
+            collected
+                .filter(m => m.mutation === 'updated')
+                .sort((a, b) => a.depth - b.depth || a.index - b.index)
+                .forEach(dispatch);
             // Commit only when there were actual node mutations (not selection-only changes)
             binding.doc.commit({ origin: binding.doc.peerIdStr });
         }

package/lib/collab/loro/sync/SyncLoroToLexical.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { $addUpdateTag, $createParagraphNode, $getRoot, $getSelection, $isRangeSelection, $setSelection, SKIP_COLLAB_TAG, SKIP_SCROLL_INTO_VIEW_TAG } from 'lexical';
@@ -30,31 +30,37 @@ export function syncLoroToLexical(binding, provider, eventBatch, isFromUndoMange
         }
         // Process Loro events and apply them to Lexical using the appropriate integrators
         eventBatch.events.forEach((event, index) => {
-            switch (event.diff.type) {
-                case 'tree':
-                    // Call internal method that doesn't wrap in editor.update()
-                    treeIntegrator.integrateInternal(event.diff, binding, provider);
-                    break;
-                case 'map':
-                    // Call internal method that doesn't wrap in editor.update()
-                    if (event.target) {
-                        mapIntegrator.integrateWithContextInternal(event.diff, event.target, binding, provider);
-                    }
-                    else {
-                        mapIntegrator.integrateInternal(event.diff, binding, provider);
-                    }
-                    break;
-                case 'list':
-                    listIntegrator.integrateInternal(event.diff, binding, provider);
-                    break;
-                case 'text':
-                    textIntegrator.integrateInternal(event.diff, binding, provider);
-                    break;
-                case 'counter':
-                    counterIntegrator.integrateInternal(event.diff, binding, provider);
-                    break;
-                default:
-                    throw new Error(`Unsupported event diff type: ${event.diff.type}. Supported types are: 'tree', 'map', 'list', 'text', 'counter'.`);
+            try {
+                switch (event.diff.type) {
+                    case 'tree':
+                        // Call internal method that doesn't wrap in editor.update()
+                        treeIntegrator.integrateInternal(event.diff, binding, provider);
+                        break;
+                    case 'map':
+                        // Call internal method that doesn't wrap in editor.update()
+                        if (event.target) {
+                            mapIntegrator.integrateWithContextInternal(event.diff, event.target, binding, provider);
+                        }
+                        else {
+                            mapIntegrator.integrateInternal(event.diff, binding, provider);
+                        }
+                        break;
+                    case 'list':
+                        listIntegrator.integrateInternal(event.diff, binding, provider);
+                        break;
+                    case 'text':
+                        textIntegrator.integrateInternal(event.diff, binding, provider);
+                        break;
+                    case 'counter':
+                        counterIntegrator.integrateInternal(event.diff, binding, provider);
+                        break;
+                    default:
+                        throw new Error(`Unsupported event diff type: ${event.diff.type}. Supported types are: 'tree', 'map', 'list', 'text', 'counter'.`);
+                }
+            }
+            catch (err) {
+                console.error('[SEED-DEBUG] syncLoroToLexical: integrator threw for event', index, 'diffType=', event.diff?.type, 'target=', String(event?.target), 'diff=', JSON.stringify(event.diff), err);
+                throw err;
             }
         });
         const selection = $getSelection();

package/lib/collab/loro/types/LexicalNodeData.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 /**