refactor: add usercall_trampoline! macro for naked asm generation

Replaces hand-written naked trampolines in frontend.rs and scheme.rs
with a declarative macro that handles register capture + stack forwarding.

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

crates/openwa-wormkit/src/hook.rs

@@ -1,4 +1,59 @@
 //! MinHook helper for installing inline hooks on WA.exe functions.
+//!
+//! Also provides the [`usercall_trampoline!`] macro for generating naked asm
+//! trampolines that capture implicit register params from MSVC `__usercall`
+//! functions and forward them to cdecl Rust implementations.
+
+/// Generate a naked trampoline for a `__usercall` function.
+///
+/// Captures one implicit register param and optionally forwards stack params
+/// to a `cdecl` Rust implementation function.
+///
+/// The impl_fn signature must be: `extern "cdecl" fn(reg_value, stack_args...) -> R`
+///
+/// # Variants
+///
+/// ```ignore
+/// // 1 register, 0 stack params, plain ret
+/// usercall_trampoline!(fn name; impl_fn = path; reg = eax);
+///
+/// // 1 register, 1 stack param, ret with cleanup
+/// usercall_trampoline!(fn name; impl_fn = path; reg = esi;
+///     stack_params = 1; ret_bytes = "0x4");
+/// ```
+macro_rules! usercall_trampoline {
+    // 1 register arg, 0 stack params, plain ret
+    (fn $name:ident; impl_fn = $impl:path; reg = $reg:ident) => {
+        #[unsafe(naked)]
+        unsafe extern "C" fn $name() {
+            core::arch::naked_asm!(
+                concat!("push ", stringify!($reg)),
+                "call {impl_fn}",
+                "add esp, 4",
+                "ret",
+                impl_fn = sym $impl,
+            );
+        }
+    };
+
+    // 1 register arg, 1 stack param, ret N
+    (fn $name:ident; impl_fn = $impl:path; reg = $reg:ident;
+     stack_params = 1; ret_bytes = $ret:literal) => {
+        #[unsafe(naked)]
+        unsafe extern "C" fn $name() {
+            core::arch::naked_asm!(
+                "push [esp+4]",
+                concat!("push ", stringify!($reg)),
+                "call {impl_fn}",
+                "add esp, 8",
+                concat!("ret ", $ret),
+                impl_fn = sym $impl,
+            );
+        }
+    };
+}
+
+pub(crate) use usercall_trampoline;
 
 use std::ffi::c_void;
 

crates/openwa-wormkit/src/replacements/frontend.rs

@@ -14,24 +14,10 @@ use openwa_types::frontend::ScreenId;
 /// Trampoline to the original FrontendChangeScreen (for fallback if needed).
 static ORIG_FRONTEND_CHANGE_SCREEN: AtomicU32 = AtomicU32::new(0);
 
-/// Naked trampoline that captures ESI (the implicit dialog this pointer)
-/// and routes it to our cdecl Rust implementation.
-///
-/// Stack on entry (from MinHook redirect):
-///   [ESP+0] = return address
-///   [ESP+4] = screen_id
-///   ESI     = dialog this (MSVC __usercall convention)
-#[unsafe(naked)]
-unsafe extern "stdcall" fn trampoline(_screen_id: u32) {
-    core::arch::naked_asm!(
-        "push [esp+4]",       // push screen_id
-        "push esi",           // push dialog this
-        "call {impl_fn}",    // cdecl call: impl(dialog, screen_id)
-        "add esp, 8",        // clean our two pushes
-        "ret 0x4",           // clean original screen_id from caller's stack
-        impl_fn = sym frontend_change_screen_impl,
-    );
-}
+// Naked trampoline: captures ESI (dialog this, __usercall) + 1 stack arg (screen_id).
+crate::hook::usercall_trampoline!(fn trampoline;
+    impl_fn = frontend_change_screen_impl; reg = esi;
+    stack_params = 1; ret_bytes = "0x4");
 
 /// Rust reimplementation of FrontendChangeScreen.
 ///

crates/openwa-wormkit/src/replacements/scheme.rs

@@ -168,20 +168,9 @@ unsafe fn call_original_read_file(dest: u32, path: u32, flag: u32, out_ptr: u32)
 // Scheme__ValidateExtendedOptions replacement (0x4D5110)
 // ============================================================
 
-/// Naked trampoline for Scheme__ValidateExtendedOptions.
-///
-/// WA calls this with EAX = pointer to 110-byte extended options data.
-/// Plain RET (no stack cleanup). Returns EAX: 0 = valid, 1 = invalid.
-#[unsafe(naked)]
-unsafe extern "C" fn trampoline_validate_ext_opts() {
-    core::arch::naked_asm!(
-        "push eax",         // push options pointer as arg
-        "call {impl_fn}",  // cdecl call
-        "add esp, 4",      // clean up our push
-        "ret",              // plain ret (no stack params to clean)
-        impl_fn = sym validate_extended_options_impl,
-    );
-}
+// Naked trampoline: captures EAX (110-byte extended options pointer). Returns 0=valid, 1=invalid.
+crate::hook::usercall_trampoline!(fn trampoline_validate_ext_opts;
+    impl_fn = validate_extended_options_impl; reg = eax);
 
 /// Rust implementation called by the naked trampoline.
 unsafe extern "cdecl" fn validate_extended_options_impl(options_ptr: u32) -> u32 {