perf(context): lazy initialization for ExtensionsContext and LSPContext

Optimize startup performance by deferring expensive initialization work
in both context providers until it is actually needed.

ExtensionsContext.tsx:
- Move get_extensions_directory invoke into the existing requestIdleCallback
  deferred block instead of eagerly calling it in a separate onMount
- Batch setExtensions/setEnabledExtensions updates with SolidJS batch()
  to prevent double renders during extension loading
- Add initialized signal to track when deferred loading completes
- Expose initialized accessor on ExtensionsContextValue interface

LSPContext.tsx:
- Extract diagnostics event listener setup from onMount into an idempotent
  lazyInit() function guarded by a listenersInitialized flag
- Call lazyInit() from startServer() so listeners are registered on first
  file open (triggered via useLSPEditor hook)
- Keep requestIdleCallback fallback in onMount so listeners eventually
  register even without file opens
- Add initialized field to LSPState store
- Expose lazyInit method on LSPContextValue interface
- Normalize line endings from CRLF to LF

Author: echobt

src/context/ExtensionsContext.tsx

@@ -244,6 +244,7 @@ export interface ExtensionsContextValue {
   loading: Accessor<boolean>;
   error: Accessor<string | null>;
   extensionsDir: Accessor<string>;
+  initialized: Accessor<boolean>;
 
   // Update State
   outdatedExtensions: Accessor<Map<string, ExtensionUpdateInfo>>;
@@ -418,6 +419,7 @@ export function ExtensionsProvider(props: ParentProps) {
   const [loading, setLoading] = createSignal(false);
   const [error, setError] = createSignal<string | null>(null);
   const [extensionsDir, setExtensionsDir] = createSignal("");
+  const [initialized, setInitialized] = createSignal(false);
 
   // Update state using store for reactive nested updates
   const [updateState, setUpdateState] = createStore<ExtensionUpdateState>({
@@ -488,25 +490,17 @@ export function ExtensionsProvider(props: ParentProps) {
     stopWorkerHost();
   });
 
-  // Load extensions directory path on mount
-  onMount(async () => {
-    try {
-      const dir = await invoke<string>("get_extensions_directory");
-      setExtensionsDir(dir);
-    } catch (e) {
-      console.error("Failed to get extensions directory:", e);
-    }
-  });
-
   // Load all extensions
   const loadExtensions = async () => {
     setLoading(true);
     setError(null);
     try {
       const loaded = await invoke<Extension[]>("load_extensions");
-      setExtensions(loaded);
-      const enabled = loaded.filter((ext) => ext.enabled);
-      setEnabledExtensions(enabled);
+      batch(() => {
+        setExtensions(loaded);
+        const enabled = loaded.filter((ext) => ext.enabled);
+        setEnabledExtensions(enabled);
+      });
       // Also refresh themes when extensions are loaded
       await refreshThemes();
     } catch (e) {
@@ -1502,7 +1496,16 @@ export function ExtensionsProvider(props: ParentProps) {
     // Use requestIdleCallback to defer extension loading until browser is idle
     // This prevents blocking the main thread during startup
     const loadExtensionsDeferred = async () => {
+      // Load extensions directory path (deferred from mount for startup perf)
+      try {
+        const dir = await invoke<string>("get_extensions_directory");
+        setExtensionsDir(dir);
+      } catch (e) {
+        console.error("Failed to get extensions directory:", e);
+      }
+
       await loadExtensions();
+      setInitialized(true);
 
       // Setup event listener for update-related events
       try {
@@ -1566,6 +1569,7 @@ export function ExtensionsProvider(props: ParentProps) {
     loading,
     error,
     extensionsDir,
+    initialized,
 
     // Update state
     outdatedExtensions,

src/context/LSPContext.tsx

@@ -565,10 +565,13 @@ interface LSPState {
   languageStatus: Record<string, LanguageStatusItem[]>;
   loading: boolean;
   error: string | null;
+  initialized: boolean;
 }
 
 interface LSPContextValue {
   state: LSPState;
+  // Lazy initialization - call when first file is opened
+  lazyInit: () => void;
   // Server management
   startServer: (config: LanguageServerConfig) => Promise<ServerInfo>;
   stopServer: (serverId: string) => Promise<void>;
@@ -699,21 +702,19 @@ export function LSPProvider(props: ParentProps) {
     languageStatus: {},
     loading: false,
     error: null,
+    initialized: false,
   });
 
   let unlistenDiagnostics: UnlistenFn | undefined;
+  let listenersInitialized = false;
 
-  // Register cleanup synchronously
-  onCleanup(() => {
-    unlistenDiagnostics?.();
-    // Stop all servers on cleanup
-    stopAllServers().catch(console.error);
-  });
+  // Lazy initialization - sets up event listeners on first file open
+  // Idempotent: safe to call multiple times
+  const lazyInit = () => {
+    if (listenersInitialized) return;
+    listenersInitialized = true;
 
-  onMount(() => {
-    // DEFERRED - Set up LSP diagnostics listener after first paint
-    // LSP diagnostics won't fire until a language server is started and files are opened
-    const initDeferredListeners = async () => {
+    const initListeners = async () => {
       // Listen for diagnostics events from the backend
       unlistenDiagnostics = await listen<{
         server_id: string;
@@ -731,7 +732,7 @@ export function LSPProvider(props: ParentProps) {
         }>;
       }>("lsp:diagnostics", (event) => {
         const { uri, diagnostics } = event.payload;
-        
+
         const mapped: Diagnostic[] = diagnostics.map((d) => ({
           range: d.range,
           severity: mapSeverity(d.severity),
@@ -746,13 +747,26 @@ export function LSPProvider(props: ParentProps) {
 
         setState("diagnostics", uri, { uri, diagnostics: mapped });
       });
+
+      setState("initialized", true);
     };
 
-    // Use requestIdleCallback if available, otherwise setTimeout
+    initListeners().catch(console.error);
+  };
+
+  // Register cleanup synchronously
+  onCleanup(() => {
+    unlistenDiagnostics?.();
+    // Stop all servers on cleanup
+    stopAllServers().catch(console.error);
+  });
+
+  // Deferred fallback: set up listeners during idle time even if no file is opened
+  onMount(() => {
     if ('requestIdleCallback' in window) {
-      (window as Window & { requestIdleCallback: (cb: () => void, opts?: { timeout: number }) => number }).requestIdleCallback(initDeferredListeners, { timeout: 2000 });
+      (window as Window & { requestIdleCallback: (cb: () => void, opts?: { timeout: number }) => number }).requestIdleCallback(() => lazyInit(), { timeout: 2000 });
     } else {
-      setTimeout(initDeferredListeners, 100);
+      setTimeout(() => lazyInit(), 100);
     }
   });
 
@@ -767,6 +781,8 @@ export function LSPProvider(props: ParentProps) {
   };
 
   const startServer = async (config: LanguageServerConfig): Promise<ServerInfo> => {
+    // Ensure event listeners are set up before starting any server
+    lazyInit();
     setState("loading", true);
     setState("error", null);
 
@@ -1829,6 +1845,7 @@ export function LSPProvider(props: ParentProps) {
     <LSPContext.Provider
       value={{
         state,
+        lazyInit,
         startServer,
         stopServer,
         stopAllServers,