@datalayer/lexical-loro 0.2.3 → 0.2.5

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

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the MIT License.
+ */
+import { $getRoot } from 'lexical';
+import { getNodeMapper } from '../nodes/NodesMapper';
+/**
+ * Handle RootNode creation (typically only happens once during initialization)
+ */
+export function createRootNodeInLoro(nodeKey, lexicalNodeJSON, // JSON object from exportJSON()
+options) {
+    const { tree, peerId } = options;
+    const mapper = getNodeMapper();
+    // Use mapper to get or create the tree node (don't pass lexicalNode to avoid context issues)
+    // Root node has no parent (undefined) and is always at index 0
+    const rootTreeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined, // don't pass lexicalNode to avoid context issues
+    undefined, // no parent for root
+    0 // always at index 0
+    );
+    // Store complete lexical node data as clean JSON if provided
+    if (lexicalNodeJSON) {
+        try {
+            // Store complete lexical JSON without all key-related fields
+            if ('key' in lexicalNodeJSON || '__key' in lexicalNodeJSON || 'lexicalKey' in lexicalNodeJSON) {
+                const { key, __key, lexicalKey, children, ...cleanedData } = lexicalNodeJSON;
+                rootTreeNode.data.set('lexical', cleanedData);
+            }
+            else {
+                const { children, ...cleanedData } = lexicalNodeJSON;
+                rootTreeNode.data.set('lexical', cleanedData);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to store lexical node JSON for RootNode:', error);
+        }
+    }
+    // Store only essential metadata
+    rootTreeNode.data.set('elementType', 'root');
+    rootTreeNode.data.set('createdAt', Date.now());
+    // The exported Lexical node data is already propagated by the mapper
+    // Return the TreeID from the node's ID
+    return rootTreeNode.id;
+}
+/**
+ * Handle RootNode updates (rarely needed since root doesn't change much)
+ */
+export function updateRootNodeInLoro(nodeKey, 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)
+    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey, undefined);
+    // Store complete lexical node data as clean JSON if provided
+    if (lexicalNodeJSON) {
+        try {
+            // Store complete lexical JSON without all key-related fields
+            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);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to store lexical node JSON for RootNode update:', error);
+        }
+    }
+    // Update only essential metadata
+    treeNode.data.set('elementType', 'root');
+    treeNode.data.set('lastUpdated', Date.now());
+}
+/**
+ * Handle RootNode deletion (should rarely happen, but included for completeness)
+ */
+export function deleteRootNodeInLoro(nodeKey, options) {
+    const mapper = getNodeMapper();
+    // Note: Deleting root node should be done with extreme caution
+    // as it represents the entire editor content
+    mapper.deleteMapping(nodeKey);
+}
+/**
+ * Create RootNode in Lexical from Loro tree data
+ */
+export function createRootNodeFromLoro(treeId, options) {
+    // In Lexical, there's always exactly one root node
+    // This function would typically be called during initialization
+    const root = $getRoot();
+    // Root node already exists, just return it
+    return root;
+}
+/**
+ * Update RootNode in Lexical from Loro tree data
+ */
+export function updateRootNodeFromLoro(treeId, options) {
+    // Root node updates are typically propagated at the document level
+    // Most changes to root would be indirect (children changes)
+    console.log('Root node update from Loro:', treeId);
+}
+/**
+ * Delete RootNode in Lexical (should not happen in normal operation)
+ */
+export function deleteRootNodeFromLoro(treeId, options) {
+    // Root node deletion should not happen in normal circumstances
+    // This would essentially clear the entire editor
+    console.warn('Attempting to delete root node - this should not happen:', treeId);
+}
+/**
+ * Utility to check if a tree node represents a RootNode
+ */
+export function isRootNodeInTree(treeId, tree) {
+    if (!tree.has(treeId)) {
+        return false;
+    }
+    const treeNode = tree.getNodeByID(treeId);
+    return treeNode?.data.get('nodeType') === 'root';
+}
+/**
+ * Main propagate method for RootNode - propagates all mutation types
+ */
+export function propagateRootNode(update, mutation, nodeKey, options) {
+    const { tree, peerId } = options;
+    switch (mutation) {
+        case 'created': {
+            // Get the current editor state to find the root node
+            const currentNode = update.editorState._nodeMap.get(nodeKey);
+            if (currentNode) {
+                // Export node data as JSON object within editor context where node methods are available
+                let lexicalNodeJSON = undefined;
+                update.editorState.read(() => {
+                    if (currentNode.getType() === 'root') {
+                        try {
+                            lexicalNodeJSON = currentNode.exportJSON();
+                        }
+                        catch (error) {
+                            console.warn('Failed to export root node JSON:', error);
+                        }
+                    }
+                });
+                if (lexicalNodeJSON) {
+                    createRootNodeInLoro(nodeKey, lexicalNodeJSON, options);
+                }
+            }
+            break;
+        }
+        case 'updated': {
+            // Root nodes typically don't change much, but we can update metadata
+            const currentNode = update.editorState._nodeMap.get(nodeKey);
+            if (currentNode) {
+                // Export node data as JSON object within editor context where node methods are available
+                let lexicalNodeJSON = undefined;
+                update.editorState.read(() => {
+                    if (currentNode.getType() === 'root') {
+                        try {
+                            lexicalNodeJSON = currentNode.exportJSON();
+                        }
+                        catch (error) {
+                            console.warn('Failed to export root node JSON for update:', error);
+                        }
+                    }
+                });
+                if (lexicalNodeJSON) {
+                    updateRootNodeInLoro(nodeKey, lexicalNodeJSON, options);
+                }
+            }
+            break;
+        }
+        case 'destroyed': {
+            // Delete the root node from Loro tree
+            deleteRootNodeInLoro(nodeKey, options);
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+import { TreeID, LoroTree } from 'loro-crdt';
+import { TextNode, TextFormatType, UpdateListenerPayload, NodeKey, ElementNode } from 'lexical';
+import { Binding } from '../Bindings';
+/**
+ * TextNode Propagator for Loro Tree Collaboration
+ *
+ * TextNode characteristics:
+ * - Leaf nodes that represent text content
+ * - Can have formatting (bold, italic, underline, strikethrough, etc.)
+ * - Can have different modes: normal, token, segmented, inert
+ * - Cannot have children (always leaf nodes)
+ * - Support text content and format operations
+ */
+export interface TextNodeMutatorOptions {
+    binding: Binding;
+    tree: LoroTree;
+    peerId: number;
+}
+/**
+ * Create TextNode in Loro tree
+ */
+export declare function createTextNodeInLoro(nodeKey: NodeKey, textContent: string, format?: number, mode?: string, parentId?: TreeID, index?: number, lexicalNodeJSON?: any, // JSON object from exportJSON()
+options?: TextNodeMutatorOptions): TreeID;
+/**
+ * Update TextNode in Loro tree
+ */
+export declare function updateTextNodeInLoro(nodeKey: NodeKey, newTextContent?: string, format?: number, mode?: string, lexicalNodeJSON?: any, // JSON object from exportJSON()
+options?: TextNodeMutatorOptions): void;
+/**
+ * Delete TextNode from Loro tree
+ */
+export declare function deleteTextNodeInLoro(nodeKey: NodeKey, options: TextNodeMutatorOptions): void;
+/**
+ * Create TextNode in Lexical from Loro tree data
+ */
+export declare function createTextNodeFromLoro(treeId: TreeID, parentNode: ElementNode, index?: number, options?: TextNodeMutatorOptions): TextNode | null;
+/**
+ * Update TextNode in Lexical from Loro tree data
+ */
+export declare function updateTextNodeFromLoro(treeId: TreeID, textNode: TextNode, newParentNode?: ElementNode, newIndex?: number, options?: TextNodeMutatorOptions): void;
+/**
+ * Delete TextNode from Lexical
+ */
+export declare function deleteTextNodeFromLoro(treeId: TreeID, lexicalNode: TextNode, options?: TextNodeMutatorOptions): void;
+/**
+ * Utility to check if a tree node represents a TextNode
+ */
+export declare function isTextNodeInTree(treeId: TreeID, tree: LoroTree): boolean;
+/**
+ * Get TextNode data from Loro tree
+ */
+export declare function getTextNodeDataFromTree(treeId: TreeID, tree: LoroTree): any;
+/**
+ * Apply text formatting operations (bold, italic, etc.)
+ */
+export declare function applyTextFormatInLoro(nodeKey: NodeKey, formatType: TextFormatType, apply: boolean, options: TextNodeMutatorOptions): void;
+/**
+ * Main propagate method for TextNode - propagates all mutation types
+ */
+export declare function propagateTextNode(update: UpdateListenerPayload, mutation: 'created' | 'updated' | 'destroyed', nodeKey: NodeKey, options: TextNodeMutatorOptions): void;

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

@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) 2023-2025 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';
+/**
+ * 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
+    }
+    // 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  
+    parentId, index);
+    // 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);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to store lexical node JSON for TextNode:', error);
+        }
+    }
+    // Store only essential metadata (elementType for debug panel)
+    treeNode.data.set('elementType', 'text');
+    treeNode.data.set('createdAt', Date.now());
+    // Return the TreeID from the node's ID
+    return treeNode.id;
+}
+/**
+ * Update TextNode in Loro tree
+ */
+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);
+    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
+    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);
+            }
+        }
+        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;
+        }
+    }
+    // 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
+}
+/**
+ * Delete TextNode from Loro tree
+ */
+export function deleteTextNodeInLoro(nodeKey, options) {
+    const mapper = getNodeMapper();
+    mapper.deleteMapping(nodeKey);
+}
+/**
+ * Create TextNode in Lexical from Loro tree data
+ */
+export function createTextNodeFromLoro(treeId, parentNode, index, options) {
+    const { tree } = options;
+    if (!tree.has(treeId)) {
+        return null;
+    }
+    const treeNode = tree.getNodeByID(treeId);
+    if (!treeNode) {
+        return null;
+    }
+    // Get LexicalNodeData (JSON object format only)
+    const lexicalData = treeNode.data.get('lexical');
+    let textNode;
+    if (lexicalData && typeof lexicalData === 'object') {
+        try {
+            // lexicalData is a direct JSON object, use it to create a TextNode
+            const lexicalDataObj = lexicalData;
+            const textContent = lexicalDataObj.text || lexicalDataObj.__text || '';
+            const format = lexicalDataObj.format || lexicalDataObj.__format || 0;
+            const mode = lexicalDataObj.mode || lexicalDataObj.__mode || 0;
+            textNode = $createTextNode(textContent);
+            textNode.setFormat(format);
+            textNode.setMode(mode);
+        }
+        catch (error) {
+            console.warn('Failed to create TextNode from JSON data for TreeID:', treeId, error);
+            return null;
+        }
+    }
+    else {
+        // No lexical JSON data found - cannot create TextNode
+        console.warn('No lexical JSON data found for TextNode TreeID:', treeId);
+        return null;
+    }
+    // Apply mode if present (only for old format)
+    if (!lexicalData || typeof lexicalData !== 'string') {
+        // const mode = treeNode.data.get('mode');
+        // if (mode && typeof textNode.setMode === 'function') {
+        //   textNode.setMode(mode);
+        // }
+    }
+    // Insert into the parent at the specified index
+    if (index !== undefined && index >= 0) {
+        parentNode.splice(index, 0, [textNode]);
+    }
+    else {
+        parentNode.append(textNode);
+    }
+    return textNode;
+}
+/**
+ * Update TextNode in Lexical from Loro tree data
+ */
+export function updateTextNodeFromLoro(treeId, textNode, newParentNode, newIndex, options) {
+    const { tree } = options;
+    if (!tree.has(treeId)) {
+        return;
+    }
+    const treeNode = tree.getNodeByID(treeId);
+    if (!treeNode || treeNode.data.get('nodeType') !== 'text') {
+        return;
+    }
+    // Update text content if it has changed
+    const textContent = treeNode.data.get('textContent');
+    if (textContent !== undefined && typeof textContent === 'string' &&
+        textNode.getTextContent() !== textContent) {
+        const currentText = textNode.getTextContent();
+        $diffTextContentAndApplyDelta(textNode, textNode.getKey(), currentText, textContent);
+    }
+    // Update format if it has changed
+    const format = treeNode.data.get('format');
+    if (format !== undefined && typeof format === 'number') {
+        textNode.setFormat(format);
+    }
+    // Update mode if it has changed (skip for now due to type complexity)
+    // const mode = treeNode.data.get('mode');
+    // if (mode !== undefined && typeof lexicalNode.setMode === 'function') {
+    //   lexicalNode.setMode(mode);
+    // }
+    // If parent or position changed, move the node
+    if (newParentNode && newIndex !== undefined) {
+        // Remove from current location
+        textNode.remove();
+        // Insert at new location
+        newParentNode.splice(newIndex, 0, [textNode]);
+    }
+}
+/**
+ * Delete TextNode from Lexical
+ */
+export function deleteTextNodeFromLoro(treeId, lexicalNode, options) {
+    if ($isTextNode(lexicalNode)) {
+        lexicalNode.remove();
+    }
+}
+/**
+ * Utility to check if a tree node represents a TextNode
+ */
+export function isTextNodeInTree(treeId, tree) {
+    if (!tree.has(treeId)) {
+        return false;
+    }
+    const treeNode = tree.getNodeByID(treeId);
+    return treeNode?.data.get('nodeType') === 'text';
+}
+/**
+ * Get TextNode data from Loro tree
+ */
+export function getTextNodeDataFromTree(treeId, tree) {
+    if (!tree.has(treeId)) {
+        return null;
+    }
+    const treeNode = tree.getNodeByID(treeId);
+    if (!treeNode || treeNode.data.get('nodeType') !== 'text') {
+        return null;
+    }
+    return {
+        nodeType: 'text',
+        textContent: treeNode.data.get('textContent'),
+        format: treeNode.data.get('format'),
+        mode: treeNode.data.get('mode'),
+        createdAt: treeNode.data.get('createdAt'),
+        lastUpdated: treeNode.data.get('lastUpdated'),
+    };
+}
+/**
+ * Apply text formatting operations (bold, italic, etc.)
+ */
+export function applyTextFormatInLoro(nodeKey, formatType, apply, options) {
+    const mapper = getNodeMapper();
+    // Get the existing Loro node from the mapper
+    const treeNode = mapper.getLoroNodeByLexicalKey(nodeKey);
+    if (!treeNode) {
+        return;
+    }
+    if (!treeNode || treeNode.data.get('nodeType') !== 'text') {
+        return;
+    }
+    // Check if the TreeNode's container is still valid
+    try {
+        // Try a simple read operation to verify the container is accessible
+        treeNode.data.get('format');
+    }
+    catch (error) {
+        console.warn(`📝 TextNode ${nodeKey} container deleted during format check (normal during text operations):`, error.message);
+        return;
+    }
+    let currentFormat = treeNode.data.get('format') || 0;
+    const formatNumber = formatType;
+    if (apply) {
+        // Add the format flag
+        currentFormat = currentFormat | formatNumber;
+    }
+    else {
+        // Remove the format flag
+        currentFormat = currentFormat & ~formatNumber;
+    }
+    try {
+        treeNode.data.set('format', currentFormat);
+        treeNode.data.set('lastUpdated', Date.now());
+    }
+    catch (error) {
+        console.warn(`📝 TextNode ${nodeKey} container deleted during format update (normal during text operations):`, error.message);
+        return;
+    }
+}
+/**
+ * Main propagate method for TextNode - propagates all mutation types
+ */
+export function propagateTextNode(update, mutation, nodeKey, options) {
+    const { tree, peerId } = options;
+    switch (mutation) {
+        case 'created': {
+            const currentNode = update.editorState._nodeMap.get(nodeKey);
+            // Check if this node already exists in Loro
+            const mapper = getNodeMapper();
+            const existingTreeID = mapper.getTreeIDByLexicalKey(nodeKey);
+            if (existingTreeID && currentNode && $isTextNode(currentNode)) {
+                // Check if the existing text node has the correct parent relationship
+                const { currentParentId, expectedParentId } = update.editorState.read(() => {
+                    const parent = currentNode.getParent();
+                    const expectedParentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
+                    // Get the current parent from Loro tree
+                    let currentParentId;
+                    try {
+                        const treeNode = tree.getNodeByID(existingTreeID);
+                        if (treeNode) {
+                            const parentNode = treeNode.parent();
+                            currentParentId = parentNode ? parentNode.id.toString() : undefined;
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`📝 Failed to get parent for existing TreeID ${existingTreeID}:`, error);
+                    }
+                    return { currentParentId, expectedParentId };
+                });
+                if (currentParentId === expectedParentId) {
+                    return; // Skip creation since the parent relationship is correct
+                }
+                else {
+                    // Get the actual TreeNode and its ID before deleting
+                    let actualTreeID = existingTreeID;
+                    try {
+                        const treeNode = tree.getNodeByID(existingTreeID);
+                        if (treeNode) {
+                            actualTreeID = treeNode.id;
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`📝 Could not get TreeNode for ${existingTreeID} during creation:`, error);
+                    }
+                    // Clear the old mapping first to avoid conflicts
+                    mapper.deleteMapping(nodeKey);
+                    // Then delete the TreeNode from Loro tree
+                    try {
+                        if (tree.has(actualTreeID)) {
+                            tree.delete(actualTreeID);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`📝 Failed to delete TreeNode ${actualTreeID} during creation:`, error);
+                    }
+                }
+            }
+            if (currentNode && $isTextNode(currentNode)) {
+                // Get parent, positioning, content, and serialized data using editor state context
+                const { parent, parentId, index, textContent, format, mode, lexicalNodeJSON } = update.editorState.read(() => {
+                    const parent = currentNode.getParent();
+                    // Get parentId from the mapper instead of constructing it manually
+                    const mapper = getNodeMapper();
+                    const parentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
+                    const index = currentNode.getIndexWithinParent();
+                    const textContent = currentNode.getTextContent();
+                    const format = currentNode.getFormat();
+                    const mode = currentNode.getMode();
+                    // Export node data as JSON object within editor context where node methods are available
+                    let lexicalNodeJSON = undefined;
+                    try {
+                        lexicalNodeJSON = currentNode.exportJSON();
+                    }
+                    catch (error) {
+                        console.warn('Failed to export node JSON in propagateTextNode created:', error);
+                    }
+                    return { parent, parentId, index, textContent, format, mode, lexicalNodeJSON };
+                });
+                createTextNodeInLoro(nodeKey, textContent, format, mode, parentId, index, lexicalNodeJSON, options);
+            }
+            break;
+        }
+        case 'updated': {
+            const currentNode = update.editorState._nodeMap.get(nodeKey);
+            if (currentNode && $isTextNode(currentNode)) {
+                // First, check if this TextNode's parent has changed (like during double Enter)
+                const mapper = getNodeMapper();
+                const existingTreeID = mapper.getTreeIDByLexicalKey(nodeKey);
+                if (existingTreeID) {
+                    const { currentParentId, expectedParentId, parent } = update.editorState.read(() => {
+                        const parent = currentNode.getParent();
+                        const expectedParentId = parent ? mapper.getTreeIDByLexicalKey(parent.getKey()) : undefined;
+                        // Get the current parent from Loro tree
+                        let currentParentId;
+                        try {
+                            const treeNode = tree.getNodeByID(existingTreeID);
+                            if (treeNode) {
+                                const parentNode = treeNode.parent();
+                                currentParentId = parentNode ? parentNode.id.toString() : undefined;
+                            }
+                        }
+                        catch (error) {
+                            console.warn(`📝 Failed to get parent for existing TreeID ${existingTreeID} during update:`, error);
+                        }
+                        return { currentParentId, expectedParentId, parent };
+                    });
+                    if (currentParentId !== expectedParentId) {
+                        // Get the actual TreeNode and its ID before deleting
+                        let actualTreeID = existingTreeID;
+                        try {
+                            const treeNode = tree.getNodeByID(existingTreeID);
+                            if (treeNode) {
+                                actualTreeID = treeNode.id;
+                            }
+                        }
+                        catch (error) {
+                            console.warn(`📝 Could not get TreeNode for ${existingTreeID}:`, error);
+                        }
+                        // Clear the old mapping first to avoid conflicts
+                        mapper.deleteMapping(nodeKey);
+                        // Then delete the TreeNode from Loro tree
+                        try {
+                            if (tree.has(actualTreeID)) {
+                                tree.delete(actualTreeID);
+                            }
+                        }
+                        catch (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(() => {
+                            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 during TextNode recreation:', error);
+                            }
+                            return { parentId, index, textContent, format, mode, lexicalNodeJSON };
+                        });
+                        createTextNodeInLoro(nodeKey, textContent, format, mode, parentId, index, lexicalNodeJSON, options);
+                        return; // Exit early since we recreated the node
+                    }
+                }
+                // Normal update case - parent hasn't changed
+                const { textContent, format, mode, lexicalNodeJSON } = update.editorState.read(() => {
+                    const textContent = currentNode.getTextContent();
+                    const format = currentNode.getFormat();
+                    const mode = currentNode.getMode();
+                    // Export node data as JSON object within editor context where node methods are available
+                    let lexicalNodeJSON = undefined;
+                    try {
+                        lexicalNodeJSON = currentNode.exportJSON();
+                    }
+                    catch (error) {
+                        console.warn('Failed to export node JSON in propagateTextNode updated:', error);
+                    }
+                    return { textContent, format, mode, lexicalNodeJSON };
+                });
+                updateTextNodeInLoro(nodeKey, textContent, format, mode, lexicalNodeJSON, options);
+            }
+            break;
+        }
+        case 'destroyed': {
+            deleteTextNodeInLoro(nodeKey, options);
+            break;
+        }
+    }
+}