@datalayer/lexical-loro 0.1.0 → 0.2.1

package/lib/collab/loro/servers/ws/callback.d.ts

@@ -1,5 +0,0 @@
-export declare const isCallbackSet: boolean;
-/**
- * @param {import('./utils.ts').WSSharedDoc} doc
- */
-export declare const callbackIntegrator: (doc: any) => void;

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

@@ -1,85 +0,0 @@
-import http from 'http';
-import * as number from 'lib0/number';
-const CALLBACK_URL = process.env.CALLBACK_URL ? new URL(process.env.CALLBACK_URL) : null;
-const CALLBACK_TIMEOUT = number.parseInt(process.env.CALLBACK_TIMEOUT || '5000');
-const CALLBACK_OBJECTS = process.env.CALLBACK_OBJECTS ? JSON.parse(process.env.CALLBACK_OBJECTS) : {};
-export const isCallbackSet = !!CALLBACK_URL;
-/**
- * @param {import('./utils.ts').WSSharedDoc} doc
- */
-export const callbackIntegrator = (doc) => {
-    const room = doc.name;
-    const dataToSend = {
-        room,
-        data: {}
-    };
-    const sharedObjectList = Object.keys(CALLBACK_OBJECTS);
-    sharedObjectList.forEach(sharedObjectName => {
-        const sharedObjectType = CALLBACK_OBJECTS[sharedObjectName];
-        const content = getContent(sharedObjectName, sharedObjectType, doc);
-        dataToSend.data[sharedObjectName] = {
-            type: sharedObjectType,
-            content: content && typeof content.toJSON === 'function' ? content.toJSON() : content
-        };
-    });
-};
-/**
- * @param {URL} url
- * @param {number} timeout
- * @param {Object} data
- */
-const callbackRequest = (url, timeout, data) => {
-    data = JSON.stringify(data);
-    const options = {
-        hostname: url.hostname,
-        port: url.port,
-        path: url.pathname,
-        timeout,
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Content-Length': Buffer.byteLength(data)
-        }
-    };
-    const req = http.request(options);
-    req.on('timeout', () => {
-        console.warn('Callback request timed out.');
-        req.abort();
-    });
-    req.on('error', (e) => {
-        console.warn('Callback request error.', e);
-        req.abort();
-    });
-    req.write(data);
-    req.end();
-};
-/**
- * @param {string} objName
- * @param {string} objType
- * @param {import('./utils.ts').WSSharedDoc} doc
- */
-const getContent = (objName, objType, doc) => {
-    // Loro uses a different API than YJS
-    // Get the container by name and type
-    try {
-        switch (objType) {
-            case 'List':
-            case 'Array':
-                return doc.doc.getList(objName);
-            case 'Map':
-                return doc.doc.getMap(objName);
-            case 'Text':
-                return doc.doc.getText(objName);
-            case 'Tree':
-                return doc.doc.getTree(objName);
-            default: {
-                // For unknown types, return the entire document state
-                return doc.doc.toJSON();
-            }
-        }
-    }
-    catch (error) {
-        console.warn(`Failed to get content for ${objName} of type ${objType}:`, error);
-        return {};
-    }
-};

package/lib/collab/loro/servers/ws/server.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

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

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-import { WebSocketServer } from 'ws';
-import http from 'http';
-import * as number from 'lib0/number';
-import { setupWSConnection } from './utils';
-const wss = new WebSocketServer({ noServer: true });
-const host = process.env.HOST || 'localhost';
-const port = number.parseInt(process.env.PORT || '1235');
-const server = http.createServer((_request, response) => {
-    response.writeHead(200, { 'Content-Type': 'text/plain' });
-    response.end('okay');
-});
-wss.on('connection', setupWSConnection);
-server.on('upgrade', (request, socket, head) => {
-    // You may check auth of request here..
-    // Call `wss.HandleUpgrade` *after* you checked whether the client has access
-    // (e.g. by checking cookies, or url parameters).
-    // See https://github.com/websockets/ws#client-authentication
-    wss.handleUpgrade(request, socket, head, /** @param {any} ws */ /** @param {any} ws */ ws => {
-        wss.emit('connection', ws, request);
-    });
-});
-server.listen(port, host, () => {
-    console.log(`running at '${host}' on port ${port}`);
-});

