@datalayer/lexical-loro 1.0.2 → 1.0.5

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

@@ -0,0 +1,450 @@
+/*
+ * 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();
+    // 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  
+    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();
+    // 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) {
+        return;
+    }
+    // Store complete lexical node data as clean JSON if provided.
+    if (lexicalNodeJSON) {
+        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);
+        }
+    }
+    // Update only essential metadata.
+    treeNode.data.set('elementType', 'text');
+    treeNode.data.set('updatedAt', Date.now());
+}
+/**
+ * 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
+                    }
+                }
+                // 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();
+                    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;
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Lexical Node Propagator for Loro Tree Collaboration
+ *
+ * This module exports mutator functions for all Lexical node types
+ * to enable bidirectional synchronization with Loro Tree Loro.
+ */
+import { ElementNode, NodeKey } from 'lexical';
+import { Binding } from '../Bindings';
+import type { LoroTree } from 'loro-crdt';
+export * from './RootNodePropagator';
+export * from './LineBreakNodePropagator';
+export * from './ElementNodePropagator';
+export * from './TextNodePropagator';
+export * from './DecoratorNodePropagator';
+export { propagateRootNode } from './RootNodePropagator';
+export { propagateLineBreakNode } from './LineBreakNodePropagator';
+export { propagateElementNode } from './ElementNodePropagator';
+export { propagateTextNode } from './TextNodePropagator';
+export { propagateDecoratorNode } from './DecoratorNodePropagator';
+/**
+ * Type definitions for mutator options
+ */
+export interface BasePropagatorOptions {
+    binding: Binding;
+    tree: LoroTree;
+    peerId: number;
+}
+/**
+ * Unified mutator interface for all node types
+ */
+export interface NodePropagator<T = any> {
+    create: (nodeKey: NodeKey, ...args: any[]) => string;
+    update: (nodeKey: NodeKey, ...args: any[]) => void;
+    delete: (nodeKey: NodeKey, options: BasePropagatorOptions) => void;
+    createFromLoro: (treeId: string, parentNode: ElementNode, index?: number, options?: BasePropagatorOptions) => T | null;
+    updateFromLoro: (treeId: string, lexicalNode: T, newParentNode?: ElementNode, newIndex?: number, options?: BasePropagatorOptions) => void;
+    deleteFromLoro: (treeId: string, lexicalNode: T, options?: BasePropagatorOptions) => void;
+}
+/**
+ * Node type constants for identifying different Lexical node types in Loro tree
+ */
+export declare const NODE_TYPES: {
+    readonly ROOT: "root";
+    readonly ELEMENT: "element";
+    readonly TEXT: "text";
+    readonly LINEBREAK: "linebreak";
+    readonly DECORATOR: "decorator";
+};
+export type NodeType = typeof NODE_TYPES[keyof typeof NODE_TYPES];

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the MIT License.
+ */
+// Root Node Propagator
+export * from './RootNodePropagator';
+// Line Break Node Propagator  
+export * from './LineBreakNodePropagator';
+// Element Node Propagator
+export * from './ElementNodePropagator';
+// Text Node Propagator
+export * from './TextNodePropagator';
+// Decorator Node Propagator
+export * from './DecoratorNodePropagator';
+// Main mutator functions for delegation
+export { propagateRootNode } from './RootNodePropagator';
+export { propagateLineBreakNode } from './LineBreakNodePropagator';
+export { propagateElementNode } from './ElementNodePropagator';
+export { propagateTextNode } from './TextNodePropagator';
+export { propagateDecoratorNode } from './DecoratorNodePropagator';
+/**
+ * Node type constants for identifying different Lexical node types in Loro tree
+ */
+export const NODE_TYPES = {
+    ROOT: 'root',
+    ELEMENT: 'element',
+    TEXT: 'text',
+    LINEBREAK: 'linebreak',
+    DECORATOR: 'decorator',
+};

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

