feat(hosts): add global exception handling to prevent crashes

Avalonia Host:
- Add AppDomain.UnhandledException handler
- Add TaskScheduler.UnobservedTaskException handler (SetObserved)
- Add Dispatcher.UIThread.UnhandledException handler (Handled=true)
- Initialize logger before registering exception handlers

Blazor Host (MAUI):
- Add AppDomain.UnhandledException handler
- Add TaskScheduler.UnobservedTaskException handler
- Add Android-specific AndroidEnvironment.UnhandledExceptionRaiser

Fix module unload crash:
- AvaloniaNavigationService.ClearModuleCache now notifies Shell to clear
  current view before AssemblyLoadContext.Unload() is called

Author: Hongwei-MB

src/Hosts/Modulus.Host.Avalonia/App.axaml.cs

@@ -62,6 +62,10 @@ public partial class App : Application
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
+        
+        // Register UI thread exception handler after Avalonia is initialized
+        Program.RegisterDispatcherExceptionHandler();
+        
 #if DEBUG
         this.AttachDeveloperTools();
 #endif

src/Hosts/Modulus.Host.Avalonia/Program.cs

@@ -1,22 +1,97 @@
 using Avalonia;
+using Avalonia.Threading;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Modulus.Core.Logging;
 using System;
+using System.Threading.Tasks;
 
 namespace Modulus.Host.Avalonia;
 
 class Program
 {
+    private static ILogger _logger = null!;
+
     // Initialization code. Don't use any Avalonia, third-party APIs or any
     // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
     // yet and stuff might break.
     [STAThread]
-    public static void Main(string[] args) => BuildAvaloniaApp()
-        .StartWithClassicDesktopLifetime(args);
+    public static void Main(string[] args)
+    {
+        // Initialize logger first - Serilog doesn't depend on Avalonia
+        var emptyConfig = new ConfigurationBuilder().Build();
+        var loggerFactory = ModulusLogging.CreateLoggerFactory(emptyConfig, "AvaloniaApp");
+        _logger = loggerFactory.CreateLogger<Program>();
+
+        // Setup global exception handlers (logger is now ready)
+        SetupGlobalExceptionHandlers();
+        _logger.LogInformation("Global exception handlers initialized.");
+
+        try
+        {
+            BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogCritical(ex, "Application startup failed: {Message}", ex.Message);
+            throw;
+        }
+    }
 
     // Avalonia configuration, don't remove; also used by visual designer.
     public static AppBuilder BuildAvaloniaApp()
         => AppBuilder.Configure<App>()
             .UsePlatformDetect()
             .WithInterFont()
             .LogToTrace();
+
+    private static void SetupGlobalExceptionHandlers()
+    {
+        // Handle all unhandled exceptions in the AppDomain
+        AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
+
+        // Handle unobserved task exceptions
+        TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+    }
+
+    private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
+    {
+        var exception = e.ExceptionObject as Exception;
+
+        if (e.IsTerminating)
+        {
+            _logger.LogCritical(exception, "Fatal unhandled exception - application will terminate: {Message}", 
+                exception?.Message ?? "Unknown error");
+        }
+        else
+        {
+            _logger.LogError(exception, "Unhandled exception caught: {Message}", 
+                exception?.Message ?? "Unknown error");
+        }
+    }
+
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        // Mark as observed to prevent process termination
+        e.SetObserved();
+
+        _logger.LogError(e.Exception, "Unobserved task exception: {Message}", e.Exception.Message);
+    }
+
+    /// <summary>
+    /// Called by App to register the Avalonia Dispatcher exception handler after Avalonia is initialized.
+    /// </summary>
+    internal static void RegisterDispatcherExceptionHandler()
+    {
+        Dispatcher.UIThread.UnhandledException += OnDispatcherUnhandledException;
+    }
+
+    private static void OnDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
+    {
+        _logger.LogError(e.Exception, "UI thread exception: {Message}", e.Exception.Message);
+
+        // Mark as handled to prevent crash - the UI can continue
+        e.Handled = true;
+    }
 }
 

src/Hosts/Modulus.Host.Avalonia/Services/AvaloniaNavigationService.cs