package/lib/collab/loro/servers/ws/utils.d.ts

@@ -1,40 +0,0 @@
-import { LoroDoc, EphemeralStore } from 'loro-crdt';
-/**
- *
- */
-export declare const setPersistence: (persistence_: any) => void;
-/**
- *
-*/
-export declare const getPersistence: () => any;
-/**
- *
- */
-export declare const docs: Map<string, WSSharedDoc>;
-/**
- * This function is called once every time a Loro document is created. You can
- * use it to pull data from an external source or initialize content.
- */
-export declare const setContentInitializor: (f: any) => void;
-/**
- * Gets a Doc by name, whether in memory or on disk
- */
-export declare const getDoc: (docname: any) => WSSharedDoc;
-/**
- * @param {import('ws').WebSocket} conn
- * @param {import('http').IncomingMessage} req
- * @param {any} opts
- */
-export declare const setupWSConnection: (conn: any, req: any, { docName }?: {
-    docName?: any;
-}) => void;
-export declare class WSSharedDoc {
-    name: string;
-    doc: LoroDoc;
-    connections: Map<any, Set<string>>;
-    ephemeralStore: EphemeralStore;
-    conns: Map<any, Set<any>>;
-    private _conns;
-    lastEphemeralSender: any;
-    constructor(name: any);
-}

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

