diff --git a/derive/src/impl_attribute.rs b/derive/src/impl_attribute.rs
index 68e9438..3eb3bc7 100644
--- a/derive/src/impl_attribute.rs
+++ b/derive/src/impl_attribute.rs
@@ -112,9 +112,9 @@ pub fn godot_script_impl(
             };
 
             let method_flag = if is_static {
-                quote!(#godot_types::global::MethodFlags::STATIC)
+                quote!(.with_flags(#godot_types::global::MethodFlags::STATIC))
             } else {
-                quote!(#godot_types::global::MethodFlags::NORMAL)
+                TokenStream::new()
             };
 
             let description = fnc.attrs.iter()
@@ -128,32 +128,38 @@ pub fn godot_script_impl(
 
             let metadata = quote_spanned! {
                 fnc.span() =>
-                ::godot_rust_script::private_export::RustScriptMethodDesc {
-                    name: #fn_name_str,
-                    arguments: Box::new([#args_meta]),
-                    return_type: ::godot_rust_script::private_export::RustScriptPropDesc {
-                        name: #fn_name_str,
-                        ty: #fn_return_ty,
-                        class_name: <<#fn_return_ty_rust as #godot_types::meta::GodotConvert>::Via as #godot_types::meta::GodotType>::class_id(),
-                        usage: #godot_types::global::PropertyUsageFlags::NONE,
-                        hint: #property_hints::NONE,
-                        hint_string: String::new(),
-                        description: "",
-                    },
-                    flags: #method_flag,
-                    description: concat!(#description),
-                },
+                methods.add_method(
+                    ::godot_rust_script::private_export::RustScriptMethodDesc::builder(
+                        #fn_name_str,
+                        Box::new([#args_meta]),
+                        ::godot_rust_script::private_export::RustScriptPropDesc {
+                            name: #fn_name_str,
+                            ty: #fn_return_ty,
+                            class_name: <<#fn_return_ty_rust as #godot_types::meta::GodotConvert>::Via as #godot_types::meta::GodotType>::class_id(),
+                            usage: #godot_types::global::PropertyUsageFlags::NONE,
+                            hint: #property_hints::NONE,
+                            hint_string: String::new(),
+                            description: "",
+                        },
+                    )
+                    .with_description(concat!(#description))
+                    #method_flag
+                );
             };
 
             Ok((dispatch, metadata))
         })
         .collect();
 
-    let (method_dispatch, method_metadata): (TokenStream, TokenStream) = match result {
-        Ok(r) => r.into_iter().unzip(),
+    let method_list = match result {
+        Ok(r) => r,
         Err(err) => return err,
     };
 
+    let method_count = method_list.len();
+    let (method_dispatch, method_metadata): (TokenStream, TokenStream) =
+        method_list.into_iter().unzip();
+
     let trait_impl = quote_spanned! {
         current_type.span() =>
         impl ::godot_rust_script::GodotScriptImpl for #current_type {
@@ -173,9 +179,10 @@ pub fn godot_script_impl(
     let metadata = quote! {
         ::godot_rust_script::register_script_methods!(
             #current_type,
-            vec![
+            #method_count,
+            methods => {
                 #method_metadata
-            ]
+            }
         );
     };
 
diff --git a/rust-script/src/interface.rs b/rust-script/src/interface.rs
index e2f0bed..f7187d4 100644
--- a/rust-script/src/interface.rs
+++ b/rust-script/src/interface.rs
@@ -213,7 +213,7 @@ impl<T: GodotScript, B: Inherits<T::Base> + Inherits<Object>> CastToScript<T> fo
 
 /// Script property access indirection
 ///
-/// gdext uses this kind of indirection to allow conversion of the actual property value into a godot compatible type when accessing the
+/// Gdext uses this kind of indirection to allow conversion of the actual property value into a Godot compatible type when accessing the
 /// property from the engine. This Trait separates the `::godot::prelude::Var` trait into it's get and set components for more granular
 /// requirements on the property types.
 pub trait GetScriptProperty: GodotConvert {
@@ -222,7 +222,7 @@ pub trait GetScriptProperty: GodotConvert {
 
 /// Script property write indirection
 ///
-/// gdext uses this kind of indirection to allow conversion of the actual property value from a godot compatible type when setting the
+/// Gdext uses this kind of indirection to allow conversion of the actual property value from a Godot compatible type when setting the
 /// property from the engine. This Trait separates the `::godot::prelude::Var` trait into it's get and set components for more granular
 /// requirements on the property types.
 pub trait SetScriptProperty: GodotConvert {
diff --git a/rust-script/src/runtime/metadata.rs b/rust-script/src/runtime/metadata.rs
index 03985ba..810a092 100644
--- a/rust-script/src/runtime/metadata.rs
+++ b/rust-script/src/runtime/metadata.rs
@@ -140,8 +140,8 @@ pub struct Documented<T> {
     description: &'static str,
 }
 
-impl From<crate::static_script_registry::RustScriptPropertyInfo> for Documented<PropertyInfo> {
-    fn from(value: crate::static_script_registry::RustScriptPropertyInfo) -> Self {
+impl From<crate::static_script_registry::RustScriptPropDesc> for Documented<PropertyInfo> {
+    fn from(value: crate::static_script_registry::RustScriptPropDesc) -> Self {
         Self {
             description: value.description,
             inner: (&value).into(),
@@ -149,17 +149,17 @@ impl From<crate::static_script_registry::RustScriptPropertyInfo> for Documented<
     }
 }
 
-impl From<crate::static_script_registry::RustScriptMethodInfo> for Documented<MethodInfo> {
-    fn from(value: crate::static_script_registry::RustScriptMethodInfo) -> Self {
+impl From<crate::static_script_registry::RustScriptMethodDesc> for Documented<MethodInfo> {
+    fn from(value: crate::static_script_registry::RustScriptMethodDesc) -> Self {
         Self {
             description: value.description,
-            inner: (&value).into(),
+            inner: value.into(),
         }
     }
 }
 
-impl From<crate::static_script_registry::RustScriptSignalInfo> for Documented<MethodInfo> {
-    fn from(value: crate::static_script_registry::RustScriptSignalInfo) -> Self {
+impl From<crate::static_script_registry::RustScriptSignalDesc> for Documented<MethodInfo> {
+    fn from(value: crate::static_script_registry::RustScriptSignalDesc) -> Self {
         Self {
             description: value.description,
             inner: (&value).into(),
diff --git a/rust-script/src/runtime/rust_script.rs b/rust-script/src/runtime/rust_script.rs
index 0cdc09e..cfcd8e0 100644
--- a/rust-script/src/runtime/rust_script.rs
+++ b/rust-script/src/runtime/rust_script.rs
@@ -20,7 +20,7 @@ use godot::prelude::{
 };
 
 use crate::apply::Apply;
-use crate::static_script_registry::RustScriptPropertyInfo;
+use crate::private_export::RustScriptPropDesc;
 
 use super::rust_script_instance::GodotScriptObject;
 use super::{
@@ -39,7 +39,7 @@ pub(crate) struct RustScript {
     #[var(get = get_class_name, set = set_class_name, usage_flags = [STORAGE])]
     class_name: GString,
 
-    /// dummy property that stores the onwer ids when the extension gets reloaded by the engine.
+    /// Dummy property that stores the owner ids when the extension gets reloaded by the engine.
     #[var( get = owner_ids, set = set_owner_ids, usage_flags = [STORAGE])]
     #[allow(dead_code)]
     owner_ids: Array<i64>,
@@ -94,7 +94,7 @@ impl RustScript {
     #[func]
     fn set_owner_ids(&mut self, ids: Array<i64>) {
         if ids.is_empty() {
-            // ignore empty owners list from engine
+            // Ignore empty owners list from engine
             return;
         }
 
@@ -133,7 +133,7 @@ impl RustScript {
         base.call("_init", &[]);
     }
 
-    fn map_property_info_list<R>(&self, f: impl Fn(&RustScriptPropertyInfo) -> R) -> Vec<R> {
+    fn map_property_info_list<R>(&self, f: impl Fn(&RustScriptPropDesc) -> R) -> Vec<R> {
         let reg = SCRIPT_REGISTRY.read().expect("unable to obtain read lock");
 
         reg.get(&self.str_class_name())
@@ -218,44 +218,48 @@ impl IScriptExtension for RustScript {
     }
 
     fn has_property_default_value(&self, _property: StringName) -> bool {
-        // default values are currently not exposed
+        // Default values are currently not exposed
         false
     }
 
     fn get_property_default_value(&self, #[expect(unused)] property: StringName) -> Variant {
-        // default values are currently not exposed
+        // Default values are currently not exposed
         Variant::nil()
     }
 
     fn get_script_signal_list(&self) -> Array<VarDictionary> {
-        let Some(script) = RustScriptLanguage::script_meta_data(&self.str_class_name()) else {
-            godot_error!(
-                "RustScript class {} does not exist in compiled dynamic library!",
-                self.str_class_name()
-            );
-            return Array::new();
-        };
+        RustScriptLanguage::with_script_metadata(&self.str_class_name(), |script_data| {
+            let Some(script) = script_data else {
+                godot_error!(
+                    "RustScript class {} does not exist in compiled dynamic library!",
+                    self.str_class_name()
+                );
+                return Array::new();
+            };
 
-        script
-            .signals()
-            .iter()
-            .map(|signal| MethodInfo::from(signal).to_dict())
-            .collect()
+            script
+                .signals()
+                .iter()
+                .map(|signal| MethodInfo::from(signal).to_dict())
+                .collect()
+        })
     }
 
     fn has_script_signal(&self, name: StringName) -> bool {
-        let Some(script) = RustScriptLanguage::script_meta_data(&self.str_class_name()) else {
-            godot_error!(
-                "RustScript class {} does not exist in compiled dynamic library!",
-                self.str_class_name()
-            );
-            return false;
-        };
+        RustScriptLanguage::with_script_metadata(&self.str_class_name(), |script_data| {
+            let Some(script) = script_data else {
+                godot_error!(
+                    "RustScript class {} does not exist in compiled dynamic library!",
+                    self.str_class_name()
+                );
+                return false;
+            };
 
-        script
-            .signals()
-            .iter()
-            .any(|signal| signal.name == name.to_string())
+            script
+                .signals()
+                .iter()
+                .any(|signal| signal.name == name.to_string())
+        })
     }
 
     fn update_exports(&mut self) {}
@@ -268,7 +272,7 @@ impl IScriptExtension for RustScript {
                 class
                     .methods()
                     .iter()
-                    .map(|method| MethodInfo::from(method).to_dict())
+                    .map(|method| MethodInfo::from(method.clone()).to_dict())
                     .collect()
             })
             .unwrap_or_default()
@@ -295,7 +299,7 @@ impl IScriptExtension for RustScript {
             class
                 .methods()
                 .iter()
-                .any(|method| method.method_name == method_name.to_string())
+                .any(|method| method.name == method_name.to_string())
         })
     }
 
@@ -310,8 +314,8 @@ impl IScriptExtension for RustScript {
                 class
                     .methods()
                     .iter()
-                    .find(|method| method.method_name == method_name.to_string())
-                    .map(|method| MethodInfo::from(method).to_dict())
+                    .find(|method| method.name == method_name.to_string())
+                    .map(|method| MethodInfo::from(method.clone()).to_dict())
             })
             .unwrap_or_default()
     }
@@ -386,10 +390,10 @@ impl IScriptExtension for RustScript {
         true
     }
 
-    // godot script reload hook
+    // Godot script reload hook
     fn reload(
         &mut self,
-        // before 4.4 the engine does not correctly pass the keep_state flag
+        // Before 4.4 the engine does not correctly pass the keep_state flag
         #[cfg_attr(before_api = "4.4", expect(unused_variables))] keep_state: bool,
     ) -> godot::global::Error {
         #[cfg(before_api = "4.4")]
@@ -398,7 +402,9 @@ impl IScriptExtension for RustScript {
         let owners = self.owners.borrow().clone();
         let exported_properties_list = if keep_state {
             self.map_property_info_list(|prop| {
-                (prop.usage & PropertyUsageFlags::EDITOR.ord() != 0).then_some(prop.property_name)
+                (prop.usage.ord() & PropertyUsageFlags::EDITOR.ord()
+                    != PropertyUsageFlags::NONE.ord())
+                .then_some(prop.name)
             })
         } else {
             Vec::with_capacity(0)
@@ -427,7 +433,7 @@ impl IScriptExtension for RustScript {
                 Vec::with_capacity(0)
             };
 
-            // clear script to destroy script instance.
+            // Clear script to destroy script instance.
             object.set_script(Option::<&Gd<Script>>::None);
 
             self.downgrade_gd(|self_gd| {
@@ -497,7 +503,7 @@ impl IScriptExtension for RustScript {
                 class
                     .properties()
                     .iter()
-                    .map(|prop| StringName::from(prop.property_name))
+                    .map(|prop| StringName::from(prop.name))
                     .collect()
             })
             .unwrap_or_default()
diff --git a/rust-script/src/runtime/rust_script_instance.rs b/rust-script/src/runtime/rust_script_instance.rs
index f1aba19..a2b9567 100644
--- a/rust-script/src/runtime/rust_script_instance.rs
+++ b/rust-script/src/runtime/rust_script_instance.rs
@@ -27,7 +27,13 @@ fn script_method_list(script: &Gd<RustScript>) -> Box<[MethodInfo]> {
         .read()
         .expect("script registry is inaccessible")
         .get(&class_name)
-        .map(|meta| meta.methods().iter().map(MethodInfo::from).collect())
+        .map(|meta| {
+            meta.methods()
+                .iter()
+                .cloned()
+                .map(MethodInfo::from)
+                .collect()
+        })
         .unwrap_or_else(|| Box::new([]) as Box<[MethodInfo]>);
 
     methods
diff --git a/rust-script/src/runtime/rust_script_language.rs b/rust-script/src/runtime/rust_script_language.rs
index ead2a49..fc4573c 100644
--- a/rust-script/src/runtime/rust_script_language.rs
+++ b/rust-script/src/runtime/rust_script_language.rs
@@ -62,12 +62,14 @@ impl RustScriptLanguage {
             .map(|gd| gd.cast())
     }
 
-    pub fn script_meta_data(class_name: &str) -> Option<RustScriptMetaData> {
-        let reg = SCRIPT_REGISTRY
-            .read()
-            .expect("unable to obtain read access");
+    #[inline]
+    pub fn with_script_metadata<R>(
+        class_name: &str,
+        lambda: impl FnOnce(Option<&RustScriptMetaData>) -> R,
+    ) -> R {
+        let reg = SCRIPT_REGISTRY.read().expect("registry is poisoned");
 
-        reg.get(class_name).map(ToOwned::to_owned)
+        lambda(reg.get(class_name))
     }
 }
 
@@ -89,10 +91,10 @@ impl IScriptLanguageExtension for RustScriptLanguage {
         true
     }
 
-    /// thread enter hook will be called before entering a thread
+    /// Thread enter hook will be called before entering a thread
     fn thread_enter(&mut self) {}
 
-    /// thread exit hook will be called before leaving a thread
+    /// Thread exit hook will be called before leaving a thread
     fn thread_exit(&mut self) {}
 
     fn get_public_functions(&self) -> Array<VarDictionary> {
@@ -184,13 +186,15 @@ impl IScriptLanguageExtension for RustScriptLanguage {
     fn get_global_class_name(&self, path: GString) -> VarDictionary {
         let class_name = Self::path_to_class_name(&path);
 
-        let Some(script) = Self::script_meta_data(&class_name) else {
-            return VarDictionary::new();
-        };
+        Self::with_script_metadata(&class_name, |script_data| {
+            let Some(script) = script_data else {
+                return VarDictionary::new();
+            };
 
-        VarDictionary::new().apply(|dict| {
-            dict.set("name", class_name);
-            dict.set("base_type", script.base_type_name());
+            VarDictionary::new().apply(|dict| {
+                dict.set("name", &*class_name);
+                dict.set("base_type", script.base_type_name());
+            })
         })
     }
 
@@ -204,7 +208,7 @@ impl IScriptLanguageExtension for RustScriptLanguage {
         _line: i32,
         _col: i32,
     ) -> global::Error {
-        // TODO: From Godot 4.4 we can show an editor toast here. Just waiting for a new gdext release.
+        // TODO: From Godot 4.4 we can show an editor toast here. Just waiting for a new Gdext release.
         godot_error!("Editing rust scripts from inside Godot is currently not supported.");
 
         global::Error::OK
diff --git a/rust-script/src/static_script_registry.rs b/rust-script/src/static_script_registry.rs
index e785b4d..24abfbd 100644
--- a/rust-script/src/static_script_registry.rs
+++ b/rust-script/src/static_script_registry.rs
@@ -12,7 +12,6 @@ use std::sync::{Arc, LazyLock, RwLock};
 use godot::builtin::{GString, StringName};
 use godot::global::{MethodFlags, PropertyHint, PropertyUsageFlags};
 use godot::meta::{ClassId, MethodInfo, PropertyHintInfo, PropertyInfo, ToGodot};
-use godot::obj::{EngineBitfield, EngineEnum};
 use godot::prelude::{Gd, Object};
 use godot::sys::VariantType;
 
@@ -45,14 +44,15 @@ macro_rules! register_script_class {
 
 #[macro_export]
 macro_rules! register_script_methods {
-    ($class_name:ty, $methods:expr) => {
+    ($class_name:ty, $method_capacity:literal, $builder:ident => $methods:tt) => {
         $crate::private_export::plugin_add! {
             $crate::private_export::SCRIPT_REGISTRY ;
-            $crate::private_export::RegistryItem::Methods($crate::private_export::RustScriptEntryMethods {
-                class_name: stringify!($class_name),
-                methods: || {
-                    $methods
-                },
+            $crate::private_export::RegistryItem::Methods(|| {
+                let mut $builder = $crate::private_export::RustScriptEntryMethods::builder(stringify!($class_name), $method_capacity);
+
+                $methods
+
+                $builder.build()
             })
         }
     };
@@ -70,16 +70,46 @@ pub struct RustScriptEntry {
 
 #[derive(Debug)]
 pub struct RustScriptEntryMethods {
-    pub class_name: &'static str,
-    pub methods: fn() -> Vec<RustScriptMethodDesc>,
+    class_name: &'static str,
+    methods: Box<[RustScriptMethodDesc]>,
+}
+
+impl RustScriptEntryMethods {
+    pub fn builder(class_name: &'static str, capacity: usize) -> RustScriptEntryMethodsBuilder {
+        RustScriptEntryMethodsBuilder {
+            class_name,
+            methods: Vec::with_capacity(capacity),
+        }
+    }
+}
+
+pub struct RustScriptEntryMethodsBuilder {
+    class_name: &'static str,
+    methods: Vec<RustScriptMethodDesc>,
+}
+
+impl RustScriptEntryMethodsBuilder {
+    pub fn add_method(&mut self, method: RustScriptMethodDescBuilder) {
+        let index = self.methods.len();
+
+        self.methods
+            .push(method.build(index as u32, self.class_name));
+    }
+
+    pub fn build(self) -> RustScriptEntryMethods {
+        RustScriptEntryMethods {
+            class_name: self.class_name,
+            methods: self.methods.into(),
+        }
+    }
 }
 
 pub enum RegistryItem {
     Entry(RustScriptEntry),
-    Methods(RustScriptEntryMethods),
+    Methods(fn() -> RustScriptEntryMethods),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct RustScriptPropDesc {
     pub name: &'static str,
     pub ty: VariantType,
@@ -90,72 +120,72 @@ pub struct RustScriptPropDesc {
     pub description: &'static str,
 }
 
-impl RustScriptPropDesc {
-    pub fn to_property_info(&self) -> RustScriptPropertyInfo {
-        RustScriptPropertyInfo {
-            variant_type: self.ty,
-            class_name: self.class_name,
-            property_name: self.name,
-            usage: self.usage.ord(),
-            hint: self.hint.ord(),
-            hint_string: self.hint_string.clone(),
-            description: self.description,
+#[derive(Debug, Clone)]
+pub struct RustScriptMethodDesc {
+    pub(crate) id: u32,
+    pub(crate) class_name: &'static str,
+    pub(crate) name: &'static str,
+    pub(crate) return_type: RustScriptPropDesc,
+    pub(crate) arguments: Box<[RustScriptPropDesc]>,
+    pub(crate) flags: MethodFlags,
+    pub(crate) description: &'static str,
+}
+
+impl RustScriptMethodDesc {
+    pub fn builder(
+        name: &'static str,
+        arguments: Box<[RustScriptPropDesc]>,
+        return_type: RustScriptPropDesc,
+    ) -> RustScriptMethodDescBuilder {
+        RustScriptMethodDescBuilder {
+            name,
+            return_type,
+            arguments,
+            flags: MethodFlags::NORMAL,
+            description: Default::default(),
         }
     }
 }
 
-pub struct RustScriptMethodDesc {
-    pub name: &'static str,
-    pub return_type: RustScriptPropDesc,
-    pub arguments: Box<[RustScriptPropDesc]>,
-    pub flags: MethodFlags,
-    pub description: &'static str,
+pub struct RustScriptMethodDescBuilder {
+    name: &'static str,
+    return_type: RustScriptPropDesc,
+    arguments: Box<[RustScriptPropDesc]>,
+    flags: MethodFlags,
+    description: &'static str,
 }
 
-impl RustScriptMethodDesc {
-    pub fn into_method_info(
-        self,
-        id: i32,
-        class_name: &'static str,
-        class_name_cstr: &'static std::ffi::CStr,
-    ) -> RustScriptMethodInfo {
-        RustScriptMethodInfo {
+impl RustScriptMethodDescBuilder {
+    pub fn with_flags(mut self, flags: MethodFlags) -> Self {
+        self.flags = flags;
+        self
+    }
+
+    pub fn with_description(mut self, description: &'static str) -> Self {
+        self.description = description;
+        self
+    }
+
+    pub fn build(self, id: u32, class_name: &'static str) -> RustScriptMethodDesc {
+        RustScriptMethodDesc {
             id,
-            method_name: self.name,
             class_name,
-            class_name_cstr,
-            return_type: self.return_type.to_property_info(),
-            flags: self.flags.ord(),
-            arguments: self
-                .arguments
-                .iter()
-                .map(|arg| arg.to_property_info())
-                .collect(),
+            name: self.name,
+            return_type: self.return_type,
+            arguments: self.arguments,
+            flags: self.flags,
             description: self.description,
         }
     }
 }
 
+#[derive(Debug, Clone)]
 pub struct RustScriptSignalDesc {
     pub name: &'static str,
     pub arguments: Box<[RustScriptPropDesc]>,
     pub description: &'static str,
 }
 
-impl From<RustScriptSignalDesc> for RustScriptSignalInfo {
-    fn from(value: RustScriptSignalDesc) -> Self {
-        Self {
-            name: value.name,
-            arguments: value
-                .arguments
-                .iter()
-                .map(|arg| arg.to_property_info())
-                .collect(),
-            description: value.description,
-        }
-    }
-}
-
 pub fn create_default_data_struct<T: GodotScript + GodotScriptObject + 'static>(
     base: Gd<Object>,
 ) -> Box<dyn GodotScriptObject> {
@@ -168,7 +198,11 @@ pub fn assemble_metadata<'a>(
     let (entries, methods): (Vec<_>, Vec<_>) = items
         .map(|item| match item {
             RegistryItem::Entry(entry) => (Some(entry), None),
-            RegistryItem::Methods(methods) => (None, Some((methods.class_name, methods))),
+            RegistryItem::Methods(methods) => {
+                let methods = methods();
+
+                (None, Some((methods.class_name, methods)))
+            }
         })
         .unzip();
 
@@ -178,26 +212,15 @@ pub fn assemble_metadata<'a>(
         .into_iter()
         .flatten()
         .map(|class| {
-            let props = (class.properties)()
-                .into_iter()
-                .map(|prop| prop.to_property_info())
-                .collect();
+            let props = (class.properties)().into();
 
             let methods = methods
                 .get(class.class_name)
                 .into_iter()
-                .flat_map(|entry| (entry.methods)())
-                .enumerate()
-                .map(|(index, method)| {
-                    method.into_method_info(
-                        (index + 1) as i32,
-                        class.class_name,
-                        class.class_name_cstr,
-                    )
-                })
+                .flat_map(|entry| entry.methods.clone())
                 .collect();
 
-            let signals = (class.signals)().into_iter().map(Into::into).collect();
+            let signals = (class.signals)().into();
 
             let create_data: Box<dyn CreateScriptInstanceData> = Box::new(class.create_data);
             let description = class.description;
@@ -215,70 +238,23 @@ pub fn assemble_metadata<'a>(
         .collect()
 }
 
-#[derive(Debug, Clone)]
-#[repr(C)]
-pub struct RustScriptPropertyInfo {
-    pub variant_type: VariantType,
-    pub property_name: &'static str,
-    pub class_name: ClassId,
-    pub hint: i32,
-    pub hint_string: String,
-    pub usage: u64,
-    pub description: &'static str,
-}
-
-impl From<&RustScriptPropertyInfo> for PropertyInfo {
-    fn from(value: &RustScriptPropertyInfo) -> Self {
+impl From<&RustScriptPropDesc> for PropertyInfo {
+    fn from(value: &RustScriptPropDesc) -> Self {
         Self {
-            variant_type: value.variant_type,
-            property_name: value.property_name.into(),
+            variant_type: value.ty,
+            property_name: value.name.into(),
             class_id: value.class_name,
             hint_info: PropertyHintInfo {
-                hint: PropertyHint::try_from_ord(value.hint).unwrap_or(PropertyHint::NONE),
+                hint: value.hint,
                 hint_string: value.hint_string.to_godot(),
             },
-            usage: PropertyUsageFlags::try_from_ord(value.usage)
-                .unwrap_or(PropertyUsageFlags::NONE),
+            usage: value.usage,
         }
     }
 }
 
-#[derive(Debug, Clone)]
-#[repr(C)]
-pub struct RustScriptMethodInfo {
-    pub id: i32,
-    pub method_name: &'static str,
-    pub class_name: &'static str,
-    pub class_name_cstr: &'static std::ffi::CStr,
-    pub return_type: RustScriptPropertyInfo,
-    pub arguments: Box<[RustScriptPropertyInfo]>,
-    pub flags: u64,
-    pub description: &'static str,
-}
-
-impl From<&RustScriptMethodInfo> for MethodInfo {
-    fn from(value: &RustScriptMethodInfo) -> Self {
-        Self {
-            id: value.id,
-            method_name: value.method_name.into(),
-            class_name: get_class_id(value.class_name),
-            return_type: (&value.return_type).into(),
-            arguments: value.arguments.iter().map(|arg| arg.into()).collect(),
-            default_arguments: vec![],
-            flags: MethodFlags::try_from_ord(value.flags).unwrap_or(MethodFlags::DEFAULT),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct RustScriptSignalInfo {
-    pub name: &'static str,
-    pub arguments: Box<[RustScriptPropertyInfo]>,
-    pub description: &'static str,
-}
-
-impl From<&RustScriptSignalInfo> for MethodInfo {
-    fn from(value: &RustScriptSignalInfo) -> Self {
+impl From<&RustScriptSignalDesc> for MethodInfo {
+    fn from(value: &RustScriptSignalDesc) -> Self {
         Self {
             id: 0,
             method_name: value.name.into(),
@@ -300,13 +276,30 @@ impl From<&RustScriptSignalInfo> for MethodInfo {
     }
 }
 
-#[derive(Debug, Clone)]
+impl From<RustScriptMethodDesc> for MethodInfo {
+    fn from(value: RustScriptMethodDesc) -> Self {
+        Self {
+            id: value
+                .id
+                .try_into()
+                .expect("method index should fit into i32"),
+            method_name: value.name.into(),
+            class_name: get_class_id(value.class_name),
+            return_type: (&value.return_type).into(),
+            flags: value.flags,
+            arguments: value.arguments.iter().map(|arg| arg.into()).collect(),
+            default_arguments: Vec::with_capacity(0),
+        }
+    }
+}
+
+#[derive(Debug)]
 pub struct RustScriptMetaData {
     pub(crate) class_name: ClassId,
     pub(crate) base_type_name: StringName,
-    pub(crate) properties: Box<[RustScriptPropertyInfo]>,
-    pub(crate) methods: Box<[RustScriptMethodInfo]>,
-    pub(crate) signals: Box<[RustScriptSignalInfo]>,
+    pub(crate) properties: Box<[RustScriptPropDesc]>,
+    pub(crate) methods: Box<[RustScriptMethodDesc]>,
+    pub(crate) signals: Box<[RustScriptSignalDesc]>,
     pub(crate) create_data: Arc<dyn CreateScriptInstanceData>,
     pub(crate) description: &'static str,
 }
@@ -315,9 +308,9 @@ impl RustScriptMetaData {
     pub fn new(
         class_name: &'static str,
         base_type_name: StringName,
-        properties: Box<[RustScriptPropertyInfo]>,
-        methods: Box<[RustScriptMethodInfo]>,
-        signals: Box<[RustScriptSignalInfo]>,
+        properties: Box<[RustScriptPropDesc]>,
+        methods: Box<[RustScriptMethodDesc]>,
+        signals: Box<[RustScriptSignalDesc]>,
         create_data: Box<dyn CreateScriptInstanceData>,
         description: &'static str,
     ) -> Self {
@@ -347,15 +340,15 @@ impl RustScriptMetaData {
         self.create_data.create(base)
     }
 
-    pub fn properties(&self) -> &[RustScriptPropertyInfo] {
+    pub fn properties(&self) -> &[RustScriptPropDesc] {
         &self.properties
     }
 
-    pub fn methods(&self) -> &[RustScriptMethodInfo] {
+    pub fn methods(&self) -> &[RustScriptMethodDesc] {
         &self.methods
     }
 
-    pub fn signals(&self) -> &[RustScriptSignalInfo] {
+    pub fn signals(&self) -> &[RustScriptSignalDesc] {
         &self.signals
     }
 
@@ -394,9 +387,14 @@ fn get_class_id(class_name: &'static str) -> ClassId {
 
 #[cfg(test)]
 mod tests {
-    use godot::meta::ClassId;
+    use godot::global::PropertyHint;
+    use godot::global::PropertyUsageFlags;
+    use godot::{meta::ClassId, sys::VariantType};
 
-    use crate::static_script_registry::get_class_id;
+    use crate::{
+        private_export::{RustScriptEntryMethods, RustScriptMethodDesc},
+        static_script_registry::get_class_id,
+    };
 
     #[test]
     fn new_class_name() {
@@ -420,4 +418,29 @@ mod tests {
 
         assert_eq!(script_name_a, script_name_b);
     }
+
+    #[test]
+    fn build_method_list() {
+        let mut builder = RustScriptEntryMethods::builder("TestClass", 4);
+
+        builder.add_method(RustScriptMethodDesc::builder(
+            "add_member",
+            Box::new([]),
+            super::RustScriptPropDesc {
+                name: "",
+                ty: VariantType::BOOL,
+                class_name: get_class_id("Node"),
+                usage: PropertyUsageFlags::NONE,
+                hint: PropertyHint::NONE,
+                hint_string: String::from(""),
+                description: "",
+            },
+        ));
+
+        let entry = builder.build();
+
+        assert_eq!(entry.methods[0].class_name, "TestClass");
+        assert_eq!(entry.methods[0].name, "add_member");
+        assert_eq!(entry.methods[0].return_type.ty, VariantType::BOOL);
+    }
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 27a3b98..8c04334 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "1.87.0"
+channel = "1.91.0"
 components = [ "rustfmt", "clippy" ]
 profile = "default"