Merge main: port WineFix to staged plugin loading pipeline

Author: noahc3

AffinityHook/Program.cs

@@ -219,14 +219,43 @@ private static void InjectBootstrap(int processId, string pluginLoaderPath)
 
                 Console.WriteLine($"Using native bootstrap: {bootstrapPath}");
 
-                // Wait a moment for process to initialize
-                Thread.Sleep(500);
+                // Poll until we can open the process
+                IntPtr hProcess = IntPtr.Zero;
+                for (int i = 0; i < 50; i++)
+                {
+                    hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, processId);
+                    if (hProcess != IntPtr.Zero)
+                        break;
+                    Thread.Sleep(10);
+                }
 
-                // Open process with full access
-                IntPtr hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, processId);
                 if (hProcess == IntPtr.Zero)
                 {
-                    throw new Exception($"Failed to open process. Error: {Marshal.GetLastWin32Error()}");
+                    throw new Exception($"Failed to open process after polling. Error: {Marshal.GetLastWin32Error()}");
+                }
+                
+                // Wait for CLR to be fully initialized by polling for clrjit.dll,
+                // one of the last modules loaded during CLR startup.
+                // Injecting before the CLR is ready causes a fatal crash (80131506).
+                Console.WriteLine("Waiting for CLR to initialize in target process...");
+                bool clrReady = false;
+                for (int i = 0; i < 300; i++) // 300 * 10ms = 3s max
+                {
+                    if (ProcessHasModule(processId, "clrjit.dll"))
+                    {
+                        clrReady = true;
+                        break;
+                    }
+                    Thread.Sleep(10);
+                }
+                
+                if (!clrReady)
+                {
+                    Console.WriteLine("WARNING: CLR may not be fully initialized, proceeding anyway...");
+                }
+                else
+                {
+                    Console.WriteLine("CLR initialized, injecting...");
                 }
 
                 try
@@ -303,6 +332,62 @@ private static void InjectBootstrap(int processId, string pluginLoaderPath)
         private const uint MEM_COMMIT = 0x1000;
         private const uint MEM_RESERVE = 0x2000;
         private const uint PAGE_READWRITE = 0x04;
+        private const uint TH32CS_SNAPMODULE = 0x00000008;
+        private const uint TH32CS_SNAPMODULE32 = 0x00000010;
+        
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct MODULEENTRY32W
+        {
+            public uint dwSize;
+            public uint th32ModuleID;
+            public uint th32ProcessID;
+            public uint GlblcntUsage;
+            public uint ProccntUsage;
+            public IntPtr modBaseAddr;
+            public uint modBaseSize;
+            public IntPtr hModule;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
+            public string szModule;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
+            public string szExePath;
+        }
+        
+        private static bool ProcessHasModule(int processId, string moduleName)
+        {
+            IntPtr snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, (uint)processId);
+            if (snap == IntPtr.Zero || snap == new IntPtr(-1))
+                return false;
+            
+            try
+            {
+                var entry = new MODULEENTRY32W();
+                entry.dwSize = (uint)Marshal.SizeOf(typeof(MODULEENTRY32W));
+                
+                if (!Module32FirstW(snap, ref entry))
+                    return false;
+                
+                do
+                {
+                    if (entry.szModule.Equals(moduleName, StringComparison.OrdinalIgnoreCase))
+                        return true;
+                } while (Module32NextW(snap, ref entry));
+                
+                return false;
+            }
+            finally
+            {
+                CloseHandle(snap);
+            }
+        }
+        
+        [DllImport("kernel32.dll", SetLastError = true)]
+        private static extern IntPtr CreateToolhelp32Snapshot(uint dwFlags, uint th32ProcessID);
+        
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+        private static extern bool Module32FirstW(IntPtr hSnapshot, ref MODULEENTRY32W lpme);
+        
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+        private static extern bool Module32NextW(IntPtr hSnapshot, ref MODULEENTRY32W lpme);
 
         [DllImport("kernel32.dll", SetLastError = true)]
         private static extern IntPtr GetModuleHandle(string lpModuleName);

AffinityPluginLoader/AffinityPlugin.cs

@@ -4,19 +4,51 @@
 namespace AffinityPluginLoader
 {
     /// <summary>
-    /// Base class for all APL plugins. Extend this and override Initialize() to apply Harmony patches.
-    /// Optionally override DefineSettings() to expose configuration in the preferences dialog.
+    /// Base class for all APL plugins. Override stage methods to participate in the loading pipeline.
     /// </summary>
     public abstract class AffinityPlugin
     {
         /// <summary>
-        /// Called when the plugin is loaded. Apply Harmony patches here.
+        /// Stage 0: Called immediately after plugin discovery and settings init.
+        /// No Affinity types are available yet. Use for early setup that doesn't touch Affinity code.
         /// </summary>
-        public abstract void Initialize(Harmony harmony);
+        public virtual void OnLoad(IPluginContext context) { }
+
+        /// <summary>
+        /// Stage 1: Called when Serif assemblies are loaded, before Affinity's OnStartup() runs.
+        /// Apply Harmony patches here. APL settings are available via context.Settings.
+        /// </summary>
+        public virtual void OnPatch(Harmony harmony, IPluginContext context) { }
+
+        /// <summary>
+        /// Stage 2: Called after Affinity's InitialiseServices() completes.
+        /// All Affinity services and settings are available in the DI container.
+        /// </summary>
+        public virtual void OnServicesReady(IPluginContext context) { }
+
+        /// <summary>
+        /// Stage 3: Called after Affinity's OnServicesInitialised() completes.
+        /// Full runtime is available including native engine, tools, and effects.
+        /// </summary>
+        public virtual void OnReady(IPluginContext context) { }
+
+        /// <summary>
+        /// Stage 4: Called after the main window is loaded and visible.
+        /// Full UI tree is available for custom panels, dialogs, and UI modifications.
+        /// </summary>
+        public virtual void OnUiReady(IPluginContext context) { }
+
+        /// <summary>
+        /// Stage 5: Called after startup is fully complete — splash hidden, app idle.
+        /// Safe to show dialogs, toasts, or do any work that should wait until the user
+        /// is looking at a fully loaded application.
+        /// </summary>
+        public virtual void OnStartupComplete(IPluginContext context) { }
 
         /// <summary>
         /// Override to define configuration options for this plugin.
         /// Returns null by default (no settings / no preferences tab).
+        /// Called during Stage 0 before OnLoad.
         /// </summary>
         public virtual PluginSettingsDefinition DefineSettings() => null;