@@ -1,513 +0,0 @@
-import { LoroDoc, EphemeralStore } from 'loro-crdt';
-import * as map from 'lib0/map';
-import * as eventloop from 'lib0/eventloop';
-import { messageEphemeral, messageQueryEphemeral, messageQuerySnapshot, messageUpdate, } from '../../provider/websocket';
-import { callbackIntegrator, isCallbackSet } from './callback';
-import { initializeLoroDocWithLexicalContent } from '../../utils/InitialContent';
-const pingTimeout = 30000;
-const CALLBACK_DEBOUNCE_WAIT = parseInt(process.env.CALLBACK_DEBOUNCE_WAIT || '2000');
-const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000');
-const debouncer = eventloop.createDebouncer(CALLBACK_DEBOUNCE_WAIT, CALLBACK_DEBOUNCE_MAXWAIT);
-const wsReadyStateConnecting = 0;
-const wsReadyStateOpen = 1;
-const wsReadyStateClosing = 2;
-const wsReadyStateClosed = 3;
-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:`);
-        // 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}`);
-                // Helper function to recursively log tree structure
-                const logTreeStructureRecursive = (node, prefix = '', isLast = true, depth = 0) => {
-                    const data = Object.fromEntries(node.data.entries());
-                    const treeId = node.id;
-                    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}`);
-                    const children = node.children();
-                    if (children && children.length > 0) {
-                        children.forEach((child, index) => {
-                            const isLastChild = index === children.length - 1;
-                            const childPrefix = prefix + (depth === 0 ? '' : (isLast ? '    ' : '│   '));
-                            logTreeStructureRecursive(child, childPrefix, isLastChild, depth + 1);
-                        });
-                    }
-                };
-                // Find and display all root nodes
-                const rootNodes = nodes.filter((node) => {
-                    const parent = node.parent();
-                    const data = Object.fromEntries(node.data.entries());
-                    return !parent || data.isRoot;
-                });
-                console.log(`[Server] Root nodes: ${rootNodes.length}`);
-                console.log('');
-                if (rootNodes.length === 0) {
-                    console.log('[Server] ⚠️  No root nodes found!');
-                }
-                else {
-                    rootNodes.forEach((root, index) => {
-                        const isLastRoot = index === rootNodes.length - 1;
-                        logTreeStructureRecursive(root, '', isLastRoot, 0);
-                    });
-                }
-            }
-            else {
-                console.log(`[Server] No tree container found`);
-            }
-        }
-        catch (treeError) {
-            console.log(`[Server] 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`);
-            const update = doc.export({ mode: 'update' });
-            console.log(`[Server] Update size: ${update.length} bytes`);
-        }
-        catch (exportError) {
-            console.log(`[Server] Error exporting:`, exportError.message);
-        }
-    }
-    catch (error) {
-        console.warn(`[Server] Error logging tree structure:`, error);
-    }
-};
-/**
- *
- */
-let persistence = null;
-if (typeof persistenceDir === 'string') {
-    console.log('Persistence directory configured: "' + persistenceDir + '" but Loro persistence not yet implemented');
-    // TODO: Implement actual Loro document persistence
-    // For now, disable persistence to keep documents in memory
-    console.log('Disabling persistence - documents will be kept in memory only');
-    persistence = null;
-    // Uncomment and implement when ready for actual persistence:
-    // persistence = {
-    //   provider: null, // Replace with Loro-compatible persistence provider
-    //   bindState: async (docName, doc: WSSharedDoc) => {
-    //     // TODO: Implement Loro document persistence loading
-    //     console.warn(`Loading state for document: ${docName}`)
-    //   },
-    //   writeState: async (docName, doc: WSSharedDoc) => {
-    //     // TODO: Implement Loro document state writing
-    //     console.warn(`Saving state for document: ${docName}`)
-    //   }
-    // }
-}
-/**
- *
- */
-export const setPersistence = persistence_ => {
-    persistence = persistence_;
-};
-/**
- *
-*/
-export const getPersistence = () => persistence;
-/**
- *
- */
-export const docs = new Map();
-/**
- * @type {(ydoc: Y.Doc) => Promise<void>}
- */
-let contentInitializor = _ydoc => Promise.resolve();
-/**
- * This function is called once every time a Loro document is created. You can
- * use it to pull data from an external source or initialize content.
- */
-export const setContentInitializor = (f) => {
-    contentInitializor = f;
-};
-/**
- * Gets a Doc by name, whether in memory or on disk
- */
-export const getDoc = (docname) => map.setIfUndefined(docs, docname, () => {
-    const doc = new WSSharedDoc(docname);
-    if (persistence !== null) {
-        persistence.bindState(docname, doc);
-    }
-    docs.set(docname, doc);
-    return doc;
-});
-/**
- *
- */
-const sendMessage = (doc, conn, message) => {
-    if (conn.readyState === wsReadyStateClosing || conn.readyState === wsReadyStateClosed) {
-        closeConn(doc, conn);
-    }
-    try {
-        //    console.log(`Sending message to ${conn.id || 'unknown'}`)
-        conn.send(JSON.stringify(message), {}, err => { if (err != null)
-            closeConn(doc, conn); });
-    }
-    catch (e) {
-        console.warn(e);
-        closeConn(doc, conn);
-    }
-};
-/**
- *
- */
-const sendMessageBinary = (doc, conn, message) => {
-    if (conn.readyState === wsReadyStateClosing || conn.readyState === wsReadyStateClosed) {
-        closeConn(doc, conn);
-    }
-    try {
-        //    console.log(`Sending message to ${conn.id || 'unknown'}`)
-        conn.send(message, {}, err => { if (err != null)
-            closeConn(doc, conn); });
-    }
-    catch (e) {
-        console.warn(e);
-        closeConn(doc, conn);
-    }
-};
-/**
- *
- */
-const messageListener = (conn, doc, message) => {
-    try {
-        let messageData = null;
-        let messageStr = '';
-        if (typeof message === 'string') {
-            messageStr = message;
-        }
-        else if (message instanceof ArrayBuffer) {
-            try {
-                const decoder = new TextDecoder();
-                messageStr = decoder.decode(message);
-            }
-            catch (decodeError) {
-                console.warn(`[Server] 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);
-                // Broadcast the update to other connections
-                doc.conns.forEach((_, c) => {
-                    if (c !== conn) {
-                        sendMessageBinary(doc, c, new Uint8Array(message));
-                    }
-                });
-                return;
-            }
-        }
-        else if (message instanceof Uint8Array) {
-            try {
-                const decoder = new TextDecoder();
-                messageStr = decoder.decode(message);
-            }
-            catch (decodeError) {
-                console.warn(`[Server] 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
-                doc.conns.forEach((_, c) => {
-                    if (c !== conn) {
-                        sendMessageBinary(doc, c, message);
-                    }
-                });
-                return;
-            }
-        }
-        else {
-            console.warn(`[Server] messageListener - Unknown message type:`, typeof message);
-            return;
-        }
-        if (!messageStr || messageStr.length === 0) {
-            return;
-        }
-        try {
-            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));
-            return;
-        }
-        console.log(`[Server] 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})`);
-                // 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})`);
-                    // 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`);
-                    // 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);
-                }
-                break;
-            case messageEphemeral:
-                try {
-                    const ephemeralBytes = new Uint8Array(messageData.ephemeral);
-                    // Mark this connection as the sender to avoid echo
-                    doc.lastEphemeralSender = conn;
-                    // Debug: Check ephemeral store state before and after
-                    const beforeStates = doc.ephemeralStore.getAllStates();
-                    const beforeKeys = Object.keys(beforeStates);
-                    doc.ephemeralStore.apply(ephemeralBytes);
-                    const afterStates = doc.ephemeralStore.getAllStates();
-                    const afterKeys = Object.keys(afterStates);
-                    console.log(`📡 SERVER DEBUG - Applied ephemeral update from ${conn.id}:`, {
-                        bytesLength: ephemeralBytes.length,
-                        beforeKeys,
-                        afterKeys,
-                        newKeys: afterKeys.filter(k => !beforeKeys.includes(k)),
-                        totalConnections: doc.conns.size
-                    });
-                }
-                catch (ephemeralError) {
-                    console.warn('messageEphemeral - ERROR applying ephemeral update');
-                    // Clear sender reference on error
-                    doc.lastEphemeralSender = null;
-                }
-                break;
-            case messageQueryEphemeral:
-                // Send current ephemeral state to requesting client       
-                try {
-                    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:`, {
-                        allKeysAvailable: allKeys,
-                        encodedLength: ephemeralUpdate.length,
-                        totalConnections: doc.conns.size
-                    });
-                    const ephemeralResponse = {
-                        type: 'ephemeral',
-                        ephemeral: Array.from(ephemeralUpdate),
-                        docId: doc.name
-                    };
-                    sendMessage(doc, conn, ephemeralResponse);
-                }
-                catch (error) {
-                    console.warn('[Server] messageQueryEphemeral - ERROR encoding/sending ephemeral state:', error);
-                }
-                break;
-            case messageUpdate:
-                // Apply the Loro update to the document.
-                const updateBytes = new Uint8Array(messageData.update);
-                const i = doc.doc.import(updateBytes);
-                // logTreeStructure(doc.doc, `After applying update from client ${conn.id || 'unknown'}`)
-                // Create properly formatted message for broadcasting
-                // Send the update to all other connections
-                let broadcastCount = 0;
-                doc.conns.forEach((_, c) => {
-                    if (c !== conn) {
-                        console.log(`Broadcasting Update to connection: ${c.id}`);
-                        sendMessage(doc, c, messageData);
-                        broadcastCount++;
-                    }
-                });
-                // Trigger callback if configured
-                if (isCallbackSet) {
-                    debouncer(() => callbackIntegrator(doc));
-                }
-                break;
-        }
-    }
-    catch (err) {
-        console.warn(err);
-        // Note: LoroDoc doesn't have emit method, using console.warn instead
-        console.warn('Message handling error:', err);
-    }
-};
-/**
- * @param {WSSharedDoc} doc
- * @param {any} conn
- */
-const closeConn = (doc, conn) => {
-    if (doc.conns.has(conn)) {
-        console.log(`Closing connection: ${conn.id || 'unknown'} for document: ${doc.name}`);
-        /**
-         * @type {Set<string>}
-         */
-        const controlledKeys = doc.conns.get(conn);
-        doc.conns.delete(conn);
-        // Remove ephemeral state controlled by this connection
-        if (controlledKeys) {
-            controlledKeys.forEach(key => {
-                doc.ephemeralStore.delete(key);
-            });
-        }
-        console.log(`Remaining connections for document ${doc.name}: ${doc.conns.size}`);
-        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`);
-                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`);
-                });
-                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`);
-                // logTreeStructure(doc.doc, `Document ${doc.name} structure before keeping in memory`)
-            }
-        }
-    }
-    conn.close();
-};
-/**
- * @param {import('ws').WebSocket} conn
- * @param {import('http').IncomingMessage} req
- * @param {any} opts
- */
-export const setupWSConnection = (conn, req, { docName = (req.url || '').slice(1).split('?')[0] } = {}) => {
-    conn.binaryType = 'arraybuffer';
-    // get doc, initialize if it does not exist yet
-    const doc = getDoc(docName);
-    // Assign a unique ID to the connection for logging
-    conn.id = `conn-${conn._socket?.remoteAddress || 'unknown'}:${conn._socket?.remotePort || Math.random()}`;
-    console.log(`New connection established: ${conn.id} for document: ${docName} (LoroDoc peerId: ${doc.doc.peerId})`);
-    doc.conns.set(conn, new Set());
-    // listen and reply to events
-    conn.on('message', message => messageListener(conn, doc, message));
-    // Check if connection is still alive
-    let pongReceived = true;
-    const pingInterval = setInterval(() => {
-        if (!pongReceived) {
-            if (doc.conns.has(conn)) {
-                closeConn(doc, conn);
-            }
-            clearInterval(pingInterval);
-        }
-        else if (doc.conns.has(conn)) {
-            pongReceived = false;
-            try {
-                conn.ping();
-            }
-            catch (e) {
-                closeConn(doc, conn);
-                clearInterval(pingInterval);
-            }
-        }
-    }, pingTimeout);
-    conn.on('close', () => {
-        closeConn(doc, conn);
-        clearInterval(pingInterval);
-    });
-    conn.on('pong', () => {
-        pongReceived = true;
-    });
-    // put the following in a variables in a block so the interval integrators don't keep in in
-    // scope
-    {
-        // Send initial snapshot to new client
-        // Log tree structure before creating initial snapshot
-        // 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`);
-            // 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`);
-            // 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);
-        }
-        // Send current ephemeral state if any
-        const ephemeralUpdate = doc.ephemeralStore.encodeAll();
-        if (ephemeralUpdate.length > 0) {
-            const ephemeralMessage = {
-                type: 'ephemeral',
-                ephemeral: Array.from(ephemeralUpdate),
-                docId: doc.name
-            };
-            sendMessage(doc, conn, ephemeralMessage);
-        }
-    }
-};
-export class WSSharedDoc {
-    name;
-    doc;
-    connections;
-    ephemeralStore;
-    conns;
-    _conns;
-    lastEphemeralSender;
-    constructor(name) {
-        this.name = name;
-        this.doc = new LoroDoc();
-        // Initialize the document with default Lexical content
-        console.log(`[Server] 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
-         * @type {Map<Object, Set<string>>}
-         */
-        this.connections = new Map();
-        this.conns = new Map();
-        this._conns = new Set();
-        /**
-         * @type {EphemeralStore}
-         */
-        this.ephemeralStore = new EphemeralStore(30000); // 30 second timeout
-        // Store the last sender to avoid echo loops
-        this.lastEphemeralSender = null;
-        /**
-         * @type {Array<function>}
-         */
-        const ephemeralChangeIntegrator = (event) => {
-            // Only broadcast if there are actual changes
-            if (event.added.length > 0 || event.updated.length > 0 || event.removed.length > 0) {
-                try {
-                    const encodedData = this.ephemeralStore.encodeAll();
-                    // Skip broadcast if no actual data to send
-                    if (encodedData.length === 0) {
-                        return;
-                    }
-                    const message = {
-                        type: 'ephemeral',
-                        ephemeral: Array.from(encodedData),
-                        docId: this.name
-                    };
-                    // Broadcast to all connections EXCEPT the one that sent the last ephemeral update
-                    this.conns.forEach((_, conn) => {
-                        if (conn !== this.lastEphemeralSender) {
-                            sendMessage(this, conn, message);
-                        }
-                    });
-                    // Clear the sender reference after broadcast
-                    this.lastEphemeralSender = null;
-                }
-                catch (broadcastError) {
-                    console.warn(`[Server] ephemeralChangeIntegrator - ERROR broadcasting:`, {
-                        error: broadcastError.message,
-                        stack: broadcastError.stack
-                    });
-                }
-            }
-        };
-        this.ephemeralStore.subscribe(ephemeralChangeIntegrator);
-        // Note: LoroDoc doesn't have 'on' method like Y.Doc
-        // Update handling will be done through message processing
-    }
-}