libre-webui 0.21.3 → 0.22.1

package/backend/dist/websocketServer.js

@@ -29,12 +29,15 @@ import { ChatRequestService } from './services/chatRequestService.js';
 import { streamOllamaChatResponse } from './utils/ollamaStreaming.js';
 import { streamPluginResponse } from './utils/pluginStreaming.js';
 import { createLogger } from './utils/logger.js';
-import { sendAssistantChunk, sendAssistantComplete, sendConnected, sendError, sendToolStatus, sendUserMessage, streamAssistantFakeChunks, } from './utils/websocketMessages.js';
+import { sendAssistantChunk, sendAssistantCancelled, sendAssistantComplete, sendConnected, sendError, sendToolStatus, sendUserMessage, streamAssistantFakeChunks, } from './utils/websocketMessages.js';
 import { createWorkTerminalServer, WORK_TERMINAL_WS_PATH, } from './workTerminalServer.js';
 import { normalizeChatProviderSelection } from './utils/chatProviderSelection.js';
 import workPreviewProxyService from './services/workPreviewProxyService.js';
-import { authService } from './services/authService.js';
 import { userModel } from './models/userModel.js';
+import { WebSocketTicketCoordinationError, websocketTicketService, } from './services/websocketTicketService.js';
+import { ChatGenerationRegistry, UserChatGenerationRegistry, isChatGenerationCancelled, throwIfChatGenerationCancelled, } from './utils/chatCancellation.js';
+import { getPlatformRuntimeConfig } from './platform/coordination/service.js';
+import { acquireSharedCapacity, SharedCapacityExceededError, } from './platform/coordination/sharedAdmission.js';
 const chatRequestService = new ChatRequestService({
     chatGenerationService,
     personaService,
@@ -43,6 +46,9 @@ const chatRequestService = new ChatRequestService({
 const logger = createLogger('websocket');
 const CHAT_WS_MAX_PAYLOAD_BYTES = positiveInteger(process.env.CHAT_WS_MAX_PAYLOAD_BYTES, 10 * 1024 * 1024);
 const CHAT_WS_MAX_MESSAGES_PER_MINUTE = positiveInteger(process.env.CHAT_WS_MAX_MESSAGES_PER_MINUTE, 120);
+const CHAT_WS_MAX_ACTIVE_GENERATIONS_PER_USER = positiveInteger(process.env.CHAT_WS_MAX_ACTIVE_GENERATIONS_PER_USER, 4);
+const CHAT_WS_MAX_CONNECTIONS_PER_USER = positiveInteger(process.env.CHAT_WS_MAX_CONNECTIONS_PER_USER, 5);
+const activeGenerationsByUser = new UserChatGenerationRegistry(CHAT_WS_MAX_ACTIVE_GENERATIONS_PER_USER);
 function positiveInteger(value, fallback) {
     const parsed = Number.parseInt(value || '', 10);
     return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
@@ -71,32 +77,55 @@ export const isAllowedWebSocketOrigin = (origin, configuredOrigins = [process.en
     });
     return allowed.length === 0 || allowed.includes(requestOrigin);
 };
-const authorizeChatUpgrade = (request) => {
+const authorizeChatUpgrade = async (request) => {
     try {
         const url = new URL(request.url || '', `http://${request.headers.host}`);
-        const token = url.searchParams.get('token')?.trim() || '';
-        if (!token)
+        const ticket = url.searchParams.get('ticket')?.trim() || '';
+        if (!ticket)
             return null;
-        const payload = authService.verifyToken(token);
-        if (!payload)
+        const consumed = await websocketTicketService.consume(ticket, 'chat');
+        if (!consumed)
             return null;
-        const currentUser = userModel.getUserById(payload.userId);
+        const currentUser = await userModel.getUserById(consumed.userId);
         if (!currentUser || currentUser.status !== 'active')
             return null;
-        return { token, userId: currentUser.id };
+        return {
+            userId: currentUser.id,
+            sessionExpiresAt: consumed.sessionExpiresAt,
+        };
     }
-    catch {
+    catch (error) {
+        if (error instanceof WebSocketTicketCoordinationError)
+            throw error;
         return null;
     }
 };
 const rejectUpgrade = (socket, status, message) => {
     const body = JSON.stringify({ success: false, message });
-    socket.end(`HTTP/1.1 ${status} ${status === 401 ? 'Unauthorized' : 'Forbidden'}\r\n` +
+    const statusText = status === 401
+        ? 'Unauthorized'
+        : status === 403
+            ? 'Forbidden'
+            : status === 429
+                ? 'Too Many Requests'
+                : 'Service Unavailable';
+    socket.end(`HTTP/1.1 ${status} ${statusText}\r\n` +
         'Connection: close\r\n' +
         'Content-Type: application/json\r\n' +
         `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
 };
+const closeWebSocketServer = (server) => {
+    for (const client of server.clients)
+        client.terminate();
+    return new Promise(resolve => {
+        server.close(() => resolve());
+    });
+};
 export function registerWebSocketServer(server) {
+    let shuttingDown = false;
+    let closePromise;
+    const activeMessageHandlers = new Set();
+    const activeUpgradeAuthorizations = new Set();
     // WebSocket server for real-time chat streaming. Upgrades are dispatched by
     // path in index.ts so the Work terminal can share the same HTTP server.
     const wss = new WebSocketServer({
@@ -104,17 +133,39 @@ export function registerWebSocketServer(server) {
         maxPayload: CHAT_WS_MAX_PAYLOAD_BYTES,
     });
     wss.on('connection', (ws, rawRequest) => {
-        logger.debug('WebSocket client connected');
         const req = rawRequest;
+        if (shuttingDown) {
+            void req.chatAdmission?.release();
+            ws.terminate();
+            return;
+        }
+        logger.debug('WebSocket client connected');
         const chatAuth = req.chatAuth;
         if (!chatAuth) {
+            void req.chatAdmission?.release();
             ws.close(1008, 'Authentication required');
             return;
         }
-        const { userId } = chatAuth;
+        const { userId, sessionExpiresAt } = chatAuth;
+        const connectionSlot = req.chatAdmission;
+        if (!connectionSlot) {
+            ws.close(1013, 'Chat connection admission is unavailable');
+            return;
+        }
+        const onAdmissionLost = () => ws.close(1013, 'Chat connection admission was lost');
+        connectionSlot.signal.addEventListener('abort', onAdmissionLost, {
+            once: true,
+        });
+        if (connectionSlot.signal.aborted)
+            onAdmissionLost();
+        const activeGenerations = new ChatGenerationRegistry();
+        const sessionExpiryTimer = setTimeout(() => ws.close(1008, 'Session expired'), Math.max(0, Math.min(sessionExpiresAt - Date.now(), 2147483647)));
         let messageWindowStartedAt = Date.now();
         let messageCount = 0;
-        ws.on('message', async (data) => {
+        const handleMessage = async (data) => {
+            let currentGeneration;
+            let globallyReserved = false;
+            let generationSlot;
             try {
                 const now = Date.now();
                 if (now - messageWindowStartedAt >= 60000) {
@@ -126,19 +177,72 @@ export function registerWebSocketServer(server) {
                     ws.close(1008, 'Message rate limit exceeded');
                     return;
                 }
-                const currentPayload = authService.verifyToken(chatAuth.token);
-                const currentUser = currentPayload
-                    ? userModel.getUserById(currentPayload.userId)
-                    : null;
+                const currentUser = await userModel.getUserById(userId);
                 if (!currentUser ||
                     currentUser.status !== 'active' ||
-                    currentUser.id !== userId) {
+                    currentUser.id !== userId ||
+                    sessionExpiresAt <= Date.now()) {
                     ws.close(1008, 'Session expired or account unavailable');
                     return;
                 }
                 const message = JSON.parse(data.toString());
+                if (message.type === 'chat_cancel') {
+                    const assistantMessageId = message.data?.assistantMessageId;
+                    const sessionId = message.data?.sessionId;
+                    if (!activeGenerations.cancel(sessionId, assistantMessageId)) {
+                        sendAssistantCancelled(ws, {
+                            assistantMessageId,
+                            sessionId,
+                            cancelled: false,
+                        }, { ignoreClosedSocket: true });
+                    }
+                    return;
+                }
                 if (message.type === 'chat_stream') {
                     const { sessionId, content, images, format, options, assistantMessageId, regenerate, originalMessageId, isPrivate, model: privateModel, providerType, providerId, messageHistory, webSearch: webSearchRequested, } = message.data;
+                    if (!isPrivate && getPlatformRuntimeConfig().mode === 'team') {
+                        sendError(ws, {
+                            error: 'Persisted chat streams must use the durable generation and event endpoints in team mode.',
+                            code: 'DURABLE_CHAT_REQUIRED',
+                            sessionId,
+                        });
+                        return;
+                    }
+                    if (typeof assistantMessageId !== 'string' ||
+                        !assistantMessageId.trim()) {
+                        sendError(ws, { error: 'An assistant message ID is required.' });
+                        return;
+                    }
+                    if (typeof sessionId !== 'string' || !sessionId.trim()) {
+                        sendError(ws, { error: 'A session ID is required.' });
+                        return;
+                    }
+                    currentGeneration = activeGenerations.start(sessionId, assistantMessageId);
+                    activeGenerationsByUser.start(userId, currentGeneration);
+                    globallyReserved = true;
+                    try {
+                        generationSlot = await acquireSharedCapacity({
+                            limits: [
+                                {
+                                    scope: 'chat-generation.user',
+                                    subject: userId,
+                                    capacity: CHAT_WS_MAX_ACTIVE_GENERATIONS_PER_USER,
+                                },
+                            ],
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof SharedCapacityExceededError) {
+                            throw new Error(`This account already has ${CHAT_WS_MAX_ACTIVE_GENERATIONS_PER_USER} active chat generations.`);
+                        }
+                        throw error;
+                    }
+                    const generationController = currentGeneration.controller;
+                    generationSlot.signal.addEventListener('abort', () => generationController.abort(generationSlot?.signal.reason), { once: true });
+                    if (generationSlot.signal.aborted) {
+                        generationController.abort(generationSlot.signal.reason);
+                    }
+                    const generationSignal = currentGeneration.controller.signal;
                     const requestProviderSelection = isPrivate
                         ? normalizeChatProviderSelection({ providerType, providerId })
                         : undefined;
@@ -159,7 +263,7 @@ export function registerWebSocketServer(server) {
                     }
                     else {
                         // Get session with user authentication
-                        session = chatService.getSession(sessionId, userId);
+                        session = await chatService.getSession(sessionId, userId);
                         if (!session) {
                             logger.debug('Backend: Session not found:', sessionId, 'for user:', userId);
                             sendError(ws, {
@@ -172,10 +276,11 @@ export function registerWebSocketServer(server) {
                             return;
                         }
                     }
+                    throwIfChatGenerationCancelled(generationSignal);
                     // Add user message with images if provided (skip for regenerations and private sessions)
                     let userMessage;
                     if (!regenerate && !isPrivate) {
-                        userMessage = chatService.addMessage(sessionId, {
+                        userMessage = await chatService.addMessage(sessionId, {
                             role: 'user',
                             content,
                             images: images || undefined,
@@ -204,9 +309,10 @@ export function registerWebSocketServer(server) {
                     let documentContext = EMPTY_CHAT_DOCUMENT_CONTEXT(content);
                     if (!isPrivate) {
                         try {
-                            documentContext = await buildChatDocumentContext(content, sessionId, userId);
+                            documentContext = await buildChatDocumentContext(content, sessionId, userId, generationSignal);
                         }
                         catch (contextError) {
+                            throwIfChatGenerationCancelled(generationSignal);
                             logger.error('Error during document search:', contextError);
                         }
                     }
@@ -220,8 +326,8 @@ export function registerWebSocketServer(server) {
                     let searchEnhancedContent = documentContext.enhancedContent;
                     let searchHasRelevantContext = documentContext.hasRelevantContext;
                     if (webSearchRequested === true &&
-                        isWebSearchAvailable() &&
-                        userCanUseWebSearch(userModel.getUserById(userId))) {
+                        (await isWebSearchAvailable()) &&
+                        (await userCanUseWebSearch(currentUser))) {
                         const searchToolCallId = `web-search-${Date.now()}`;
                         sendToolStatus(ws, {
                             toolCallId: searchToolCallId,
@@ -229,7 +335,7 @@ export function registerWebSocketServer(server) {
                             phase: 'running',
                         });
                         try {
-                            const results = await runWebSearch(content);
+                            const results = await runWebSearch(content, undefined, generationSignal);
                             if (results.length > 0) {
                                 searchEnhancedContent = buildWebSearchEnhancedContent(searchEnhancedContent, results, content);
                                 searchHasRelevantContext = true;
@@ -245,6 +351,7 @@ export function registerWebSocketServer(server) {
                             });
                         }
                         catch (searchError) {
+                            throwIfChatGenerationCancelled(generationSignal);
                             logger.error('Web search failed; answering without it:', searchError);
                             sendToolStatus(ws, {
                                 toolCallId: searchToolCallId,
@@ -271,7 +378,7 @@ export function registerWebSocketServer(server) {
                     logger.debug('Backend: Using assistantMessageId:', assistantMessageId);
                     const persistedMessages = isPrivate
                         ? []
-                        : chatService.getMessagesForContext(sessionId);
+                        : await chatService.getMessagesForContext(sessionId, userId);
                     const preparedGeneration = await chatRequestService.prepareGenerationRequest({
                         session,
                         userId,
@@ -286,7 +393,9 @@ export function registerWebSocketServer(server) {
                         images: images || undefined,
                         hasRelevantContext: searchHasRelevantContext,
                         enhancedContent: searchEnhancedContent,
+                        signal: generationSignal,
                     });
+                    throwIfChatGenerationCancelled(generationSignal);
                     const generationTarget = preparedGeneration.target;
                     const { actualModelName, mergedOptions, activePlugin, ollamaMessages, pluginMessages, shouldStreamPlugin, } = preparedGeneration;
                     // Check if there's an active plugin for this model
@@ -308,9 +417,10 @@ export function registerWebSocketServer(server) {
                                 const streamResult = await streamPluginResponse({
                                     ws,
                                     chunks: agentProviderId
-                                        ? agentCliService.executeAgentStreamRequest(agentProviderId, pluginMessages, userId, { model: actualModelName })
-                                        : pluginService.executePluginStreamRequest(actualModelName, pluginMessages, mergedOptions, userId, activePlugin.id),
+                                        ? agentCliService.executeAgentStreamRequest(agentProviderId, pluginMessages, userId, { model: actualModelName, signal: generationSignal })
+                                        : pluginService.executePluginStreamRequest(actualModelName, pluginMessages, mergedOptions, userId, activePlugin.id, generationSignal),
                                     messageId: assistantMessageId,
+                                    signal: generationSignal,
                                 });
                                 assistantContent = streamResult.content;
                                 assistantThinking = streamResult.thinking || '';
@@ -323,6 +433,7 @@ export function registerWebSocketServer(server) {
                                     pluginMessages,
                                     userId,
                                     pluginFallbackPolicy: 'disabled',
+                                    signal: generationSignal,
                                 });
                                 assistantContent = generationResult.assistantContent;
                                 assistantThinking = generationResult.assistantThinking || '';
@@ -339,13 +450,14 @@ export function registerWebSocketServer(server) {
                                     });
                                 }
                                 if (assistantContent) {
-                                    await streamAssistantFakeChunks(ws, assistantContent, assistantMessageId);
+                                    await streamAssistantFakeChunks(ws, assistantContent, assistantMessageId, 100, generationSignal);
                                 }
                             }
+                            throwIfChatGenerationCancelled(generationSignal);
                             // Save the complete assistant message (skip for private sessions)
                             if ((assistantContent || assistantThinking) &&
                                 assistantMessageId) {
-                                const completion = assistantCompletionService.completeAssistantMessage({
+                                const completion = await assistantCompletionService.completeAssistantMessage({
                                     sessionId,
                                     session,
                                     content: assistantContent,
@@ -357,6 +469,7 @@ export function registerWebSocketServer(server) {
                                     regenerate,
                                     originalMessageId,
                                     providerMetadata: withContextSources(assistantProviderMetadata),
+                                    signal: generationSignal,
                                 });
                                 if (isPrivate) {
                                     // For private sessions, just send completion without saving
@@ -376,11 +489,12 @@ export function registerWebSocketServer(server) {
                             return; // Exit early since we handled the request via plugin
                         }
                         catch (pluginError) {
+                            throwIfChatGenerationCancelled(generationSignal);
                             const err = pluginError instanceof Error
                                 ? pluginError
                                 : new Error(String(pluginError));
                             const errWithResponse = pluginError;
-                            logger.error('Plugin failed, falling back to Ollama:', err.message);
+                            logger.error('Plugin request failed:', err.message);
                             if (errWithResponse &&
                                 typeof errWithResponse === 'object' &&
                                 'response' in errWithResponse) {
@@ -396,7 +510,7 @@ export function registerWebSocketServer(server) {
                             if (activePlugin || agentProviderId) {
                                 logger.error(`[WebSocket] ${agentProviderId
                                     ? `Agent CLI "${agentProviderId}"`
-                                    : `Plugin "${activePlugin?.name}"`} failed for model ${actualModelName}, not falling back to Ollama`);
+                                    : `Plugin "${activePlugin?.name}"`} failed for model ${actualModelName}`);
                                 sendError(ws, {
                                     error: agentProviderId
                                         ? `Agent request failed: ${err.message}`
@@ -428,15 +542,17 @@ export function registerWebSocketServer(server) {
                         streamSource: ollamaService,
                         messageId: assistantMessageId,
                         userId,
+                        signal: generationSignal,
                     });
                     assistantContent = ollamaStream.content;
                     assistantThinking = ollamaStream.thinking || '';
+                    throwIfChatGenerationCancelled(generationSignal);
                     if (!ollamaStream.completed) {
                         return;
                     }
                     // Save the complete assistant message with the provided ID (skip for private sessions)
                     if ((assistantContent || assistantThinking) && assistantMessageId) {
-                        const completion = assistantCompletionService.completeAssistantMessage({
+                        const completion = await assistantCompletionService.completeAssistantMessage({
                             sessionId,
                             session,
                             content: assistantContent,
@@ -449,6 +565,7 @@ export function registerWebSocketServer(server) {
                             originalMessageId,
                             statistics: ollamaStream.statistics,
                             providerMetadata: withContextSources(undefined),
+                            signal: generationSignal,
                         });
                         if (isPrivate) {
                             // For private sessions, just send completion without saving
@@ -495,12 +612,49 @@ export function registerWebSocketServer(server) {
                 }
             }
             catch (error) {
+                if (currentGeneration &&
+                    isChatGenerationCancelled(error, currentGeneration.controller.signal)) {
+                    sendAssistantCancelled(ws, {
+                        assistantMessageId: currentGeneration.assistantMessageId,
+                        sessionId: currentGeneration.sessionId,
+                        cancelled: true,
+                    }, { ignoreClosedSocket: true });
+                    return;
+                }
                 logger.error('WebSocket error:', error);
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 sendError(ws, { error: errorMessage });
             }
+            finally {
+                if (currentGeneration) {
+                    activeGenerations.finish(currentGeneration);
+                    if (globallyReserved) {
+                        activeGenerationsByUser.finish(userId, currentGeneration);
+                    }
+                }
+                await generationSlot?.release();
+            }
+        };
+        ws.on('message', data => {
+            if (shuttingDown)
+                return;
+            let trackedHandler;
+            trackedHandler = handleMessage(data)
+                .catch(error => {
+                // EventEmitter does not observe rejected async listeners. Contain a
+                // late send failure after shutdown while retaining the handler in
+                // the drain set until every provider and persistence operation has
+                // actually settled.
+                logger.error('WebSocket message handler failed:', error);
+            })
+                .finally(() => activeMessageHandlers.delete(trackedHandler));
+            activeMessageHandlers.add(trackedHandler);
         });
         ws.on('close', () => {
+            clearTimeout(sessionExpiryTimer);
+            connectionSlot.signal.removeEventListener('abort', onAdmissionLost);
+            void connectionSlot.release();
+            activeGenerations.cancelAll('The WebSocket closed before generation completed.');
             logger.debug('WebSocket client disconnected');
         });
         ws.on('error', error => {
@@ -510,7 +664,14 @@ export function registerWebSocketServer(server) {
         sendConnected(ws);
     });
     const terminalServer = createWorkTerminalServer();
-    server.on('upgrade', (request, socket, head) => {
+    const upgradedSockets = new Set();
+    const handleUpgrade = (request, socket, head) => {
+        if (shuttingDown) {
+            socket.destroy();
+            return;
+        }
+        upgradedSockets.add(socket);
+        socket.once('close', () => upgradedSockets.delete(socket));
         if (workPreviewProxyService.tryHandleUpgrade(request, socket, head)) {
             return;
         }
@@ -523,6 +684,10 @@ export function registerWebSocketServer(server) {
             return;
         }
         if (pathname === WORK_TERMINAL_WS_PATH) {
+            if (!isAllowedWebSocketOrigin(request.headers.origin)) {
+                rejectUpgrade(socket, 403, 'WebSocket origin is not allowed');
+                return;
+            }
             terminalServer.handleUpgrade(request, socket, head, ws => {
                 terminalServer.emit('connection', ws, request);
             });
@@ -534,18 +699,99 @@ export function registerWebSocketServer(server) {
                 return;
             }
             const authenticatedRequest = request;
-            const chatAuth = authorizeChatUpgrade(authenticatedRequest);
-            if (!chatAuth) {
-                rejectUpgrade(socket, 401, 'WebSocket authentication is required');
-                return;
-            }
-            authenticatedRequest.chatAuth = chatAuth;
-            wss.handleUpgrade(request, socket, head, ws => {
-                wss.emit('connection', ws, request);
-            });
+            socket.pause();
+            let authorization;
+            authorization = authorizeChatUpgrade(authenticatedRequest)
+                .then(async (chatAuth) => {
+                if (shuttingDown) {
+                    socket.destroy();
+                    return;
+                }
+                if (!chatAuth) {
+                    rejectUpgrade(socket, 401, 'WebSocket authentication is required');
+                    return;
+                }
+                let admission;
+                try {
+                    admission = await acquireSharedCapacity({
+                        limits: [
+                            {
+                                scope: 'chat-websocket.user',
+                                subject: chatAuth.userId,
+                                capacity: CHAT_WS_MAX_CONNECTIONS_PER_USER,
+                            },
+                        ],
+                    });
+                }
+                catch (error) {
+                    if (error instanceof SharedCapacityExceededError) {
+                        rejectUpgrade(socket, 429, 'Too many active Chat connections');
+                    }
+                    else {
+                        rejectUpgrade(socket, 503, 'Chat connection admission is temporarily unavailable');
+                    }
+                    return;
+                }
+                if (shuttingDown || socket.destroyed) {
+                    await admission.release();
+                    socket.destroy();
+                    return;
+                }
+                authenticatedRequest.chatAuth = chatAuth;
+                authenticatedRequest.chatAdmission = admission;
+                try {
+                    wss.handleUpgrade(request, socket, head, ws => {
+                        wss.emit('connection', ws, request);
+                    });
+                }
+                catch (error) {
+                    await admission.release();
+                    throw error;
+                }
+                socket.resume();
+            })
+                .catch(error => {
+                logger.error('WebSocket upgrade authorization failed:', error);
+                if (!shuttingDown) {
+                    if (error instanceof WebSocketTicketCoordinationError) {
+                        rejectUpgrade(socket, 503, 'WebSocket authentication is temporarily unavailable');
+                    }
+                    else {
+                        rejectUpgrade(socket, 401, 'WebSocket authentication is required');
+                    }
+                }
+            })
+                .finally(() => activeUpgradeAuthorizations.delete(authorization));
+            activeUpgradeAuthorizations.add(authorization);
             return;
         }
         socket.destroy();
-    });
+    };
+    server.on('upgrade', handleUpgrade);
+    return {
+        close: () => {
+            if (closePromise)
+                return closePromise;
+            shuttingDown = true;
+            closePromise = (async () => {
+                server.off('upgrade', handleUpgrade);
+                for (const socket of upgradedSockets)
+                    socket.destroy();
+                upgradedSockets.clear();
+                await Promise.allSettled([
+                    closeWebSocketServer(wss),
+                    closeWebSocketServer(terminalServer),
+                ]);
+                // Socket close aborts every active generation. Wait for their async
+                // handlers to honor that signal (or finish independently) before the
+                // caller closes SQLite and snapshots its WAL state.
+                await Promise.allSettled([
+                    ...activeUpgradeAuthorizations,
+                    ...activeMessageHandlers,
+                ]);
+            })();
+            return closePromise;
+        },
+    };
 }
 //# sourceMappingURL=websocketServer.js.map