@@ -0,0 +1,117 @@
+import { LoroDoc, EphemeralStore, VersionVector } from 'loro-crdt';
+import { ObservableV2 } from 'lib0/observable';
+export declare const messageUpdate = "update";
+export declare const messageQuerySnapshot = "query-snapshot";
+export declare const messageEphemeral = "ephemeral";
+export declare const messageQueryEphemeral = "query-ephemeral";
+export interface LoroUpdateMessage {
+    type: 'update';
+    update: number[];
+    docId: string;
+}
+export interface EphemeralMessage {
+    type: 'ephemeral';
+    ephemeral: number[];
+    docId: string;
+}
+export interface QueryEphemeralMessage {
+    type: 'query-ephemeral';
+    docId: string;
+    clientId?: string;
+}
+export interface QuerySnapshotMessage {
+    type: 'query-snapshot';
+    docId: string;
+    clientId?: string;
+}
+export type LoroWebSocketMessage = LoroUpdateMessage | EphemeralMessage | QueryEphemeralMessage | QuerySnapshotMessage;
+/**
+ * Websocket Provider for Loro. Creates a websocket connection to sync the shared document.
+ * The document name is attached to the provided url. I.e. the following example
+ * creates a websocket connection to http://localhost:1235/my-document-name
+ */
+export declare class WebsocketProvider extends ObservableV2<any> {
+    static globalEphemeralStore: EphemeralStore | null;
+    wsServerUrl: string;
+    docId: string;
+    doc: LoroDoc | null;
+    _WS: any;
+    protocols: any[];
+    params: {};
+    ephemeralStore: any;
+    awareness: any;
+    ws: any;
+    wsconnected: boolean;
+    wsconnecting: boolean;
+    bcconnected: boolean;
+    disableBc: boolean;
+    bcChannel: string;
+    maxBackoffTime: number;
+    wsUnsuccessfulReconnects: number;
+    messageHandlers: any[];
+    _synced: boolean;
+    wsLastMessageReceived: number;
+    shouldConnect: boolean;
+    snapshotLoaded: boolean;
+    _checkInterval: any;
+    _resyncInterval: any;
+    _updateHandler: any;
+    _ephemeralUpdateIntegrator: any;
+    _exitIntegrator: any;
+    _bcSubscriber: any;
+    _lastExportedVersion: VersionVector;
+    _pendingUpdates: Uint8Array[];
+    /**
+     * @param {string} wsServerUrl
+     * @param {string} docId
+     * @param {LoroDoc} doc
+     * @param {object} opts
+     * @param {boolean} [opts.connect]
+     * @param {EphemeralStore} [opts.ephemeralStore]
+     * @param {Object<string,string>} [opts.params] specify url parameters
+     * @param {Array<string>} [opts.protocols] specify websocket protocols
+     * @param {typeof WebSocket} [opts.WebSocketPolyfill] Optionally provide a WebSocket polyfill
+     * @param {number} [opts.resyncInterval] Request server state every `resyncInterval` milliseconds
+     * @param {number} [opts.maxBackoffTime] Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
+     * @param {boolean} [opts.disableBc] Disable cross-tab BroadcastChannel communication
+     */
+    constructor(wsServerUrl: string, docId: string, doc: LoroDoc, { connect, ephemeralStore, params, protocols, WebSocketPolyfill, resyncInterval, maxBackoffTime, disableBc }?: {
+        connect?: boolean;
+        ephemeralStore?: any;
+        params?: {};
+        protocols?: any[];
+        WebSocketPolyfill?: {
+            new (url: string | URL, protocols?: string | string[]): WebSocket;
+            prototype: WebSocket;
+            readonly CONNECTING: 0;
+            readonly OPEN: 1;
+            readonly CLOSING: 2;
+            readonly CLOSED: 3;
+        };
+        resyncInterval?: number;
+        maxBackoffTime?: number;
+        disableBc?: boolean;
+    });
+    get url(): string;
+    /**
+     * @type {boolean}
+     */
+    get synced(): boolean;
+    set synced(state: boolean);
+    destroy(): void;
+    connectBc(): void;
+    disconnectBc(): void;
+    disconnect(): void;
+    connect(): void;
+    /**
+     * Manually send a Loro document update to connected peers
+     * Call this method after making changes to the LoroDoc
+     * @param {Uint8Array} update The update bytes from LoroDoc
+     */
+    sendUpdate(update: Uint8Array): void;
+    /**
+     * Force cleanup of stale ephemeral states (for debugging)
+     * Removes user states that haven't been active for more than 5 minutes
+     */
+    cleanupStaleStates(): void;
+}