feat: register struct field maps in global registry via inventory

The #[derive(FieldRegistry)] proc macro now also submits a
StructRegistration to the global inventory, enabling runtime lookup
by struct name or vtable address:

- struct_fields_for("DDGame") -> Option<&StructFields>
- struct_fields_for_vtable(0x0066_A30C) -> Option<&StructFields>

Uses a lazy HashMap<&str, &StructFields> built on first query.
This connects the field registry to detect_pointer() for future
"DDGame+0x45EC = rng_state" style output.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/openwa-core/src/registry.rs

@@ -234,6 +234,49 @@ pub trait HasFieldRegistry {
     fn field_registry() -> &'static StructFields;
 }
 
+/// A struct's field registry submitted to the global collection via `inventory`.
+///
+/// The `#[derive(FieldRegistry)]` macro emits an `inventory::submit!` for each
+/// annotated struct, making it discoverable at runtime via
+/// [`struct_fields_for`].
+pub struct StructRegistration {
+    pub fields: &'static StructFields,
+}
+
+inventory::collect!(StructRegistration);
+
+static STRUCT_MAP: OnceLock<std::collections::HashMap<&'static str, &'static StructFields>> =
+    OnceLock::new();
+
+fn struct_map() -> &'static std::collections::HashMap<&'static str, &'static StructFields> {
+    STRUCT_MAP.get_or_init(|| {
+        inventory::iter::<StructRegistration>
+            .into_iter()
+            .map(|r| (r.fields.struct_name, r.fields))
+            .collect()
+    })
+}
+
+/// Look up the field registry for a struct by name.
+///
+/// Returns `None` if the struct doesn't have `#[derive(FieldRegistry)]`.
+pub fn struct_fields_for(struct_name: &str) -> Option<&'static StructFields> {
+    struct_map().get(struct_name).copied()
+}
+
+/// Look up the field registry for a class identified by its vtable address.
+///
+/// Combines vtable → class name lookup with struct fields lookup.
+pub fn struct_fields_for_vtable(ghidra_vtable: u32) -> Option<&'static StructFields> {
+    let class = vtable_class_name(ghidra_vtable)?;
+    struct_fields_for(class)
+}
+
+/// Return all registered struct field registries.
+pub fn all_struct_fields() -> impl Iterator<Item = &'static StructFields> {
+    struct_map().values().copied()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -411,4 +454,36 @@ mod tests {
         // Doc comment should be non-empty (we have "0x00: Pointer to virtual method table")
         assert!(!vtable.doc.is_empty(), "doc should be extracted: {:?}", vtable.doc);
     }
+
+    #[test]
+    fn struct_fields_for_lookup() {
+        // Global registry should find structs by name
+        let ddgame = struct_fields_for("DDGame");
+        assert!(ddgame.is_some(), "DDGame not found in struct registry");
+        assert_eq!(ddgame.unwrap().struct_name, "DDGame");
+
+        let ctask = struct_fields_for("CTask");
+        assert!(ctask.is_some(), "CTask not found in struct registry");
+
+        let session = struct_fields_for("GameSession");
+        assert!(session.is_some(), "GameSession not found in struct registry");
+
+        // Unknown struct returns None
+        assert!(struct_fields_for("FooBarBaz").is_none());
+    }
+
+    #[test]
+    fn struct_fields_for_vtable_lookup() {
+        use crate::address::va;
+
+        // DDGameWrapper vtable → "DDGameWrapper" → DDGameWrapper fields
+        let fields = struct_fields_for_vtable(va::DDGAME_WRAPPER_VTABLE);
+        assert!(fields.is_some(), "DDGameWrapper fields not found via vtable");
+        assert_eq!(fields.unwrap().struct_name, "DDGameWrapper");
+
+        // CTask vtable → "CTask" → CTask fields
+        let fields = struct_fields_for_vtable(va::CTASK_VTABLE);
+        assert!(fields.is_some(), "CTask fields not found via vtable");
+        assert_eq!(fields.unwrap().struct_name, "CTask");
+    }
 }

crates/openwa-derive/src/lib.rs

@@ -83,21 +83,36 @@ pub fn derive_field_registry(input: TokenStream) -> TokenStream {
 
     let entry_count = entries.len();
 
+    // Generate a unique static name to avoid collisions across structs.
+    let fields_static = quote::format_ident!("_FIELD_REGISTRY_{}", struct_name);
+
     let expanded = quote! {
-        impl openwa_core::registry::HasFieldRegistry for #struct_name {
-            fn field_registry() -> &'static openwa_core::registry::StructFields {
+        // The static StructFields table, accessible both from the trait impl
+        // and from the inventory registration (which needs a const context).
+        #[doc(hidden)]
+        #[allow(non_upper_case_globals)]
+        static #fields_static: openwa_core::registry::StructFields = openwa_core::registry::StructFields {
+            struct_name: #struct_name_str,
+            fields: {
                 // Fields are already sorted by offset because #[repr(C)]
                 // guarantees declaration order = memory order.
-                static FIELDS: openwa_core::registry::StructFields = openwa_core::registry::StructFields {
-                    struct_name: #struct_name_str,
-                    fields: {
-                        const ENTRIES: [openwa_core::registry::FieldEntry; #entry_count] = [
-                            #(#entries),*
-                        ];
-                        &ENTRIES
-                    },
-                };
-                &FIELDS
+                const ENTRIES: [openwa_core::registry::FieldEntry; #entry_count] = [
+                    #(#entries),*
+                ];
+                &ENTRIES
+            },
+        };
+
+        impl openwa_core::registry::HasFieldRegistry for #struct_name {
+            fn field_registry() -> &'static openwa_core::registry::StructFields {
+                &#fields_static
+            }
+        }
+
+        // Register in the global struct registry so struct_fields_for() works.
+        openwa_core::inventory::submit! {
+            openwa_core::registry::StructRegistration {
+                fields: &#fields_static,
             }
         }
     };