@datalayer/lexical-loro 1.0.3 → 1.0.5

package/lib/collab/loro/propagators/ElementNodePropagator.js

@@ -1,9 +1,10 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { $createParagraphNode, $isElementNode } from 'lexical';
 import { getNodeMapper } from '../nodes/NodesMapper';
+import { invariant } from '../utils/Invariant';
 /**
  * Create ElementNode in Loro tree
  */
@@ -28,7 +29,7 @@ options) {
 /**
  * Update ElementNode in Loro tree
  */
-export function updateElementNodeInLoro(nodeKey, elementType, parentId, index, metadata, lexicalNodeJSON, // JSON object from exportJSON()
+export function updateElementNodeInLoro(nodeKey, elementType, parentId, index, previousSiblingId, nextSiblingId, metadata, lexicalNodeJSON, // JSON object from exportJSON()
 options) {
     const mapper = getNodeMapper();
     // Get the existing tree node using the mapper (don't pass lexicalNode to avoid context issues)
@@ -42,44 +43,87 @@ options) {
     if (elementType !== undefined) {
         treeNode.data.set('elementType', elementType);
     }
-    // Move the node if parent or position changed
+    // Move the node only if its position in Loro actually differs from Lexical.
     if (parentId !== undefined || index !== undefined) {
-        // Note: For moving, we need access to tree - this might need to be propagated differently
         const { tree } = options;
-        // CRITICAL: Prevent cycle moves - a node cannot be its own parent
-        if (parentId && treeNode.id === parentId) {
-            console.warn(`🚨 CYCLE MOVE DETECTED: Node ${treeNode.id} cannot be its own parent! Skipping move operation.`);
-            return;
-        }
-        // Debug: Check if the parent exists and its children count
-        const parentNode = parentId ? tree.getNodeByID(parentId) : null;
-        const parentChildCount = parentNode ? parentNode.children.length : tree.roots().length;
-        // Check if the node is already a child of the target parent
+        // A node can never be its own parent — that indicates a wrong parent
+        // mapping upstream, not something to silently skip.
+        invariant(!(parentId && treeNode.id === parentId), 'updateElementNodeInLoro: cycle move (node is its own parent)', { nodeKey, treeId: treeNode.id });
+        // Where does the node currently sit in the Loro tree?
         const currentParent = treeNode.parent();
-        const isAlreadyChild = currentParent?.id === parentId;
-        if (index !== undefined) {
-            let adjustedIndex = index;
-            if (!isAlreadyChild) {
-                // Moving to a new parent - check bounds against current child count
-                if (index > parentChildCount) {
-                    adjustedIndex = parentChildCount;
+        const currentParentId = currentParent ? currentParent.id : undefined;
+        const siblings = currentParent ? (currentParent.children() ?? []) : tree.roots();
+        const currentIndex = siblings.findIndex(child => child.id === treeNode.id);
+        const sameParent = currentParentId === parentId;
+        // Re-issuing a move on every content edit is unnecessary and races with
+        // sibling creation (the classic source of "index out of range"). Only move
+        // when the parent or index genuinely changed. This is a real no-op check,
+        // not a masked failure.
+        const needsMove = !sameParent || (index !== undefined && index !== currentIndex);
+        if (needsMove) {
+            const parentNode = parentId ? tree.getNodeByID(parentId) : null;
+            const parentChildCount = parentNode
+                ? (parentNode.children()?.length ?? 0)
+                : tree.roots().length;
+            if (index !== undefined) {
+                // Loro move index bounds:
+                //   same-parent reorder : [0, children.length - 1]
+                //   cross-parent move   : [0, children.length]
+                // An index outside this range means the position was computed against
+                // siblings that are not yet synced. Before failing, resolve index
+                // from mapped sibling anchors when available.
+                let targetIndex = index;
+                const maxIndex = sameParent
+                    ? Math.max(parentChildCount - 1, 0)
+                    : parentChildCount;
+                if (targetIndex < 0 || targetIndex > maxIndex) {
+                    const targetSiblings = parentNode
+                        ? (parentNode.children() ?? [])
+                        : tree.roots();
+                    if (previousSiblingId) {
+                        const prevIndex = targetSiblings.findIndex(child => child.id === previousSiblingId);
+                        if (prevIndex >= 0) {
+                            targetIndex = prevIndex + 1;
+                        }
+                    }
+                    if ((targetIndex < 0 || targetIndex > maxIndex) && nextSiblingId) {
+                        const nextIndex = targetSiblings.findIndex(child => child.id === nextSiblingId);
+                        if (nextIndex >= 0) {
+                            targetIndex = nextIndex;
+                        }
+                    }
+                    // A move can observe transiently sparse sibling mappings within one
+                    // update batch (e.g. pressing Enter at the end of the document, where
+                    // the sibling created in the same batch is not yet mapped). When the
+                    // anchors cannot resolve the position, clamp into the valid Loro range
+                    // instead of throwing: a hard failure rolls back the user's keystroke,
+                    // whereas a bounded placement still converges via the CRDT and can be
+                    // refined by subsequent updates.
+                    if (targetIndex < 0 || targetIndex > maxIndex) {
+                        const clamped = Math.min(Math.max(targetIndex, 0), maxIndex);
+                        console.warn(`[loro-collab] updateElementNodeInLoro: clamping out-of-range move index`, {
+                            nodeKey,
+                            treeId: treeNode.id,
+                            index,
+                            targetIndex,
+                            clamped,
+                            maxIndex,
+                            sameParent,
+                            previousSiblingId,
+                            nextSiblingId,
+                        });
+                        targetIndex = clamped;
+                    }
                 }
+                tree.move(treeNode.id, parentId, targetIndex);
+            }
+            else {
+                tree.move(treeNode.id, parentId, parentChildCount);
             }
-            tree.move(treeNode.id, parentId, adjustedIndex);
-        }
-        else {
-            // No specific index, append to end
-            tree.move(treeNode.id, parentId, parentChildCount);
         }
     }
-    // The exported Lexical node data is already propagated by the mapper
-    // No additional JSON export needed since mapper propagates exportJSON automatically
-    try {
-        treeNode.data.set('lastUpdated', Date.now());
-    }
-    catch (error) {
-        console.warn(`🔄 ElementNode ${treeNode.id} container deleted during timestamp update (normal during operations):`, error.message);
-    }
+    // The exported Lexical node data is already propagated by the mapper.
+    treeNode.data.set('lastUpdated', Date.now());
 }
 /**
  * Delete ElementNode from Loro tree
@@ -263,7 +307,7 @@ export function propagateElementNode(update, mutation, nodeKey, options) {
                     // because SyncLexicalToLoro sorts element mutations by depth.
                     // But as a safety net, log a warning.
                     if (parent && !parentId) {
-                        console.warn(`⚠️ ElementNodePropagator: parent mapping missing for ${elementType} nodeKey=${nodeKey}, parentKey=${parent.getKey()}`);
+                        console.warn(` ElementNodePropagator: parent mapping missing for ${elementType} nodeKey=${nodeKey}, parentKey=${parent.getKey()}`);
                     }
                     // Collect metadata (format, style, direction, etc.)
                     if (typeof currentNode.getFormat === 'function') {
@@ -288,6 +332,8 @@ export function propagateElementNode(update, mutation, nodeKey, options) {
             if (currentNode && $isElementNode(currentNode)) {
                 // Use editorState.read() to safely access node methods
                 let parent, parentId, index;
+                let previousSiblingId;
+                let nextSiblingId;
                 let elementType;
                 const metadata = {};
                 // Export node data and collect metadata within editor context
@@ -299,6 +345,27 @@ export function propagateElementNode(update, mutation, nodeKey, options) {
                     const mapper = getNodeMapper();
                     parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
                     index = currentNode.getIndexWithinParent();
+                    // Resolve nearest mapped sibling anchors to stabilize target index
+                    // when Lexical index includes siblings not yet represented in Loro.
+                    if (parent) {
+                        const siblings = parent.getChildren();
+                        for (let i = index - 1; i >= 0; i--) {
+                            const candidate = siblings[i];
+                            const candidateTreeId = mapper.getTreeIDByLexicalKey(candidate.getKey());
+                            if (candidateTreeId && tree.has(candidateTreeId)) {
+                                previousSiblingId = candidateTreeId;
+                                break;
+                            }
+                        }
+                        for (let i = index + 1; i < siblings.length; i++) {
+                            const candidate = siblings[i];
+                            const candidateTreeId = mapper.getTreeIDByLexicalKey(candidate.getKey());
+                            if (candidateTreeId && tree.has(candidateTreeId)) {
+                                nextSiblingId = candidateTreeId;
+                                break;
+                            }
+                        }
+                    }
                     // Get element type and metadata
                     elementType = currentNode.getType();
                     if (typeof currentNode.getFormat === 'function') {
@@ -314,7 +381,7 @@ export function propagateElementNode(update, mutation, nodeKey, options) {
                     lexicalNodeJSON = currentNode.exportJSON();
                 });
                 // Update the node in Loro after safely reading from editor state
-                updateElementNodeInLoro(nodeKey, elementType, parentId, index, metadata, lexicalNodeJSON, options);
+                updateElementNodeInLoro(nodeKey, elementType, parentId, index, previousSiblingId, nextSiblingId, metadata, lexicalNodeJSON, options);
             }
             break;
         }

package/lib/collab/loro/propagators/LineBreakNodePropagator.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 { $createLineBreakNode, $isLineBreakNode } from 'lexical';

package/lib/collab/loro/propagators/RootNodePropagator.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 { $getRoot } from 'lexical';

package/lib/collab/loro/propagators/TextNodePropagator.js

@@ -1,21 +1,21 @@
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { $createTextNode, $isTextNode } from 'lexical';
 import { getNodeMapper } from '../nodes/NodesMapper';
 import { $diffTextContentAndApplyDelta } from '../utils/Utils';
+import { invariant } from '../utils/Invariant';
 /**
  * Create TextNode in Loro tree
  */
 export function createTextNodeInLoro(nodeKey, textContent, format, mode, parentId, index, lexicalNodeJSON, // JSON object from exportJSON()
 options) {
     const mapper = getNodeMapper();
-    // Debug logging for text node creation issues
-    if (!parentId) {
-        console.warn(`❌ Creating TextNode ${nodeKey} without parent in Loro tree - THIS WILL FAIL`);
-        return null; // Return early to avoid creating orphaned nodes
-    }
+    // A text node is always a leaf with a parent element. A missing parent means
+    // the parent element was not synced first — surface it instead of creating an
+    // orphaned (unrenderable) node.
+    invariant(parentId !== undefined, 'createTextNodeInLoro: text node has no parent in Loro tree', { nodeKey });
     // Use mapper to get or create the tree node
     // Note: We can't pass lexicalNode directly due to context issues, but parentId should be sufficient
     const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined, // don't pass lexicalNode to avoid context issues  
@@ -49,44 +49,30 @@ options) {
 export function updateTextNodeInLoro(nodeKey, newTextContent, format, mode, lexicalNodeJSON, // JSON object from exportJSON()
 options) {
     const mapper = getNodeMapper();
-    // Get the existing tree node using the mapper
-    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined);
+    // Updates must target an existing mapped node. Creating on update can
+    // accidentally create inline nodes at root when parent info is unavailable.
+    const treeID = mapper.getTreeIDByLexicalKey(nodeKey);
+    if (!treeID || !options?.tree.has(treeID)) {
+        return;
+    }
+    const treeNode = options.tree.getNodeByID(treeID);
     if (!treeNode) {
-        console.warn(`📝 TextNode ${nodeKey} not found in Loro, skipping update`);
         return;
     }
-    // Note: Container validation is done in each try-catch block below since
-    // the container can be deleted between operations
-    // Store complete lexical node data as clean JSON if provided
+    // Store complete lexical node data as clean JSON if provided.
     if (lexicalNodeJSON) {
-        try {
-            // Store complete lexical JSON without the key
-            if ('key' in lexicalNodeJSON || '__key' in lexicalNodeJSON || 'lexicalKey' in lexicalNodeJSON) {
-                const { key, __key, lexicalKey, children, ...cleanedData } = lexicalNodeJSON;
-                treeNode.data.set('lexical', cleanedData);
-            }
-            else {
-                const { children, ...cleanedData } = lexicalNodeJSON;
-                treeNode.data.set('lexical', cleanedData);
-            }
+        if ('key' in lexicalNodeJSON || '__key' in lexicalNodeJSON || 'lexicalKey' in lexicalNodeJSON) {
+            const { key, __key, lexicalKey, children, ...cleanedData } = lexicalNodeJSON;
+            treeNode.data.set('lexical', cleanedData);
         }
-        catch (error) {
-            // This is expected during text operations when nodes get deleted/recreated
-            console.warn(`📝 TextNode ${nodeKey} container was deleted during update, skipping (normal during text operations):`, error.message);
-            return;
+        else {
+            const { children, ...cleanedData } = lexicalNodeJSON;
+            treeNode.data.set('lexical', cleanedData);
         }
     }
-    // Update only essential metadata
-    try {
-        treeNode.data.set('elementType', 'text');
-        treeNode.data.set('updatedAt', Date.now());
-    }
-    catch (error) {
-        console.warn(`📝 TextNode ${nodeKey} container deleted during metadata update (normal during text operations):`, error.message);
-        return;
-    }
-    // The exported Lexical node data is already propagated by the mapper
-    // No additional JSON export needed since mapper propagates exportJSON automatically
+    // Update only essential metadata.
+    treeNode.data.set('elementType', 'text');
+    treeNode.data.set('updatedAt', Date.now());
 }
 /**
  * Delete TextNode from Loro tree
@@ -241,7 +227,7 @@ export function applyTextFormatInLoro(nodeKey, formatType, apply, options) {
         treeNode.data.get('format');
     }
     catch (error) {
-        console.warn(`📝 TextNode ${nodeKey} container deleted during format check (normal during text operations):`, error.message);
+        console.warn(` TextNode ${nodeKey} container deleted during format check (normal during text operations):`, error.message);
         return;
     }
     let currentFormat = treeNode.data.get('format') || 0;
@@ -259,7 +245,7 @@ export function applyTextFormatInLoro(nodeKey, formatType, apply, options) {
         treeNode.data.set('lastUpdated', Date.now());
     }
     catch (error) {
-        console.warn(`📝 TextNode ${nodeKey} container deleted during format update (normal during text operations):`, error.message);
+        console.warn(` TextNode ${nodeKey} container deleted during format update (normal during text operations):`, error.message);
         return;
     }
 }
@@ -289,7 +275,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                         }
                     }
                     catch (error) {
-                        console.warn(`📝 Failed to get parent for existing TreeID ${existingTreeID}:`, error);
+                        console.warn(` Failed to get parent for existing TreeID ${existingTreeID}:`, error);
                     }
                     return { currentParentId, expectedParentId };
                 });
@@ -306,7 +292,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                         }
                     }
                     catch (error) {
-                        console.warn(`📝 Could not get TreeNode for ${existingTreeID} during creation:`, error);
+                        console.warn(` Could not get TreeNode for ${existingTreeID} during creation:`, error);
                     }
                     // Clear the old mapping first to avoid conflicts
                     mapper.deleteMapping(nodeKey);
@@ -317,7 +303,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                         }
                     }
                     catch (error) {
-                        console.warn(`📝 Failed to delete TreeNode ${actualTreeID} during creation:`, error);
+                        console.warn(` Failed to delete TreeNode ${actualTreeID} during creation:`, error);
                     }
                 }
             }
@@ -366,7 +352,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                             }
                         }
                         catch (error) {
-                            console.warn(`📝 Failed to get parent for existing TreeID ${existingTreeID} during update:`, error);
+                            console.warn(` Failed to get parent for existing TreeID ${existingTreeID} during update:`, error);
                         }
                         return { currentParentId, expectedParentId, parent };
                     });
@@ -380,7 +366,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                             }
                         }
                         catch (error) {
-                            console.warn(`📝 Could not get TreeNode for ${existingTreeID}:`, error);
+                            console.warn(` Could not get TreeNode for ${existingTreeID}:`, error);
                         }
                         // Clear the old mapping first to avoid conflicts
                         mapper.deleteMapping(nodeKey);
@@ -391,7 +377,7 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                             }
                         }
                         catch (error) {
-                            console.warn(`📝 Failed to delete TreeNode ${actualTreeID} during update:`, error);
+                            console.warn(` Failed to delete TreeNode ${actualTreeID} during update:`, error);
                         }
                         // Now recreate the TextNode with the new parent (treat as "created")
                         const { parentId, index, textContent, format, mode, lexicalNodeJSON } = update.editorState.read(() => {
@@ -413,6 +399,30 @@ export function propagateTextNode(update, mutation, nodeKey, options) {
                         return; // Exit early since we recreated the node
                     }
                 }
+                // If a text node emits only an "updated" mutation before we have a
+                // mapping, treat it as a create so parent/index are explicit.
+                if (!existingTreeID) {
+                    const { parent, parentId, index, textContent, format, mode, lexicalNodeJSON } = update.editorState.read(() => {
+                        const parent = currentNode.getParent();
+                        const parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
+                        const index = currentNode.getIndexWithinParent();
+                        const textContent = currentNode.getTextContent();
+                        const format = currentNode.getFormat();
+                        const mode = currentNode.getMode();
+                        let lexicalNodeJSON = undefined;
+                        try {
+                            lexicalNodeJSON = currentNode.exportJSON();
+                        }
+                        catch (error) {
+                            console.warn('Failed to export node JSON in propagateTextNode updated(create fallback):', error);
+                        }
+                        return { parent, parentId, index, textContent, format, mode, lexicalNodeJSON };
+                    });
+                    if (parentId !== undefined) {
+                        createTextNodeInLoro(nodeKey, textContent, format, mode, parentId, index, lexicalNodeJSON, options);
+                    }
+                    return;
+                }
                 // Normal update case - parent hasn't changed
                 const { textContent, format, mode, lexicalNodeJSON } = update.editorState.read(() => {
                     const textContent = currentNode.getTextContent();

package/lib/collab/loro/propagators/index.d.ts

@@ -6,7 +6,7 @@
  */
 import { ElementNode, NodeKey } from 'lexical';
 import { Binding } from '../Bindings';
-import { LoroTree } from 'loro-crdt/bundler/loro_wasm';
+import type { LoroTree } from 'loro-crdt';
 export * from './RootNodePropagator';
 export * from './LineBreakNodePropagator';
 export * from './ElementNodePropagator';

package/lib/collab/loro/propagators/index.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.
  */
 // Root Node Propagator

package/lib/collab/loro/provider/websocket.d.ts

@@ -60,6 +60,7 @@ export declare class WebsocketProvider extends ObservableV2<any> {
     _exitIntegrator: any;
     _bcSubscriber: any;
     _lastExportedVersion: VersionVector;
+    _pendingUpdates: Uint8Array[];
     /**
      * @param {string} wsServerUrl
      * @param {string} docId

package/lib/collab/loro/provider/websocket.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 { EphemeralStore } from 'loro-crdt';
@@ -28,7 +28,7 @@ class AwarenessAdapter {
         this.ephemeralStore = ephemeralStore;
         // Use the same client ID as the binding for consistency
         this.localClientId = doc ? generateClientID(doc) : generateRandomClientID();
-        console.log('🔄 AwarenessAdapter created:', {
+        console.log(' AwarenessAdapter created:', {
             localClientId: this.localClientId,
             docPeerId: doc ? doc.peerId : 'no-doc',
             existingStatesCount: Object.keys(ephemeralStore.getAllStates()).length
@@ -256,6 +256,7 @@ messageHandlers[messageUpdate] = (provider, message, emitSynced) => {
         // The key point is that it's NOT our local peerId
         const importStatus = provider.doc.import(updateBytes);
         const afterVersion = provider.doc.version();
+        console.log('[SEED-DEBUG] messageUpdate: imported', updateBytes.length, 'bytes; importStatus=', JSON.stringify(importStatus));
         // Update our last exported version to include the remote changes
         // This ensures we don't re-export remote changes
         provider._lastExportedVersion = afterVersion;
@@ -265,7 +266,7 @@ messageHandlers[messageUpdate] = (provider, message, emitSynced) => {
         return null; // No response needed
     }
     catch (error) {
-        console.warn(`❌ [LORO-UPDATE-ERROR] Failed to apply Loro update:`, error);
+        console.warn(` [LORO-UPDATE-ERROR] Failed to apply Loro update:`, error);
         return null;
     }
 };
@@ -432,7 +433,7 @@ const setupWS = (provider) => {
             provider.emit('status', [{
                     status: 'connected'
                 }]);
-            console.log('✅ WebSocket connection established, requesting initial data');
+            console.log(' WebSocket connection established, requesting initial data');
             // Since we're in onopen, we know the WebSocket is ready
             // Use sendMessage directly to avoid any race conditions
             // Only request snapshot if we haven't already loaded it
@@ -445,12 +446,12 @@ const setupWS = (provider) => {
                     docId: provider.docId,
                     clientId: clientId
                 };
-                console.log(`🔄 Requesting initial snapshot from server (ID: ${requestId}, clientId: ${clientId}):`, snapshotRequest);
-                console.log(`🔄 Provider instance ID: ${provider.wsServerUrl}/${provider.docId}, snapshotLoaded: ${provider.snapshotLoaded}`);
+                console.log(` Requesting initial snapshot from server (ID: ${requestId}, clientId: ${clientId}):`, snapshotRequest);
+                console.log(` Provider instance ID: ${provider.wsServerUrl}/${provider.docId}, snapshotLoaded: ${provider.snapshotLoaded}`);
                 sendMessage(ws, snapshotRequest);
             }
             else {
-                console.log('📸 Snapshot already loaded, skipping request');
+                console.log(' Snapshot already loaded, skipping request');
             }
             // Then request initial ephemeral state from server  
             const clientId = generateClientID(provider.doc).toString();
@@ -482,6 +483,22 @@ const setupWS = (provider) => {
                     });
                 }
             }
+            // Flush any local document updates that were buffered while the socket
+            // was not ready to send (e.g. the initial-content bootstrap ran before
+            // the connection opened). Without this, seeded content committed before
+            // the socket opened would never reach the server or other collaborators.
+            if (provider._pendingUpdates.length > 0) {
+                const pending = provider._pendingUpdates;
+                provider._pendingUpdates = [];
+                console.log('[SEED-DEBUG] ws.onopen: flushing', pending.length, 'buffered local updates');
+                for (const pendingUpdate of pending) {
+                    sendMessage(ws, {
+                        type: 'update',
+                        update: Array.from(pendingUpdate),
+                        docId: provider.docId
+                    });
+                }
+            }
         };
         provider.emit('status', [{
                 status: 'connecting'
@@ -497,13 +514,13 @@ const broadcastMessage = (provider, message) => {
         sendMessage(ws, message);
     }
     else {
-        console.log('❌ [BROADCAST] WebSocket not ready for sending');
+        console.log(' [BROADCAST] WebSocket not ready for sending');
     }
     if (provider.bcconnected) {
         bc.publish(provider.bcChannel, JSON.stringify(message), provider);
     }
     else {
-        console.log('📻 [BROADCAST] BroadcastChannel not connected');
+        console.log(' [BROADCAST] BroadcastChannel not connected');
     }
 };
 /**
@@ -541,6 +558,7 @@ export class WebsocketProvider extends ObservableV2 {
     _exitIntegrator = null;
     _bcSubscriber = null;
     _lastExportedVersion = null; // Track last exported version for incremental updates
+    _pendingUpdates = []; // Local updates buffered while the socket is not ready to send
     /**
      * @param {string} wsServerUrl
      * @param {string} docId
@@ -587,7 +605,7 @@ export class WebsocketProvider extends ObservableV2 {
                     console.log('🆕 Created new global EphemeralStore');
                 }
                 else {
-                    console.log('♻️ Reusing existing global EphemeralStore - cleaning up stale user states');
+                    console.log(' Reusing existing global EphemeralStore - cleaning up stale user states');
                     // Clean up all existing user states when reusing store to prevent accumulation
                     const allStates = WebsocketProvider.globalEphemeralStore.getAllStates();
                     Object.keys(allStates).forEach(key => {
@@ -595,7 +613,7 @@ export class WebsocketProvider extends ObservableV2 {
                         const clientId = parseInt(key, 10);
                         if (!isNaN(clientId)) {
                             WebsocketProvider.globalEphemeralStore.delete(key);
-                            console.log('🧹 Cleaned up stale user state:', key);
+                            console.log(' Cleaned up stale user state:', key);
                         }
                     });
                 }
@@ -673,7 +691,24 @@ export class WebsocketProvider extends ObservableV2 {
                 update: Array.from(update),
                 docId: this.docId
             };
-            broadcastMessage(this, updateMessage);
+            const ws = this.ws;
+            if (this.wsconnected && ws && ws.readyState === ws.OPEN) {
+                console.log('[SEED-DEBUG] _updateHandler: sending local update over WS', update.length, 'bytes');
+                sendMessage(ws, updateMessage);
+            }
+            else {
+                // The socket is not ready yet — this happens when the initial-content
+                // bootstrap commits before the connection opens. Loro delivers each
+                // local update to subscribeLocalUpdates exactly once, so dropping it
+                // here would lose the seeded content permanently (remote peers would
+                // never receive it). Buffer it and flush on open instead.
+                console.log('[SEED-DEBUG] _updateHandler: WS not ready, buffering local update', update.length, 'bytes (pending now', this._pendingUpdates.length + 1, ')');
+                this._pendingUpdates.push(update);
+            }
+            // Mirror to other same-origin tabs when the BroadcastChannel is available.
+            if (this.bcconnected) {
+                bc.publish(this.bcChannel, JSON.stringify(updateMessage), this);
+            }
         };
         // Document update integrater - called when Loro emits document change events
         /**

package/lib/collab/loro/servers/index.js

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

package/lib/collab/loro/servers/ws/callback.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 http from 'http';

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*
- * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the MIT License.
  */
 import { WebSocketServer } from 'ws';