@@ -377,7 +377,7 @@ public void ClearModuleCache(string moduleId)
             _singletonViews.TryRemove(key, out _);
         }
 
-        // If current navigation is from this module, clear it
+        // If current navigation is from this module, navigate away to clear the view
         if (_currentViewModel != null && _runtimeContext.TryGetModuleHandle(moduleId, out var currentHandle) && currentHandle != null)
         {
             var currentAssembly = _currentViewModel.GetType().Assembly;
@@ -386,6 +386,9 @@ public void ClearModuleCache(string moduleId)
                 _currentViewModel = null;
                 _currentView = null;
                 _currentNavigationKey = null;
+                
+                // Notify shell to clear the current view before module unload
+                OnViewChanged?.Invoke(null, string.Empty);
             }
         }
     }

src/Hosts/Modulus.Host.Blazor/MauiProgram.cs

@@ -15,6 +15,10 @@
 using Modulus.UI.Abstractions;
 using UiMenuItem = Modulus.UI.Abstractions.MenuItem;
 
+#if ANDROID
+using Android.Runtime;
+#endif
+
 namespace Modulus.Host.Blazor;
 
 [DependsOn()]
@@ -56,10 +60,27 @@ public override Task OnApplicationInitializationAsync(IModuleInitializationConte
 
 public static class MauiProgram
 {
+    private static ILogger _logger = null!;
+
     public static void Main(string[] args) {} // Dummy entry point for net10.0 target without MAUI
 
     public static MauiApp CreateMauiApp()
     {
+        // Configuration (needed for logger)
+        var configuration = new ConfigurationBuilder()
+            .SetBasePath(AppContext.BaseDirectory)
+            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
+            .AddEnvironmentVariables()
+            .Build();
+
+        // Initialize logger first
+        var loggerFactory = ModulusLogging.CreateLoggerFactory(configuration, HostType.Blazor);
+        _logger = loggerFactory.CreateLogger<MauiApp>();
+
+        // Setup global exception handlers (logger is now ready)
+        SetupGlobalExceptionHandlers();
+        _logger.LogInformation("Global exception handlers initialized.");
+
         var builder = MauiApp.CreateBuilder();
         builder
             .UseMauiApp<App>()
@@ -68,14 +89,6 @@ public static MauiApp CreateMauiApp()
                 fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
             });
 
-        // Configuration
-        var configuration = new ConfigurationBuilder()
-            .SetBasePath(AppContext.BaseDirectory)
-            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
-            .AddEnvironmentVariables()
-            .Build();
-
-        var loggerFactory = ModulusLogging.CreateLoggerFactory(configuration, HostType.Blazor);
         ModulusLogging.AddLoggerFactory(builder.Services, loggerFactory);
 
         // Module Providers - load from Modules/ directory relative to executable
@@ -129,4 +142,51 @@ public static MauiApp CreateMauiApp()
         return app;
     }
 
+    private static void SetupGlobalExceptionHandlers()
+    {
+        // Handle all unhandled exceptions in the AppDomain
+        AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
+
+        // Handle unobserved task exceptions
+        TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
+
+#if ANDROID
+        // Android-specific unhandled exception handler
+        AndroidEnvironment.UnhandledExceptionRaiser += OnAndroidUnhandledException;
+#endif
+    }
+
+    private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
+    {
+        var exception = e.ExceptionObject as Exception;
+
+        if (e.IsTerminating)
+        {
+            _logger.LogCritical(exception, "Fatal unhandled exception - application will terminate: {Message}",
+                exception?.Message ?? "Unknown error");
+        }
+        else
+        {
+            _logger.LogError(exception, "Unhandled exception caught: {Message}",
+                exception?.Message ?? "Unknown error");
+        }
+    }
+
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        // Mark as observed to prevent process termination
+        e.SetObserved();
+
+        _logger.LogError(e.Exception, "Unobserved task exception: {Message}", e.Exception.Message);
+    }
+
+#if ANDROID
+    private static void OnAndroidUnhandledException(object? sender, RaiseThrowableEventArgs e)
+    {
+        _logger.LogError(e.Exception, "Android unhandled exception: {Message}", e.Exception.Message);
+        
+        // Set handled to prevent crash where possible
+        e.Handled = true;
+    }
+#endif
 }