Feature/regression fixes (#190)

* Fix Paste button in Avalonia Browser app

* Fix Attach disk image button in Avalonia Desktop and Browser app

* Fix possible issue in Avalonia Desktop startup.

Author: highbyte

src/apps/Avalonia/Highbyte.DotNet6502.App.Avalonia.Core/ViewModels/C64MenuViewModel.cs

@@ -683,12 +683,8 @@ private bool IsC64System()
 
     // Events for View to handle clipboard and file operations
     public event EventHandler<string>? ClipboardCopyRequested;
-    public event EventHandler? ClipboardPasteRequested;
-    public event EventHandler? AttachDiskImageRequested;
-
-    // Properties for View to provide results
-    public string? ClipboardPasteResult { get; set; }
-    public byte[]? DiskImageFileResult { get; set; }
+    public event EventHandler<TaskCompletionSource<string?>>? ClipboardPasteRequested;
+    public event EventHandler<TaskCompletionSource<byte[]?>>? AttachDiskImageRequested;
 
     private async Task RequestClipboardCopyAsync(string text)
     {
@@ -698,26 +694,28 @@ private async Task RequestClipboardCopyAsync(string text)
 
     private async Task<string?> RequestClipboardPasteAsync()
     {
-        ClipboardPasteResult = null;
-        ClipboardPasteRequested?.Invoke(this, EventArgs.Empty);
-        // View should synchronously set ClipboardPasteResult
-        await Task.CompletedTask;
-        return ClipboardPasteResult;
+        if (ClipboardPasteRequested == null)
+            return null;
+        var tcs = new TaskCompletionSource<string?>();
+        ClipboardPasteRequested.Invoke(this, tcs);
+        return await tcs.Task;
     }
 
     private async Task RequestAttachDiskImageAsync()
     {
-        DiskImageFileResult = null;
-        AttachDiskImageRequested?.Invoke(this, EventArgs.Empty);
-        // View should handle file picker and set DiskImageFileResult
-        await Task.Delay(100); // Give UI time to process
+        if (AttachDiskImageRequested == null)
+            return;
+
+        var tcs = new TaskCompletionSource<byte[]?>();
+        AttachDiskImageRequested.Invoke(this, tcs);
+        var fileBuffer = await tcs.Task;
 
-        if (DiskImageFileResult != null)
+        if (fileBuffer != null)
         {
             try
             {
                 // Parse the D64 disk image
-                var d64DiskImage = Systems.Commodore64.TimerAndPeripheral.DiskDrive.D64.D64Parser.ParseD64File(DiskImageFileResult);
+                var d64DiskImage = Systems.Commodore64.TimerAndPeripheral.DiskDrive.D64.D64Parser.ParseD64File(fileBuffer);
 
                 // Set the disk image on the running C64's DiskDrive1541
                 var c64 = (C64)_avaloniaHostApp!.CurrentRunningSystem!;

src/apps/Avalonia/Highbyte.DotNet6502.App.Avalonia.Core/Views/C64MenuView.axaml.cs

@@ -67,54 +67,65 @@ private void OnClipboardCopyRequested(object? sender, string text)
             }
         });
 
-    private void OnClipboardPasteRequested(object? sender, EventArgs e)
+    private void OnClipboardPasteRequested(object? sender, TaskCompletionSource<string?> tcs)
         => SafeAsyncHelper.Execute(async () =>
         {
-            if (ViewModel != null
-                && TopLevel.GetTopLevel(this) is { } topLevel
-                && topLevel.Clipboard is { } clipboard)
+            if (TopLevel.GetTopLevel(this) is { } topLevel && topLevel.Clipboard is { } clipboard)
             {
                 using var data = await clipboard.TryGetDataAsync();
-                if (data is not null)
-                    ViewModel.ClipboardPasteResult = await data.TryGetTextAsync();
+                tcs.SetResult(data is not null ? await data.TryGetTextAsync() : null);
+            }
+            else
+            {
+                tcs.SetResult(null);
             }
         });
 
-    private void OnAttachDiskImageRequested(object? sender, EventArgs e)
+    private void OnAttachDiskImageRequested(object? sender, TaskCompletionSource<byte[]?> tcs)
         => SafeAsyncHelper.Execute(async () =>
         {
-            if (ViewModel == null || TopLevel.GetTopLevel(this) is not { } topLevel)
+            if (TopLevel.GetTopLevel(this) is not { } topLevel)
+            {
+                tcs.SetResult(null);
                 return;
+            }
 
             var storageProvider = topLevel.StorageProvider;
-            if (storageProvider.CanOpen)
+            if (!storageProvider.CanOpen)
             {
-                var files = await storageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
-                {
-                    Title = "Select D64 Disk Image",
-                    AllowMultiple = false,
-                    FileTypeFilter = new[]
-                    {
-                        new FilePickerFileType("D64 Disk Images") { Patterns = new[] { "*.d64" } },
-                        new FilePickerFileType("All Files") { Patterns = new[] { "*" } }
-                   }
-                });
+                tcs.SetResult(null);
+                return;
+            }
 
-                if (files.Count > 0)
+            var files = await storageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
+            {
+                Title = "Select D64 Disk Image",
+                AllowMultiple = false,
+                FileTypeFilter = new[]
                 {
-                    try
-                    {
-                        await using var stream = await files[0].OpenReadAsync();
-                        var fileBuffer = new byte[stream.Length];
-                        await stream.ReadExactlyAsync(fileBuffer);
+                    new FilePickerFileType("D64 Disk Images") { Patterns = new[] { "*.d64" } },
+                    new FilePickerFileType("All Files") { Patterns = new[] { "*" } }
+                }
+            });
 
-                        ViewModel.DiskImageFileResult = fileBuffer;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logger.LogError(ex, "Error reading disk image file");
-                    }
+            if (files.Count > 0)
+            {
+                try
+                {
+                    await using var stream = await files[0].OpenReadAsync();
+                    var fileBuffer = new byte[stream.Length];
+                    await stream.ReadExactlyAsync(fileBuffer);
+                    tcs.SetResult(fileBuffer);
                 }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, "Error reading disk image file");
+                    tcs.SetResult(null);
+                }
+            }
+            else
+            {
+                tcs.SetResult(null);
             }
         });
 

