@nocturnium/svelte-ide 1.0.2 → 1.0.4

package/dist/services/lsp-client.js

@@ -109,6 +109,7 @@ export class LSPClient {
     _capabilities = null;
     reconnectAttempts = 0;
     reconnectTimeout = null;
+    intentionalDisconnect = false;
     // Document tracking
     openDocuments = new Map();
     diagnosticsCache = new Map();
@@ -177,11 +178,24 @@ export class LSPClient {
         if (this._state !== 'disconnected' && this._state !== 'error') {
             return;
         }
+        this.intentionalDisconnect = false;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        this.cleanupSocket();
         this.setState('connecting');
         return new Promise((resolve, reject) => {
             try {
-                this.ws = new WebSocket(this.config.serverUrl);
-                this.ws.onopen = async () => {
+                const socket = new WebSocket(this.config.serverUrl);
+                this.ws = socket;
+                socket.onopen = async () => {
+                    if (socket !== this.ws)
+                        return;
+                    if (this.reconnectTimeout) {
+                        clearTimeout(this.reconnectTimeout);
+                        this.reconnectTimeout = null;
+                    }
                     this.reconnectAttempts = 0;
                     this.setState('connected');
                     try {
@@ -192,17 +206,21 @@ export class LSPClient {
                         reject(err);
                     }
                 };
-                this.ws.onclose = () => {
-                    this.handleDisconnect();
+                socket.onclose = () => {
+                    this.handleDisconnect(socket);
                 };
-                this.ws.onerror = (_event) => {
+                socket.onerror = (_event) => {
+                    if (socket !== this.ws)
+                        return;
                     const error = new Error('WebSocket error');
                     this.emitEvent('onError', error);
                     if (this._state === 'connecting') {
                         reject(error);
                     }
                 };
-                this.ws.onmessage = (event) => {
+                socket.onmessage = (event) => {
+                    if (socket !== this.ws)
+                        return;
                     this.handleMessage(event.data);
                 };
             }
@@ -212,7 +230,29 @@ export class LSPClient {
             }
         });
     }
-    handleDisconnect() {
+    cleanupSocket(socket = this.ws) {
+        if (!socket)
+            return;
+        socket.onopen = null;
+        socket.onclose = null;
+        socket.onerror = null;
+        socket.onmessage = null;
+        if (socket.readyState !== WebSocket.CLOSING) {
+            socket.close();
+        }
+        if (socket === this.ws) {
+            this.ws = null;
+        }
+    }
+    getReconnectDelay(attempt) {
+        const baseDelay = this.config.reconnectDelay ?? 1000;
+        const exponentialDelay = baseDelay * 2 ** (attempt - 1);
+        const jitter = 0.75 + Math.random() * 0.5;
+        return Math.round(exponentialDelay * jitter);
+    }
+    handleDisconnect(socket = this.ws) {
+        const wasIntentional = this.intentionalDisconnect;
+        this.cleanupSocket(socket);
         this.setState('disconnected');
         // Cancel pending requests
         for (const [_id, pending] of this.pendingRequests) {
@@ -220,11 +260,15 @@ export class LSPClient {
             pending.reject(new Error('Connection closed'));
         }
         this.pendingRequests.clear();
+        if (wasIntentional) {
+            this.intentionalDisconnect = false;
+            return;
+        }
         // Auto-reconnect
         if (this.config.autoReconnect &&
             this.reconnectAttempts < (this.config.maxReconnectAttempts ?? 5)) {
             this.reconnectAttempts++;
-            const delay = (this.config.reconnectDelay ?? 1000) * this.reconnectAttempts;
+            const delay = this.getReconnectDelay(this.reconnectAttempts);
             if (this.config.debug) {
                 console.log(`[LSP] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
             }
@@ -236,6 +280,7 @@ export class LSPClient {
         }
     }
     async disconnect() {
+        this.intentionalDisconnect = true;
         if (this.reconnectTimeout) {
             clearTimeout(this.reconnectTimeout);
             this.reconnectTimeout = null;
@@ -251,10 +296,10 @@ export class LSPClient {
                     // Ignore errors during shutdown
                 }
             }
-            this.ws.close();
-            this.ws = null;
+            this.cleanupSocket();
         }
         this.setState('disconnected');
+        this.intentionalDisconnect = false;
     }
     // ============================================================================
     // Initialize

package/dist/services/mock-ai.js

@@ -282,7 +282,7 @@ export function createMockMessage(role, content, options = {}) {
         ...options,
         metadata: role === 'assistant'
             ? {
-                model: 'claude-3-5-sonnet-mock',
+                model: 'nocturnium-demo-mock',
                 tokensUsed: Math.floor(content.length / 4),
                 latencyMs: Math.floor(500 + Math.random() * 1500),
                 ...options.metadata

package/dist/services/optimistic.d.ts

@@ -6,6 +6,7 @@
  */
 export interface OptimisticOperation<T> {
     id: string;
+    scopeKey?: string;
     type: string;
     payload: T;
     timestamp: number;
@@ -53,6 +54,7 @@ type CommitFn<T> = () => Promise<T>;
  * ```
  */
 export declare function optimisticUpdate<T, R>(options: {
+    scopeKey?: string;
     type: string;
     payload: T;
     apply: () => void;
@@ -84,6 +86,7 @@ export declare function createOptimisticState<T>(initialValue: T): {
  * Batch multiple optimistic operations
  */
 export declare function batchOptimisticUpdates(operations: Array<{
+    scopeKey?: string;
     type: string;
     payload: unknown;
     apply: () => void;
@@ -95,9 +98,9 @@ export declare function batchOptimisticUpdates(operations: Array<{
     failedCount: number;
 }>;
 /**
- * Get all pending operations
+ * Get pending operations, optionally limited to one document/workspace scope.
  */
-export declare function getPendingOperations(): OptimisticOperation<unknown>[];
+export declare function getPendingOperations(scopeKey?: string): OptimisticOperation<unknown>[];
 /**
  * Get operation by ID
  */
@@ -105,11 +108,11 @@ export declare function getOperation(id: string): OptimisticOperation<unknown> |
 /**
  * Cancel a pending operation
  */
-export declare function cancelOperation(id: string): Promise<boolean>;
+export declare function cancelOperation(id: string, scopeKey?: string): Promise<boolean>;
 /**
- * Cancel all pending operations
+ * Cancel pending operations, optionally limited to one document/workspace scope.
  */
-export declare function cancelAllOperations(): Promise<void>;
+export declare function cancelAllOperations(scopeKey?: string): Promise<void>;
 export interface ConflictInfo {
     type: 'version' | 'lock' | 'concurrent';
     localVersion?: number;

package/dist/services/optimistic.js

@@ -4,6 +4,7 @@
  * Provides utilities for optimistic UI updates with automatic rollback on failure.
  * Implements a queue-based system for managing pending operations.
  */
+const DEFAULT_SCOPE_KEY = '__global__';
 // ============================================================================
 // Operation Queue
 // ============================================================================
@@ -38,8 +39,10 @@ const rollbackFunctions = new Map();
 export async function optimisticUpdate(options) {
     const { type, payload, apply, rollback, commit, config = {} } = options;
     const { maxRetries = 3, retryDelay = 1000, onCommit, onRollback, onRetry } = config;
+    const scopeKey = options.scopeKey ?? getScopeKeyFromPayload(payload);
     const operation = {
         id: crypto.randomUUID(),
+        scopeKey,
         type,
         payload,
         timestamp: Date.now(),
@@ -85,7 +88,7 @@ export async function optimisticUpdate(options) {
             operation.retryCount++;
             if (operation.retryCount <= maxRetries) {
                 onRetry?.(operation, operation.retryCount);
-                await delay(retryDelay * operation.retryCount); // Exponential backoff
+                await delay(getRetryDelay(retryDelay, operation.retryCount));
             }
         }
     }
@@ -227,10 +230,10 @@ export async function batchOptimisticUpdates(operations, config) {
 // Queue Management
 // ============================================================================
 /**
- * Get all pending operations
+ * Get pending operations, optionally limited to one document/workspace scope.
  */
-export function getPendingOperations() {
-    return Array.from(operationQueue.values()).filter((op) => op.status === 'pending');
+export function getPendingOperations(scopeKey) {
+    return Array.from(operationQueue.values()).filter((op) => op.status === 'pending' && (!scopeKey || op.scopeKey === scopeKey));
 }
 /**
  * Get operation by ID
@@ -241,9 +244,11 @@ export function getOperation(id) {
 /**
  * Cancel a pending operation
  */
-export async function cancelOperation(id) {
+export async function cancelOperation(id, scopeKey) {
     const operation = operationQueue.get(id);
-    if (!operation || operation.status !== 'pending') {
+    if (!operation ||
+        operation.status !== 'pending' ||
+        (scopeKey && operation.scopeKey !== scopeKey)) {
         return false;
     }
     const rollback = rollbackFunctions.get(id);
@@ -262,12 +267,12 @@ export async function cancelOperation(id) {
     return true;
 }
 /**
- * Cancel all pending operations
+ * Cancel pending operations, optionally limited to one document/workspace scope.
  */
-export async function cancelAllOperations() {
-    const pending = getPendingOperations();
+export async function cancelAllOperations(scopeKey) {
+    const pending = getPendingOperations(scopeKey);
     for (const op of pending) {
-        await cancelOperation(op.id);
+        await cancelOperation(op.id, scopeKey);
     }
 }
 /**
@@ -319,6 +324,27 @@ export function parseConflictDetails(error) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function getScopeKeyFromPayload(payload) {
+    if (payload && typeof payload === 'object') {
+        const candidate = payload;
+        if (typeof candidate.scopeKey === 'string')
+            return candidate.scopeKey;
+        if (typeof candidate.workspaceId === 'string' && typeof candidate.path === 'string') {
+            return `${candidate.workspaceId}:${candidate.path}`;
+        }
+        if (typeof candidate.workspace === 'string' && typeof candidate.path === 'string') {
+            return `${candidate.workspace}:${candidate.path}`;
+        }
+        if (typeof candidate.path === 'string')
+            return candidate.path;
+    }
+    return DEFAULT_SCOPE_KEY;
+}
+function getRetryDelay(baseDelay, attempt) {
+    const exponentialDelay = baseDelay * 2 ** (attempt - 1);
+    const jitter = 0.75 + Math.random() * 0.5;
+    return Math.round(exponentialDelay * jitter);
+}
 /**
  * Create a debounced optimistic updater
  */

package/dist/services/vfs-client.js

@@ -55,7 +55,7 @@ async function request(path, options = {}) {
         if (err instanceof VFSError)
             throw err;
         if (err instanceof Error && err.name === 'AbortError') {
-            throw new VFSError('Request timeout', 'NETWORK_ERROR');
+            throw new VFSError('Request timeout', 'TIMEOUT');
         }
         throw new VFSError(err instanceof Error ? err.message : 'Unknown error', 'NETWORK_ERROR', err);
     }
@@ -65,14 +65,22 @@ async function request(path, options = {}) {
 }
 function mapStatusToErrorCode(status) {
     switch (status) {
-        case 404:
-            return 'FILE_NOT_FOUND';
+        case 401:
         case 403:
             return 'PERMISSION_DENIED';
+        case 404:
+            return 'FILE_NOT_FOUND';
         case 409:
             return 'VERSION_CONFLICT';
         case 423:
             return 'FILE_LOCKED';
+        case 429:
+            return 'RATE_LIMITED';
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            return 'SERVER_ERROR';
         default:
             return 'NETWORK_ERROR';
     }

package/dist/stores/agents.svelte.js

@@ -5,13 +5,14 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { SvelteMap } from 'svelte/reactivity';
 const state = $state({
-    agents: new Map(),
+    agents: new SvelteMap(),
     events: [],
     maxEvents: 200,
     activities: [],
     maxActivities: 500,
-    cursors: new Map(),
+    cursors: new SvelteMap(),
     selectedAgentId: null,
     filter: 'all',
     connected: false,

package/dist/stores/ai-persistence.svelte.js

@@ -3,6 +3,7 @@
  *
  * Handles saving and loading AI conversations to IndexedDB/localStorage
  */
+import { browser } from '$app/environment';
 const DEFAULT_CONFIG = {
     dbName: 'svelte-ide-ai',
     storeName: 'conversations',
@@ -31,7 +32,7 @@ export async function initPersistence(options) {
     config = { ...DEFAULT_CONFIG, ...options };
     try {
         // Check if IndexedDB is available
-        if (!('indexedDB' in globalThis)) {
+        if (!browser || !('indexedDB' in globalThis)) {
             console.warn('IndexedDB not available, using localStorage fallback');
             initialized = true;
             return true;
@@ -52,7 +53,7 @@ export async function initPersistence(options) {
  */
 function openDatabase() {
     return new Promise((resolve, reject) => {
-        const request = indexedDB.open(config.dbName, config.version);
+        const request = globalThis.indexedDB.open(config.dbName, config.version);
         request.onerror = () => reject(request.error);
         request.onsuccess = () => resolve(request.result);
         request.onupgradeneeded = (event) => {
@@ -318,6 +319,8 @@ export async function pruneOldConversations() {
 }
 // localStorage helpers
 function getLocalStorageConversations() {
+    if (typeof localStorage === 'undefined')
+        return [];
     try {
         const data = localStorage.getItem('ai-conversations');
         return data ? JSON.parse(data) : [];
@@ -327,6 +330,8 @@ function getLocalStorageConversations() {
     }
 }
 function setLocalStorageConversations(conversations) {
+    if (typeof localStorage === 'undefined')
+        return;
     try {
         localStorage.setItem('ai-conversations', JSON.stringify(conversations));
     }

package/dist/stores/ai.svelte.js

@@ -5,10 +5,11 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { SvelteMap } from 'svelte/reactivity';
 // Default configuration
 const defaultConfig = {
     endpoint: '/api/chat',
-    model: 'claude-3-5-sonnet',
+    model: 'nocturnium-demo-mock',
     systemPrompt: 'You are a helpful coding assistant integrated into an IDE.',
     tools: [],
     maxTokens: 4096,
@@ -19,7 +20,7 @@ const defaultConfig = {
 const state = $state({
     conversations: [],
     activeConversationId: null,
-    tools: new Map(),
+    tools: new SvelteMap(),
     config: { ...defaultConfig },
     editSessions: [],
     suggestions: [],

package/dist/stores/collaboration.svelte.d.ts

@@ -24,7 +24,7 @@ export declare const config: {
     readonly current: CollaborationConfig | null;
 };
 export declare const status: {
-    readonly current: "error" | "connected" | "disconnected" | "connecting";
+    readonly current: "error" | "disconnected" | "connecting" | "connected";
 };
 export declare const error: {
     readonly current: string | null;

package/dist/stores/collaboration.svelte.js

@@ -5,6 +5,7 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { SvelteMap } from 'svelte/reactivity';
 // Reactive state
 const state = $state({
     config: null,
@@ -12,8 +13,8 @@ const state = $state({
     error: null,
     synced: false,
     users: [],
-    cursors: new Map(),
-    awareness: new Map(),
+    cursors: new SvelteMap(),
+    awareness: new SvelteMap(),
     aiSessions: [],
     pendingChanges: [],
     snapshots: [],

package/dist/stores/editor.svelte.js

@@ -5,6 +5,7 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { SvelteMap } from 'svelte/reactivity';
 import { DEFAULT_EDITOR_PREFERENCES } from '../types';
 import { detectLanguage } from '../utils/language';
 // Reactive state using $state rune
@@ -17,6 +18,12 @@ const state = $state({
     loading: false,
     error: null
 });
+// Private saved-content baseline used to compute dirty state without changing
+// the exported EditorTab shape.
+const savedContents = new SvelteMap();
+function isTabDirty(tab) {
+    return tab.content !== (savedContents.get(tab.id) ?? tab.content);
+}
 // Getter functions for derived values (Svelte 5 module-safe)
 export function getTabs() {
     return state.tabs;
@@ -122,6 +129,7 @@ export function openFile(path, content, options) {
         isDirty: false,
         cursorPosition: { line: 1, column: 1 }
     };
+    savedContents.set(id, content);
     state.tabs = [...state.tabs, tab];
     if (options?.focus !== false) {
         state.activeTabId = id;
@@ -138,10 +146,11 @@ export function closeTab(tabId) {
     if (index === -1)
         return false;
     const tab = state.tabs[index];
-    if (tab.isDirty) {
+    if (isTabDirty(tab)) {
         // Could prompt for save here - returning false indicates unsaved changes
         return false;
     }
+    savedContents.delete(tabId);
     state.tabs = state.tabs.filter((t) => t.id !== tabId);
     // Update active tab if we closed the active one
     if (state.activeTabId === tabId) {
@@ -157,6 +166,7 @@ export function forceCloseTab(tabId) {
     const index = state.tabs.findIndex((t) => t.id === tabId);
     if (index === -1)
         return;
+    savedContents.delete(tabId);
     state.tabs = state.tabs.filter((t) => t.id !== tabId);
     if (state.activeTabId === tabId) {
         const newIndex = Math.min(index, state.tabs.length - 1);
@@ -167,9 +177,10 @@ export function forceCloseTab(tabId) {
  * Close all tabs
  */
 export function closeAllTabs(force = false) {
-    if (!force && state.tabs.some((t) => t.isDirty)) {
+    if (!force && state.tabs.some(isTabDirty)) {
         return false;
     }
+    savedContents.clear();
     state.tabs = [];
     state.activeTabId = null;
     return true;
@@ -178,9 +189,14 @@ export function closeAllTabs(force = false) {
  * Close other tabs (keep the specified one)
  */
 export function closeOtherTabs(keepTabId, force = false) {
-    if (!force && state.tabs.some((t) => t.id !== keepTabId && t.isDirty)) {
+    if (!force && state.tabs.some((t) => t.id !== keepTabId && isTabDirty(t))) {
         return false;
     }
+    for (const tab of state.tabs) {
+        if (tab.id !== keepTabId) {
+            savedContents.delete(tab.id);
+        }
+    }
     state.tabs = state.tabs.filter((t) => t.id === keepTabId);
     state.activeTabId = keepTabId;
     return true;
@@ -197,13 +213,21 @@ export function setActiveTab(tabId) {
  * Update content for a tab
  */
 export function updateContent(tabId, content) {
-    state.tabs = state.tabs.map((t) => t.id === tabId ? { ...t, content, isDirty: t.content !== content || t.isDirty } : t);
+    state.tabs = state.tabs.map((t) => t.id === tabId
+        ? { ...t, content, isDirty: content !== (savedContents.get(tabId) ?? t.content) }
+        : t);
 }
 /**
  * Mark a tab as saved
  */
 export function markSaved(tabId, newContent) {
-    state.tabs = state.tabs.map((t) => t.id === tabId ? { ...t, isDirty: false, content: newContent ?? t.content } : t);
+    state.tabs = state.tabs.map((t) => t.id === tabId
+        ? (() => {
+            const content = newContent ?? t.content;
+            savedContents.set(tabId, content);
+            return { ...t, isDirty: false, content };
+        })()
+        : t);
 }
 /**
  * Update cursor position for a tab

package/dist/stores/layout.svelte.js

@@ -5,6 +5,7 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { browser } from '$app/environment';
 // Default sizes
 const SIDEBAR_DEFAULT_WIDTH = 260;
 const SIDEBAR_MIN_WIDTH = 180;
@@ -219,6 +220,8 @@ export function toggleStatusBar() {
  */
 export function toggleFullScreen() {
     state.isFullScreen = !state.isFullScreen;
+    if (!browser || typeof document === 'undefined')
+        return;
     if (state.isFullScreen) {
         document.documentElement.requestFullscreen?.();
     }

package/dist/stores/plugin.svelte.js

@@ -10,12 +10,14 @@
  * Note: Svelte 5 modules cannot directly export $derived values.
  * We use getter functions to expose reactive derived state.
  */
+import { browser } from '$app/environment';
+import { SvelteMap } from 'svelte/reactivity';
 // Reactive state
 const state = $state({
     proposals: [],
-    instances: new Map(),
-    commands: new Map(),
-    panels: new Map(),
+    instances: new SvelteMap(),
+    commands: new SvelteMap(),
+    panels: new SvelteMap(),
     eventSource: null,
     connected: false,
     loadingProposals: false,
@@ -151,6 +153,10 @@ export function connect(endpoint = '/api/plugins/stream') {
     if (state.eventSource) {
         state.eventSource.close();
     }
+    if (!browser || typeof EventSource === 'undefined') {
+        state.connected = false;
+        return;
+    }
     const eventSource = new EventSource(endpoint);
     eventSource.onopen = () => {
         state.connected = true;

package/dist/stores/vfs.svelte.js

@@ -6,7 +6,8 @@
  * We use getter functions to expose reactive derived state.
  */
 import * as vfsClient from '../services/vfs-client';
-import { SvelteMap } from 'svelte/reactivity';
+import { browser } from '$app/environment';
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import { parseError, isConflictError, logError } from '../services/error-handling';
 import { optimisticUpdate } from '../services/optimistic';
 // Reactive state using $state rune
@@ -14,12 +15,12 @@ const state = $state({
     workspace: null,
     workspaceLoading: false,
     files: [],
-    fileMap: new Map(),
-    dirtyFiles: new Set(),
-    locks: new Map(),
-    lockStatuses: new Map(),
-    pendingLocks: new Set(),
-    activeTransactions: new Map(),
+    fileMap: new SvelteMap(),
+    dirtyFiles: new SvelteSet(),
+    locks: new SvelteMap(),
+    lockStatuses: new SvelteMap(),
+    pendingLocks: new SvelteSet(),
+    activeTransactions: new SvelteMap(),
     transactionHistory: [],
     eventSource: null,
     connected: false,
@@ -30,7 +31,7 @@ const state = $state({
     errorCode: null,
     structuredError: null,
     version: 0,
-    pendingRetries: new Map(),
+    pendingRetries: new SvelteMap(),
     conflictQueue: []
 });
 // Event handlers for SSE
@@ -39,6 +40,7 @@ const eventHandlers = new Map();
 // Lock TTL refresh intervals
 // eslint-disable-next-line svelte/prefer-svelte-reactivity -- non-reactive internal timer registry, not UI state
 const lockRefreshIntervals = new Map(); // path -> intervalId
+let reconnectTimer = null;
 // Current user ID (set during initialization)
 let currentUserId = null;
 // ============================================================================
@@ -496,6 +498,8 @@ export function setLocks(locks) {
     }
 }
 function startLockRefresh(lock) {
+    if (!browser || typeof window === 'undefined')
+        return;
     // Refresh at 80% of TTL to ensure we don't lose the lock
     const refreshInterval = lock.ttl * 0.8;
     const intervalId = window.setInterval(async () => {
@@ -581,9 +585,17 @@ export function completeTransaction(transactionId, status) {
 const BASE_RECONNECT_DELAY = 1000;
 const MAX_RECONNECT_ATTEMPTS = 10;
 export function connect(workspaceId) {
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
     if (state.eventSource) {
         state.eventSource.close();
     }
+    if (!browser || typeof EventSource === 'undefined') {
+        state.connected = false;
+        return;
+    }
     const endpoint = `/api/vfs/workspaces/${workspaceId}/stream`;
     const eventSource = new EventSource(endpoint);
     eventSource.onopen = () => {
@@ -597,7 +609,8 @@ export function connect(workspaceId) {
         if (state.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
             const delay = BASE_RECONNECT_DELAY * Math.pow(2, state.reconnectAttempts);
             state.reconnectAttempts++;
-            setTimeout(() => {
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
                 if (!state.connected) {
                     connect(workspaceId);
                 }
@@ -619,6 +632,10 @@ export function connect(workspaceId) {
     state.eventSource = eventSource;
 }
 export function disconnect() {
+    if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
     if (state.eventSource) {
         state.eventSource.close();
         state.eventSource = null;