fix: resolve app startup hang in IDE debug mode

Root causes:
1. Irihi.Lingua NuGet package (unused) — source generator/runtime may cause
   debug-mode initialization issues. Removed until actual integration.
2. LoadFromResources() called in Initialize() — asset loader may not be
   ready yet. Moved to OnFrameworkInitializationCompleted().
3. async void OnFrameworkInitializationCompleted — Avalonia's framework
   initialization does not reliably support async continuations; the await
   on LoadAsync could cause the continuation to be dropped on certain
   synchronization contexts.
4. No synchronous config loading path — startup now uses synchronous
   Load()/Save() to avoid async-related deadlocks during initialization.
   Runtime saves remain async (window close, property changes).

Changes:
- Remove Irihi.Lingua 0.2.0 package reference
- Move LoadFromResources() from Initialize() to OnFrameworkInitializationCompleted()
- Change OnFrameworkInitializationCompleted back to synchronous (void)
- Add IConfigService.Load() + ConfigService.Load() for synchronous startup
- Add private ConfigService.Save() for synchronous writes during Load()
- Add LoadConfigSafe() with exception-protected synchronous config init

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JusterZhu

src/App.axaml.cs

@@ -15,19 +15,17 @@ public partial class App : Application
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
-
-        // Load translations from embedded JSON files (falls back to built-in dictionaries)
-        Services.LocalizationService.Instance.LoadFromResources();
     }
 
-    public override async void OnFrameworkInitializationCompleted()
+    public override void OnFrameworkInitializationCompleted()
     {
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
-            // Initialize configuration
-            var configService = ConfigServiceSingleton.Instance;
-            await configService.LoadAsync();
-            var config = configService.Config;
+            // Load translations from embedded JSON files (must be after platform init)
+            Services.LocalizationService.Instance.LoadFromResources();
+
+            // Initialize configuration (synchronous path for startup reliability)
+            var config = LoadConfigSafe();
 
             // Apply saved theme
             RequestedThemeVariant = config.Theme == "Dark"
@@ -49,6 +47,7 @@ public override async void OnFrameworkInitializationCompleted()
                 mainWindow.WindowState = WindowState.Maximized;
 
             // Save window state on close
+            var configService = ConfigServiceSingleton.Instance;
             mainWindow.Closing += (_, _) =>
             {
                 if (mainWindow.WindowState == WindowState.Maximized)
@@ -71,6 +70,26 @@ public override async void OnFrameworkInitializationCompleted()
 
         base.OnFrameworkInitializationCompleted();
     }
+
+    /// <summary>
+    /// Load configuration synchronously with exception protection.
+    /// Uses blocking I/O on first load to avoid async-initialization races in Avalonia.
+    /// Save operations remain async (fire-and-forget from window close / property changes).
+    /// </summary>
+    private static AppConfig LoadConfigSafe()
+    {
+        try
+        {
+            var configService = ConfigServiceSingleton.Instance;
+            // Synchronous load for startup reliability
+            configService.Load();
+            return configService.Config;
+        }
+        catch
+        {
+            return new AppConfig();
+        }
+    }
 }
 
 /// <summary>

src/Configuration/ConfigService.cs

@@ -36,6 +36,91 @@ public ConfigService()
         _backupPath = Path.Combine(_configDir, "config.json.backup");
     }
 
+    /// <inheritdoc />
+    public void Load()
+    {
+        Directory.CreateDirectory(_configDir);
+
+        if (!File.Exists(_configPath))
+        {
+            // Try to recover from backup
+            if (File.Exists(_backupPath))
+            {
+                try
+                {
+                    var backupJson = File.ReadAllText(_backupPath);
+                    Config = JsonConvert.DeserializeObject<AppConfig>(backupJson, JsonSettings) ?? new AppConfig();
+                    Save(); // Restore main file from backup
+                    return;
+                }
+                catch
+                {
+                    // Backup is corrupted; fall through to defaults
+                }
+            }
+
+            // First run: save defaults so the file exists
+            Config = new AppConfig();
+            Save();
+            return;
+        }
+
+        try
+        {
+            var json = File.ReadAllText(_configPath);
+            Config = JsonConvert.DeserializeObject<AppConfig>(json, JsonSettings) ?? new AppConfig();
+
+            // Run schema migrations
+            Migrate();
+        }
+        catch (JsonException)
+        {
+            // Config file is corrupted; try backup
+            if (File.Exists(_backupPath))
+            {
+                try
+                {
+                    var backupJson = File.ReadAllText(_backupPath);
+                    Config = JsonConvert.DeserializeObject<AppConfig>(backupJson, JsonSettings) ?? new AppConfig();
+                    Save();
+                    return;
+                }
+                catch
+                {
+                    // Backup also corrupted; reset
+                }
+            }
+
+            Config = new AppConfig();
+            Save();
+        }
+    }
+
+    /// <summary>Synchronous save for internal use during Load().</summary>
+    private void Save()
+    {
+        _saveLock.Wait();
+        try
+        {
+            Directory.CreateDirectory(_configDir);
+
+            if (File.Exists(_configPath))
+            {
+                try { File.Copy(_configPath, _backupPath, overwrite: true); }
+                catch { /* Non-critical */ }
+            }
+
+            var json = JsonConvert.SerializeObject(Config, JsonSettings);
+            var tempPath = _configPath + ".tmp";
+            File.WriteAllText(tempPath, json);
+            File.Move(tempPath, _configPath, overwrite: true);
+        }
+        finally
+        {
+            _saveLock.Release();
+        }
+    }
+
     /// <inheritdoc />
     public async Task LoadAsync()
     {

src/Configuration/IConfigService.cs

@@ -10,6 +10,9 @@ public interface IConfigService
     /// <summary>Current in-memory configuration. Save to persist changes.</summary>
     AppConfig Config { get; }
 
+    /// <summary>Load configuration from disk synchronously. Called once at startup.</summary>
+    void Load();
+
     /// <summary>Load configuration from disk. Called once at startup.</summary>
     Task LoadAsync();
 

src/GeneralUpdate.Tools.csproj

@@ -32,7 +32,6 @@
     <ProjectReference Include="..\..\..\GeneralUpdate\src\c#\GeneralUpdate.Core\GeneralUpdate.Core.csproj" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="9.0.0" />
-    <PackageReference Include="Irihi.Lingua" Version="0.2.0" />
   </ItemGroup>
 
   <ItemGroup>