src/apps/Avalonia/Highbyte.DotNet6502.App.Avalonia.Desktop/Program.cs

@@ -386,12 +386,19 @@ public static int Main(string[] args)
                 var startupLogger = loggerFactory.CreateLogger(nameof(Program));
 
                 // The App object is created lazily by Avalonia during StartWithClassicDesktopLifetime,
-                // so poll until both the App and HostApp instances have been initialized.
-                startupLogger.LogInformation("Waiting for Avalonia HostApp initialization...");
-                while (Core.App.Current is not { IsHostAppReady: true })
+                // so we need App.Current to exist before we can await WhenHostAppReadyAsync.
+                startupLogger.LogInformation("Waiting for Avalonia App instance...");
+                while (Core.App.Current == null)
                     await Task.Delay(10);
 
-                var hostApp = Core.App.Current.HostApp;
+                // Await proper readiness — the TCS guarantees all writes made before TrySetResult
+                // (including full HostApp construction) are visible to the continuation here.
+                // VSTHRD003: suppressed — WhenHostAppReadyAsync is a TCS completion signal, not work
+                // started in another context; ConfigureAwait(false) already handles context capture.
+                startupLogger.LogInformation("Awaiting HostApp initialization...");
+#pragma warning disable VSTHRD003
+                var hostApp = await Core.App.WhenHostAppReadyAsync.ConfigureAwait(false);
+#pragma warning restore VSTHRD003
                 startupLogger.LogInformation("HostApp initialized.");
 
                 await AutomatedStartupHandler.ExecuteAsync(