From c0119037d32b3122a93e884558669bccc1f369b2 Mon Sep 17 00:00:00 2001
From: Chris Cranford <chris@hibernate.org>
Date: Fri, 19 Jul 2024 19:29:28 -0400
Subject: [PATCH] GH-537 Fix target resolution

* Resolves methods, properties, and signals on nodes & scripts
* Correctly assigns target types for global class types
* Excludes private properties, prefixed with `_`
* Excludes internal methods, prefixed with `@`
* Reworks method/properties/signals for global classes
---
 src/common/method_utils.cpp                   |  66 +-
 src/common/method_utils.h                     |   5 +
 src/common/scene_utils.cpp                    |  11 +
 src/editor/graph/actions/action_menu.cpp      |   4 +-
 .../actions/default_action_registrar.cpp      | 580 ++++++++++--------
 .../graph/actions/default_action_registrar.h  | 101 ++-
 src/editor/graph/graph_edit.cpp               |   8 +-
 src/editor/graph/graph_node.cpp               |   2 +-
 src/editor/graph/graph_node_pin.cpp           |   4 +-
 src/editor/graph/graph_node_spawner.h         |   8 +-
 .../graph/pins/graph_node_pin_object.cpp      |   2 +-
 src/script/node_pin.cpp                       |   5 +
 src/script/nodes/functions/call_function.cpp  |  19 +-
 .../nodes/functions/call_member_function.cpp  |   8 +-
 .../nodes/functions/call_static_function.cpp  |   8 +-
 src/script/nodes/properties/property.cpp      |  76 ++-
 src/script/nodes/properties/property.h        |  10 +
 src/script/nodes/properties/property_get.cpp  |  12 +-
 src/script/nodes/properties/property_set.cpp  |   8 +-
 .../nodes/utilities/engine_singleton.cpp      |   2 +-
 src/script/script.cpp                         |   2 +-
 src/script/script_server.cpp                  | 158 +++++
 src/script/script_server.h                    | 101 +++
 23 files changed, 869 insertions(+), 331 deletions(-)
 create mode 100644 src/script/script_server.cpp
 create mode 100644 src/script/script_server.h

diff --git a/src/common/method_utils.cpp b/src/common/method_utils.cpp
index 6868ffb0..2046779d 100644
--- a/src/common/method_utils.cpp
+++ b/src/common/method_utils.cpp
@@ -16,6 +16,10 @@
 //
 #include "common/method_utils.h"
 
+#include "dictionary_utils.h"
+#include "property_utils.h"
+#include "script/script_server.h"
+
 #include <godot_cpp/core/class_db.hpp>
 
 namespace MethodUtils
@@ -60,7 +64,12 @@ namespace MethodUtils
         String class_name = p_class_name;
         while (!class_name.is_empty())
         {
-            TypedArray<Dictionary> methods = ClassDB::class_get_method_list(class_name, true);
+            TypedArray<Dictionary> methods;
+            if (ScriptServer::is_global_class(p_class_name))
+                methods = ScriptServer::get_global_class(p_class_name).get_method_list();
+            else
+                ClassDB::class_get_method_list(class_name, true);
+
             for (int i = 0; i < methods.size(); i++)
             {
                 const Dictionary& method = methods[i];
@@ -71,4 +80,59 @@ namespace MethodUtils
         }
         return {};
     }
+
+    String get_signature(const MethodInfo& p_method)
+    {
+        String signature = p_method.name.replace("_", " ").capitalize() + "\n\n";
+
+        if (MethodUtils::has_return_value(p_method))
+        {
+            if (PropertyUtils::is_variant(p_method.return_val))
+                signature += "Variant";
+            else if (p_method.return_val.hint == PROPERTY_HINT_ARRAY_TYPE)
+                signature += "Array[" + p_method.return_val.hint_string + "]";
+            else
+                signature += Variant::get_type_name(p_method.return_val.type);
+        }
+        else
+            signature += "void";
+
+        signature += " " + p_method.name + " (";
+
+        int index = 0;
+        for (const PropertyInfo& property : p_method.arguments)
+        {
+            if (!signature.ends_with("("))
+                signature += ", ";
+
+            if (property.name.is_empty())
+                signature += "p" + itos(index++);
+            else
+                signature += property.name;
+
+            signature += ":" + PropertyUtils::get_property_type_name(property);
+        }
+
+        if (p_method.flags & METHOD_FLAG_VARARG)
+        {
+            if (!p_method.arguments.empty())
+                signature += ", ";
+            signature += "...";
+        }
+
+        signature += ")";
+
+        if (p_method.flags & METHOD_FLAG_CONST)
+            signature += " const";
+        else if (p_method.flags & METHOD_FLAG_VIRTUAL)
+            signature += " virtual";
+
+        #if DEBUG_ENABLED
+        signature += "\n\n";
+        signature += vformat("%s", DictionaryUtils::from_method(p_method));
+        #endif
+
+        return signature;
+    }
+
 }
\ No newline at end of file
diff --git a/src/common/method_utils.h b/src/common/method_utils.h
index 7031b8dd..9cbb2174 100644
--- a/src/common/method_utils.h
+++ b/src/common/method_utils.h
@@ -45,6 +45,11 @@ namespace MethodUtils
     /// @param p_method_name the name of the method to search for
     /// @return the class that contains the method, or an empty string if the method is not found
     String get_method_class(const String& p_class_name, const String& p_method_name);
+
+    /// Generates a method signature based on the specified method.
+    /// @param p_method the method
+    /// @return the signature
+    String get_signature(const MethodInfo& p_method);
 }
 
 #endif // ORCHESTRATOR_METHOD_UTILS_H
\ No newline at end of file
diff --git a/src/common/scene_utils.cpp b/src/common/scene_utils.cpp
index 8c25b557..72551992 100644
--- a/src/common/scene_utils.cpp
+++ b/src/common/scene_utils.cpp
@@ -17,11 +17,13 @@
 #include "scene_utils.h"
 
 #include "editor/plugins/orchestrator_editor_plugin.h"
+#include "script/script_server.h"
 
 #include <godot_cpp/classes/editor_interface.hpp>
 #include <godot_cpp/classes/engine.hpp>
 #include <godot_cpp/classes/font.hpp>
 #include <godot_cpp/classes/label.hpp>
+#include <godot_cpp/classes/resource_loader.hpp>
 #include <godot_cpp/classes/scene_tree.hpp>
 #include <godot_cpp/classes/style_box.hpp>
 #include <godot_cpp/classes/theme.hpp>
@@ -50,6 +52,15 @@ namespace SceneUtils
             return vbox->get_theme_icon(instantiable ? "Object" : "ObjectDisabled", "EditorIcons");
         }
 
+        if (ScriptServer::is_global_class(p_class_name))
+        {
+            const String icon = ScriptServer::get_global_class(p_class_name).icon_path;
+            if (!icon.is_empty())
+                return ResourceLoader::get_singleton()->load(icon);
+
+            return get_class_icon(ScriptServer::get_native_class_name(p_class_name));
+        }
+
         return nullptr;
     }
 
diff --git a/src/editor/graph/actions/action_menu.cpp b/src/editor/graph/actions/action_menu.cpp
index 0b650522..588ca8c7 100644
--- a/src/editor/graph/actions/action_menu.cpp
+++ b/src/editor/graph/actions/action_menu.cpp
@@ -338,7 +338,7 @@ TreeItem* OrchestratorGraphActionMenu::_make_item(TreeItem* p_parent,
     TreeItem* child = p_parent->create_child();
     child->set_text(0, p_text);
     child->set_expand_right(0, true);
-    child->set_icon(0, SceneUtils::get_editor_icon(p_menu_item->get_spec().icon));
+    child->set_icon(0, SceneUtils::get_class_icon(p_menu_item->get_spec().icon));
     child->set_tooltip_text(0, p_menu_item->get_spec().tooltip);
     child->set_selectable(0, p_menu_item->get_handler().is_valid());
 
@@ -450,6 +450,8 @@ void OrchestratorGraphActionMenu::_on_filter_text_changed(const String& p_new_te
     // Update filters
     _filter.keywords.clear();
 
+    _on_expand_tree(true);
+
     const String filter_text = p_new_text.trim_prefix(" ").trim_suffix(" ");
     if (!filter_text.is_empty())
         for (const String& element : filter_text.split(" "))
diff --git a/src/editor/graph/actions/default_action_registrar.cpp b/src/editor/graph/actions/default_action_registrar.cpp
index aec0a7c6..191abad4 100644
--- a/src/editor/graph/actions/default_action_registrar.cpp
+++ b/src/editor/graph/actions/default_action_registrar.cpp
@@ -25,16 +25,16 @@
 #include "common/variant_utils.h"
 #include "editor/graph/graph_edit.h"
 #include "editor/graph/graph_node_spawner.h"
+#include "godot_cpp/templates/hash_set.hpp"
 #include "script/nodes/script_nodes.h"
+#include "script/script_server.h"
 
 #include <godot_cpp/classes/engine.hpp>
 
-void OrchestratorDefaultGraphActionRegistrar::_register_node(const OrchestratorGraphActionRegistrarContext& p_context,
-                                                       const StringName& p_class_name, const StringName& p_category,
-                                                       const Dictionary& p_data)
+void OrchestratorDefaultGraphActionRegistrar::_register_node(const StringName& p_class_name, const StringName& p_category, const Dictionary& p_data)
 {
     OScriptLanguage* language = OScriptLanguage::get_singleton();
-    Orchestration* orchestration = p_context.graph->get_orchestration();
+    Orchestration* orchestration = _context->graph->get_orchestration();
 
     const Ref<OScriptNode> node = language->create_node_from_name(p_class_name, orchestration, false);
     if (!node->get_flags().has_flag(OScriptNode::ScriptNodeFlags::CATALOGABLE))
@@ -52,7 +52,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_node(const OrchestratorG
     spec.keywords = StringUtils::join(",", keywords);
     spec.icon = node->get_icon();
     spec.type_icon = "PluginScript";
-    spec.graph_compatible = node->is_compatible_with_graph(p_context.graph->get_owning_graph());
+    spec.graph_compatible = node->is_compatible_with_graph(_context->graph->get_owning_graph());
 
     const Ref<OScriptNodeCallStaticFunction> call_static_function = node;
     if (call_static_function.is_valid())
@@ -64,7 +64,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_node(const OrchestratorG
     node->initialize(context);
 
     Ref<OrchestratorGraphActionHandler> handler(memnew(OrchestratorGraphNodeSpawnerScriptNode(p_class_name, p_data, node)));
-    p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
 }
 
 PackedStringArray OrchestratorDefaultGraphActionRegistrar::_get_class_hierarchy(const String& p_derived_class_name)
@@ -79,36 +79,6 @@ PackedStringArray OrchestratorDefaultGraphActionRegistrar::_get_class_hierarchy(
     return classes;
 }
 
-String OrchestratorDefaultGraphActionRegistrar::_get_method_signature(const MethodInfo& p_method)
-{
-    String signature = p_method.name.replace("_", " ").capitalize();
-    if (!p_method.arguments.empty())
-    {
-        signature += " (";
-        bool first = true;
-        int index = 0;
-        for (const PropertyInfo& property : p_method.arguments)
-        {
-            if (!first)
-                signature += ", ";
-
-            if (property.name.is_empty())
-                signature += "p" + itos(index++);
-            else
-                signature += property.name;
-
-            if (property.type == Variant::NIL)
-                signature += ":Any";
-            else
-                signature += ":" + Variant::get_type_name(property.type);
-
-            first = false;
-        }
-        signature += ")";
-    }
-    return signature;
-}
-
 String OrchestratorDefaultGraphActionRegistrar::_get_method_icon(const MethodInfo& p_method)
 {
     if (!OScriptNodeEvent::is_event_method(p_method))
@@ -123,7 +93,7 @@ String OrchestratorDefaultGraphActionRegistrar::_get_method_icon(const MethodInf
         else if (p_method.name.capitalize().begins_with("Set ") && p_method.arguments.size() == 1)
         {
             // Method is a setter, base icon on the argument type
-            String arg_type = Variant::get_type_name(p_method.arguments[0].type);
+            String arg_type = PropertyUtils::get_property_type_name(p_method.arguments[0]);
             if (!arg_type.is_empty())
                 return arg_type;
         }
@@ -167,20 +137,63 @@ String OrchestratorDefaultGraphActionRegistrar::_get_builtin_type_display_name(V
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_category(const OrchestratorGraphActionRegistrarContext& p_context, const String& p_category, const String& p_display_name, const String& p_icon)
+OrchestratorGraphActionSpec OrchestratorDefaultGraphActionRegistrar::_get_method_spec(const MethodInfo& p_method, const String& p_base_type, const String& p_class_name)
+{
+    OrchestratorGraphActionSpec spec;
+    if (p_class_name.is_empty())
+    {
+        spec.category = vformat("Call Function/%s", p_method.name);
+        spec.text = vformat("Call %s", _friendly_method_names ? p_method.name.capitalize() : String(p_method.name));
+    }
+    else
+    {
+        spec.category = vformat("Methods/%s/%s", p_class_name, p_method.name);
+        spec.text = vformat("%s", p_method.name).capitalize();
+    }
+
+    spec.tooltip = MethodUtils::get_signature(p_method);
+    spec.keywords = vformat("%s,%s", StringUtils::default_if_empty(p_class_name, p_base_type), p_method.name);
+    spec.icon = _get_method_icon(p_method);
+    spec.type_icon = _get_method_type_icon(p_method);
+
+    return spec;
+}
+
+OrchestratorGraphActionSpec OrchestratorDefaultGraphActionRegistrar::_get_signal_spec(const StringName& p_signal_name, const String& p_base_type, const String& p_class_name)
+{
+    OrchestratorGraphActionSpec spec;
+    if (p_class_name.is_empty())
+        spec.category = vformat("Signals/emit_%s", p_signal_name);
+    else
+        spec.category = vformat("Signals/%s/%s", p_class_name, p_signal_name);
+
+    spec.tooltip = "Emit the signal " + p_signal_name;
+    spec.text = vformat("emit_%s", p_signal_name).capitalize();
+    if (p_class_name.is_empty())
+        spec.keywords = vformat("emit,signal,%s,%s", p_base_type, p_signal_name);
+    else
+        spec.keywords = vformat("emit,signal,%s,%s", p_signal_name, p_class_name);
+
+    spec.icon = p_class_name.is_empty() ? "MemberSignal" : "Signal";
+    spec.type_icon = "MemberSignal";
+
+    return spec;
+}
+
+void OrchestratorDefaultGraphActionRegistrar::_register_category(const String& p_category, const String& p_display_name, const String& p_icon)
 {
     OrchestratorGraphActionSpec spec;
     spec.category = p_category;
     spec.text = p_display_name;
     spec.icon = p_icon;
-    p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec)));
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec)));
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const OrchestratorGraphActionRegistrarContext& p_context)
+void OrchestratorDefaultGraphActionRegistrar::_register_orchestration_nodes()
 {
     bool graph_function = false;
-    if (p_context.graph)
-        graph_function = p_context.graph->is_function();
+    if (_context->graph)
+        graph_function = _context->graph->is_function();
 
     // Groups
     const String func_or_macro_group = graph_function ? "Variables" : "Utilities/Macro";
@@ -191,128 +204,128 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
     const Dictionary array_data = DictionaryUtils::of({ { "collection_type", Variant::ARRAY },{ "index_type", Variant::NIL } });
 
     // Register several top-level categories
-    _register_category(p_context, "Project", "Project", "Godot");
-    _register_category(p_context, "Call Function", "Call Function", "ScriptExtend");
-    _register_category(p_context, "Constants", "Constants", "MemberConstant");
-    _register_category(p_context, "Dialogue", "Dialogue", "Window");
-    _register_category(p_context, "Flow Control", "Flow Control", "FileTree");
-    _register_category(p_context, "Input", "Input", "InputEventKey");
-    _register_category(p_context, "Math", "Math", "X509Certificate");
-    _register_category(p_context, "Memory", "Memory", "MiniObject");
-    _register_category(p_context, "Methods", "Methods", "MemberMethod");
-    _register_category(p_context, "Properties", "Properties", "MemberProperty");
-    _register_category(p_context, "Random Numbers", "Random Numbers", "RandomNumberGenerator");
-    _register_category(p_context, "Resource", "Resource", "File");
-    _register_category(p_context, "Scene", "Scene", "PackedScene");
-    _register_category(p_context, "Singletons", "Singletons", "MiniObject");
-    _register_category(p_context, "Static", "Static", "AudioBusSolo");
-    _register_category(p_context, "Utilities", "Utilities", "Tools");
-    _register_category(p_context, "Variables", "Variables", "Range");
+    _register_category("Project", "Project", "Godot");
+    _register_category("Call Function", "Call Function", "ScriptExtend");
+    _register_category("Constants", "Constants", "MemberConstant");
+    _register_category("Dialogue", "Dialogue", "Window");
+    _register_category("Flow Control", "Flow Control", "FileTree");
+    _register_category("Input", "Input", "InputEventKey");
+    _register_category("Math", "Math", "X509Certificate");
+    _register_category("Memory", "Memory", "MiniObject");
+    _register_category("Methods", "Methods", "MemberMethod");
+    _register_category("Properties", "Properties", "MemberProperty");
+    _register_category("Random Numbers", "Random Numbers", "RandomNumberGenerator");
+    _register_category("Resource", "Resource", "File");
+    _register_category("Scene", "Scene", "PackedScene");
+    _register_category("Singletons", "Singletons", "MiniObject");
+    _register_category("Static", "Static", "AudioBusSolo");
+    _register_category("Utilities", "Utilities", "Tools");
+    _register_category("Variables", "Variables", "Range");
 
     // Comments
-    _register_node<OScriptNodeComment>(p_context, "Utilities/add_comment");
+    _register_node<OScriptNodeComment>("Utilities/add_comment");
 
     // Constants
-    _register_node<OScriptNodeGlobalConstant>(p_context, "Constants/global_constant");
-    _register_node<OScriptNodeMathConstant>(p_context, "Constants/math_constant");
-    _register_node<OScriptNodeTypeConstant>(p_context, "Constants/type_constant");
-    _register_node<OScriptNodeClassConstant>(p_context, "Constants/class_constant");
-    _register_node<OScriptNodeSingletonConstant>(p_context, "Constants/singleton_constant");
+    _register_node<OScriptNodeGlobalConstant>("Constants/global_constant");
+    _register_node<OScriptNodeMathConstant>("Constants/math_constant");
+    _register_node<OScriptNodeTypeConstant>("Constants/type_constant");
+    _register_node<OScriptNodeClassConstant>("Constants/class_constant");
+    _register_node<OScriptNodeSingletonConstant>("Constants/singleton_constant");
 
     // Data
-    _register_node<OScriptNodeArrayGet>(p_context, "Types/Array/Operators/get_at_index", array_data);
-    _register_node<OScriptNodeArraySet>(p_context, "Types/Array/Operators/set_at_index", array_data);
-    _register_node<OScriptNodeArrayFind>(p_context, "Types/Array/find_array_element");
-    _register_node<OScriptNodeArrayClear>(p_context, "Types/Array/clear_array");
-    _register_node<OScriptNodeArrayAppend>(p_context, "Types/Array/append_arrays");
-    _register_node<OScriptNodeArrayAddElement>(p_context, "Types/Array/add_element");
-    _register_node<OScriptNodeArrayRemoveElement>(p_context, "Types/Array/remove_element");
-    _register_node<OScriptNodeArrayRemoveIndex>(p_context, "Types/Array/remove_element_by_index");
-    _register_node<OScriptNodeMakeArray>(p_context, "Types/Array/make_array");
-    _register_node<OScriptNodeMakeDictionary>(p_context, "Types/Dictionary/make_dictionary");
-    _register_node<OScriptNodeDictionarySet>(p_context, "Types/Dictionary/set");
+    _register_node<OScriptNodeArrayGet>("Types/Array/Operators/get_at_index", array_data);
+    _register_node<OScriptNodeArraySet>("Types/Array/Operators/set_at_index", array_data);
+    _register_node<OScriptNodeArrayFind>("Types/Array/find_array_element");
+    _register_node<OScriptNodeArrayClear>("Types/Array/clear_array");
+    _register_node<OScriptNodeArrayAppend>("Types/Array/append_arrays");
+    _register_node<OScriptNodeArrayAddElement>("Types/Array/add_element");
+    _register_node<OScriptNodeArrayRemoveElement>("Types/Array/remove_element");
+    _register_node<OScriptNodeArrayRemoveIndex>("Types/Array/remove_element_by_index");
+    _register_node<OScriptNodeMakeArray>("Types/Array/make_array");
+    _register_node<OScriptNodeMakeDictionary>("Types/Dictionary/make_dictionary");
+    _register_node<OScriptNodeDictionarySet>("Types/Dictionary/set");
 
     // Dialogue
-    _register_node<OScriptNodeDialogueChoice>(p_context, "Dialogue/choice");
-    _register_node<OScriptNodeDialogueMessage>(p_context, "Dialogue/show_message");
+    _register_node<OScriptNodeDialogueChoice>("Dialogue/choice");
+    _register_node<OScriptNodeDialogueMessage>("Dialogue/show_message");
 
     // Flow Control
-    _register_node<OScriptNodeBranch>(p_context, "Flow Control/branch");
-    _register_node<OScriptNodeChance>(p_context, "Flow Control/chance");
-    _register_node<OScriptNodeDelay>(p_context, "Flow Control/delay");
-    _register_node<OScriptNodeForEach>(p_context, "Flow Control/for_each", without_break);
-    _register_node<OScriptNodeForEach>(p_context, "Flow Control/for_each_with_break", with_break);
-    _register_node<OScriptNodeForLoop>(p_context, "Flow Control/for", without_break);
-    _register_node<OScriptNodeForLoop>(p_context, "Flow Control/for_with_break", with_break);
-    _register_node<OScriptNodeRandom>(p_context, "Flow Control/random");
-    _register_node<OScriptNodeSelect>(p_context, "Flow Control/select");
-    _register_node<OScriptNodeSequence>(p_context, "Flow Control/sequence");
-    _register_node<OScriptNodeSwitch>(p_context, "Flow Control/switch");
-    _register_node<OScriptNodeSwitchInteger>(p_context, "Flow Control/switch_on_integer");
-    _register_node<OScriptNodeSwitchString>(p_context, "Flow Control/switch_on_string");
-    _register_node<OScriptNodeTypeCast>(p_context, "Flow Control/type_cast");
-    _register_node<OScriptNodeWhile>(p_context, "Flow Control/while");
+    _register_node<OScriptNodeBranch>("Flow Control/branch");
+    _register_node<OScriptNodeChance>("Flow Control/chance");
+    _register_node<OScriptNodeDelay>("Flow Control/delay");
+    _register_node<OScriptNodeForEach>("Flow Control/for_each", without_break);
+    _register_node<OScriptNodeForEach>("Flow Control/for_each_with_break", with_break);
+    _register_node<OScriptNodeForLoop>("Flow Control/for", without_break);
+    _register_node<OScriptNodeForLoop>("Flow Control/for_with_break", with_break);
+    _register_node<OScriptNodeRandom>("Flow Control/random");
+    _register_node<OScriptNodeSelect>("Flow Control/select");
+    _register_node<OScriptNodeSequence>("Flow Control/sequence");
+    _register_node<OScriptNodeSwitch>("Flow Control/switch");
+    _register_node<OScriptNodeSwitchInteger>("Flow Control/switch_on_integer");
+    _register_node<OScriptNodeSwitchString>("Flow Control/switch_on_string");
+    _register_node<OScriptNodeTypeCast>("Flow Control/type_cast");
+    _register_node<OScriptNodeWhile>("Flow Control/while");
 
     // Switch on Enums
     for (const String& enum_name : ExtensionDB::get_global_enum_names())
     {
         const EnumInfo ei = ExtensionDB::get_global_enum(enum_name);
         const String category = vformat("Flow Control/Switch On/switch_on_%s", ei.name);
-        _register_node<OScriptNodeSwitchEnum>(p_context, category, DictionaryUtils::of({ { "enum" , ei.name } }));
+        _register_node<OScriptNodeSwitchEnum>(category, DictionaryUtils::of({ { "enum" , ei.name } }));
     }
 
     // Functions
-    _register_node<OScriptNodeFunctionResult>(p_context, "add_return_node");
+    _register_node<OScriptNodeFunctionResult>("add_return_node");
 
     // Input
-    _register_node<OScriptNodeInputAction>(p_context, "Input/input_action");
+    _register_node<OScriptNodeInputAction>("Input/input_action");
 
     // Memory
     {
         Dictionary new_object;
-        if (!p_context.filter->target_classes.is_empty())
-            new_object["class_name"] = p_context.filter->target_classes[0];
-        _register_node<OScriptNodeNew>(p_context, "Memory/new_object", new_object);
+        if (!_context->filter->target_classes.is_empty())
+            new_object["class_name"] = _context->filter->target_classes[0];
+        _register_node<OScriptNodeNew>("Memory/new_object", new_object);
 
-        _register_node<OScriptNodeFree>(p_context, "Memory/free_object");
+        _register_node<OScriptNodeFree>("Memory/free_object");
     }
 
     // Resource
-    _register_node<OScriptNodePreload>(p_context, "Resource/preload_resource");
-    _register_node<OScriptNodeResourcePath>(p_context, "Resource/get_resource_path");
+    _register_node<OScriptNodePreload>("Resource/preload_resource");
+    _register_node<OScriptNodeResourcePath>("Resource/get_resource_path");
 
     // Scene
-    _register_node<OScriptNodeInstantiateScene>(p_context, "Scene/instantiate_scene");
-    _register_node<OScriptNodeSceneNode>(p_context, "Scene/get_scene_node");
-    _register_node<OScriptNodeSceneTree>(p_context, "Scene/get_scene_tree");
+    _register_node<OScriptNodeInstantiateScene>("Scene/instantiate_scene");
+    _register_node<OScriptNodeSceneNode>("Scene/get_scene_node");
+    _register_node<OScriptNodeSceneTree>("Scene/get_scene_tree");
 
     // Signals
-    _register_node<OScriptNodeAwaitSignal>(p_context, "Signals/Await Signal");
+    _register_node<OScriptNodeAwaitSignal>("Signals/Await Signal");
 
     // Utilities
-    _register_node<OScriptNodeAutoload>(p_context, "Utilities/get_autoload");
-    _register_node<OScriptNodeEngineSingleton>(p_context, "Utilities/engine_singleton");
-    _register_node<OScriptNodePrintString>(p_context, "Utilities/print_string");
+    _register_node<OScriptNodeAutoload>("Utilities/get_autoload");
+    _register_node<OScriptNodeEngineSingleton>("Utilities/engine_singleton");
+    _register_node<OScriptNodePrintString>("Utilities/print_string");
 
     // Register each Engine singleton type
     for (const String& name : Engine::get_singleton()->get_singleton_list())
     {
         const String category = vformat("Singletons/%s", name);
         const Dictionary data = DictionaryUtils::of({ { "singleton_name", name } });
-        _register_node<OScriptNodeEngineSingleton>(p_context, category, data);
+        _register_node<OScriptNodeEngineSingleton>(category, data);
     }
 
     // Variables
-    _register_node<OScriptNodeSelf>(p_context, "Variables/get_self");
+    _register_node<OScriptNodeSelf>("Scene/get_self");
 
     // Register variable assignment differently for macros
     const String local_var_category = vformat("%s/assign_local", func_or_macro_group);
-    _register_node<OScriptNodeAssignLocalVariable>(p_context, local_var_category);
+    _register_node<OScriptNodeAssignLocalVariable>(local_var_category);
 
     // Register Local Object variables
     const String lv_object_name = vformat("%s/local_object", func_or_macro_group);
     const Dictionary object_type_dict = DictionaryUtils::of({ { "type", Variant::OBJECT } });
-    _register_node<OScriptNodeLocalVariable>(p_context, lv_object_name, object_type_dict);
+    _register_node<OScriptNodeLocalVariable>(lv_object_name, object_type_dict);
 
     // Static Function Calls
     for (const String& class_name : ClassDB::get_class_list())
@@ -320,7 +333,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
         for (const String& function_name : ExtensionDB::get_static_function_names(class_name))
         {
             const String category = vformat("Static/%s/%s", class_name, function_name);
-            _register_node<OScriptNodeCallStaticFunction>(p_context, category,
+            _register_node<OScriptNodeCallStaticFunction>(category,
                 DictionaryUtils::of({ { "class_name", class_name }, { "method_name", function_name } }));;
         }
     }
@@ -332,24 +345,24 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
         const String type_icon = _get_builtin_type_icon_name(type.type);
         const String type_name = _get_builtin_type_display_name(type.type);
 
-        _register_category(p_context, vformat("Types/%s", type_name), type_name, type_icon);
+        _register_category(vformat("Types/%s", type_name), type_name, type_icon);
 
         const Dictionary type_dict = DictionaryUtils::of({ { "type", type.type } });
 
         // Register local variables differently for macros
         const String lv_name = vformat("Types/%s/local_%s_variable", type_name, type_name);
-        _register_node<OScriptNodeLocalVariable>(p_context, lv_name, type_dict);
+        _register_node<OScriptNodeLocalVariable>(lv_name, type_dict);
 
         if (!type.properties.is_empty())
         {
             if (OScriptNodeCompose::is_supported(type.type))
             {
                 const String make_category = vformat("Types/%s/make_%s", type_name, type_name.to_lower());
-                _register_node<OScriptNodeCompose>(p_context, make_category, type_dict);
+                _register_node<OScriptNodeCompose>(make_category, type_dict);
             }
 
             const String break_category = vformat("Types/%s/break_%s", type_name, type_name.to_lower());
-            _register_node<OScriptNodeDecompose>(p_context, break_category, type_dict);
+            _register_node<OScriptNodeDecompose>(break_category, type_dict);
         }
 
         if (!type.constructors.is_empty())
@@ -381,7 +394,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
                     const String args = StringUtils::join(" and ", type_names);
                     const String category = vformat("Types/%s/make_%s_from_%s", type_name, type_name.to_lower(), args);
 
-                    _register_node<OScriptNodeComposeFrom>(p_context, category, ctor_dict);
+                    _register_node<OScriptNodeComposeFrom>(category, ctor_dict);
                 }
             }
         }
@@ -391,7 +404,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
             const String category = vformat("Types/%s/%s", type_name, mi.name);
             const Dictionary method_dict = DictionaryUtils::from_method(mi);
             const Dictionary data = DictionaryUtils::of({ { "target_type", type.type }, { "method", method_dict } });
-            _register_node<OScriptNodeCallMemberFunction>(p_context, category, data);
+            _register_node<OScriptNodeCallMemberFunction>(category, data);
         }
 
         if (OScriptNodeOperator::is_supported(type.type))
@@ -423,7 +436,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
                                                               { "right_type_name", op.right_type_name },
                                                               { "return_type", op.return_type } });
 
-                _register_node<OScriptNodeOperator>(p_context, category, data);
+                _register_node<OScriptNodeOperator>(category, data);
             }
         }
 
@@ -436,8 +449,8 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
                 { "collection_type", type.type },
                 { "index_type", type.index_returning_type } });
 
-            _register_node<OScriptNodeArrayGet>(p_context, get_category, data);
-            _register_node<OScriptNodeArraySet>(p_context, set_category, data);
+            _register_node<OScriptNodeArrayGet>(get_category, data);
+            _register_node<OScriptNodeArraySet>(set_category, data);
         }
     }
 
@@ -466,73 +479,110 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_nodes(const Orche
             top_category = "random_numbers";
 
         const String category = vformat("%s/%s", top_category.capitalize(), fi.name);
-        _register_node<OScriptNodeCallBuiltinFunction>(p_context, category, DictionaryUtils::from_method(mi));
+        _register_node<OScriptNodeCallBuiltinFunction>(category, DictionaryUtils::from_method(mi));
     }
 
     // Autoloads
     for (const String& class_name : OScriptLanguage::get_singleton()->get_global_constant_names())
     {
         String category = vformat("project/Autoloads/%s", class_name);
-        _register_node<OScriptNodeAutoload>(p_context, category, DictionaryUtils::of({{ "class_name" , class_name }}));
+        _register_node<OScriptNodeAutoload>(category, DictionaryUtils::of({{ "class_name" , class_name }}));
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_graph_items(const OrchestratorGraphActionRegistrarContext& p_context)
+void OrchestratorDefaultGraphActionRegistrar::_register_class(const String& p_class_name)
 {
-    if (!p_context.graph)
-        return;
+    const OrchestratorGraphActionSpec spec(p_class_name, p_class_name, p_class_name);
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec)));
 
-    PackedStringArray classes;
-    if (p_context.filter->has_target_object())
-    {
-        classes.push_back(p_context.filter->get_target_class());
-    }
-    else if (!p_context.filter->target_classes.is_empty())
-    {
-        for (String target_class : p_context.filter->target_classes)
-        {
-            PackedStringArray target_hierarchy = _get_class_hierarchy(target_class);
-            for (const String& target : target_hierarchy)
-                classes.push_back(target);
-        }
-    }
-    else
+    _register_methods(p_class_name, ClassDB::class_get_method_list(p_class_name, true));
+    _register_properties(p_class_name, ClassDB::class_get_property_list(p_class_name, true));
+    _register_signals(p_class_name, ClassDB::class_get_signal_list(p_class_name, true));
+}
+
+void OrchestratorDefaultGraphActionRegistrar::_register_methods(const String& p_class_name, const TypedArray<Dictionary>& p_methods)
+{
+    if (ClassDB::can_instantiate(p_class_name) && !_classes_new_instances.has(p_class_name))
     {
-        classes = _get_class_hierarchy(p_context.graph->get_orchestration()->get_base_type());
+        _classes_new_instances.push_back(p_class_name);
+
+        const String category = vformat("Methods/%s/New Instance", p_class_name);
+        _register_node<OScriptNodeNew>(category, DictionaryUtils::of({ { "class_name", p_class_name } }));
     }
 
-    for (const String& class_name : classes)
+    Orchestration* orchestration = _context->filter->get_orchestration();
+    for (int i = 0; i < p_methods.size(); i++)
     {
-        const OrchestratorGraphActionSpec spec(class_name, class_name, class_name);
-        p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec)));
-        _register_class_properties(p_context, class_name);
-        _register_class_methods(p_context, class_name);
-        _register_class_signals(p_context, class_name);
+        const MethodInfo mi = DictionaryUtils::to_method(p_methods[i]);
+
+        // Skip private methods
+        if (mi.name.begins_with("_") && !(mi.flags & METHOD_FLAG_VIRTUAL))
+            continue;
+
+        // Skip internal methods (found from scripts like GDScript)
+        if (mi.name.begins_with("@"))
+            continue;
+
+        const OrchestratorGraphActionSpec spec = _get_method_spec(mi, orchestration->get_base_type(), p_class_name);
+
+        OrchestratorGraphActionHandler* handler_ptr;
+        if (OScriptNodeEvent::is_event_method(mi))
+            handler_ptr = memnew(OrchestratorGraphNodeSpawnerEvent(mi));
+        else
+            handler_ptr = memnew(OrchestratorGraphNodeSpawnerCallMemberFunction(mi, p_class_name));
+
+        Ref<OrchestratorGraphActionHandler> handler(handler_ptr);
+        _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_class_properties(const OrchestratorGraphActionRegistrarContext& p_context,
-                                                                   const StringName& p_class_name)
+void OrchestratorDefaultGraphActionRegistrar::_register_properties(const String& p_class_name, const TypedArray<Dictionary>& p_properties)
 {
-    String class_name = p_class_name;
-    TypedArray<Dictionary> properties;
-    if (p_context.filter->has_target_object())
-    {
-        properties = p_context.filter->target_object->get_target_property_list();
-        class_name = p_context.filter->target_object->get_class();
-    }
-    else
-        properties = ClassDB::class_get_property_list(p_class_name, true);
+    ScriptServer::GlobalClass global_class;
+    if (ScriptServer::is_global_class(p_class_name))
+        global_class = ScriptServer::get_global_class(p_class_name);
 
-    for (int i = 0; i < properties.size(); i++)
+    for (int i = 0; i < p_properties.size(); i++)
     {
-        const PropertyInfo pi = DictionaryUtils::to_property(properties[i]);
+        const PropertyInfo pi = DictionaryUtils::to_property(p_properties[i]);
 
         // Exclude properties that are not included in the class reference
         if (pi.usage & PROPERTY_USAGE_INTERNAL)
             continue;
 
-        if (!ClassDB::class_has_method(class_name, vformat("get_%s", pi.name)))
+        // Exclude category and group properties
+        if (pi.usage & PROPERTY_USAGE_CATEGORY || pi.usage & PROPERTY_USAGE_GROUP)
+            continue;
+
+        // Skip private properties
+        if (pi.name.begins_with("_"))
+            continue;
+
+        // For script variables, checks whether its define in the parent or child type
+        // If it's defined in the parent type, skip it
+        if (pi.usage & PROPERTY_USAGE_SCRIPT_VARIABLE && !global_class.name.is_empty())
+        {
+            if (ScriptServer::is_global_class(global_class.base_type))
+            {
+                if (ScriptServer::get_global_class(global_class.base_type).has_property(pi.name))
+                    continue;
+            }
+        }
+
+        const String getter_name = vformat("get_%s", pi.name);
+        const String setter_name = vformat("set_%s", pi.name);
+
+        bool has_getter = false;
+        if ((global_class.name.is_empty() && ClassDB::class_has_method(p_class_name, getter_name))
+            || (!global_class.name.is_empty() && global_class.has_method(getter_name)))
+            has_getter = true;
+
+        bool has_setter = false;
+        if ((global_class.name.is_empty() && ClassDB::class_has_method(p_class_name, setter_name))
+            || (!global_class.name.is_empty() && global_class.has_method(setter_name)))
+            has_setter = true;
+
+        if (!has_getter)
         {
             OrchestratorGraphActionSpec getter_spec;
             getter_spec.category = vformat("Properties/%s/get_%s", p_class_name, pi.name);
@@ -542,11 +592,11 @@ void OrchestratorDefaultGraphActionRegistrar::_register_class_properties(const O
             getter_spec.icon = Variant::get_type_name(pi.type);
             getter_spec.type_icon = "MemberProperty";
 
-            Ref<OrchestratorGraphActionHandler> getter_handler(memnew(OrchestratorGraphNodeSpawnerPropertyGet(pi, p_context.filter->target_classes)));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(getter_spec, getter_handler)));
+            Ref<OrchestratorGraphActionHandler> getter_handler(memnew(OrchestratorGraphNodeSpawnerPropertyGet(pi, Array::make(p_class_name))));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(getter_spec, getter_handler)));
         }
 
-        if (!ClassDB::class_has_method(class_name, vformat("set_%s", pi.name)))
+        if (!has_setter)
         {
             OrchestratorGraphActionSpec setter_spec;
             setter_spec.category = vformat("Properties/%s/set_%s", p_class_name, pi.name);
@@ -556,78 +606,29 @@ void OrchestratorDefaultGraphActionRegistrar::_register_class_properties(const O
             setter_spec.icon = Variant::get_type_name(pi.type);
             setter_spec.type_icon = "MemberProperty";
 
-            Ref<OrchestratorGraphActionHandler> setter_handler(memnew(OrchestratorGraphNodeSpawnerPropertySet(pi, p_context.filter->target_classes)));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(setter_spec, setter_handler)));
+            Ref<OrchestratorGraphActionHandler> setter_handler(memnew(OrchestratorGraphNodeSpawnerPropertySet(pi, Array::make(p_class_name))));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(setter_spec, setter_handler)));
         }
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_class_methods(const OrchestratorGraphActionRegistrarContext& p_context,
-                                                                const StringName& p_class_name)
+void OrchestratorDefaultGraphActionRegistrar::_register_signals(const String& p_class_name, const TypedArray<Dictionary>& p_signals)
 {
-    TypedArray<Dictionary> methods;
-    StringName class_name;
-    if (p_context.filter->has_target_object())
-    {
-        methods = p_context.filter->target_object->get_target_method_list();
-        class_name = p_context.filter->target_object->get_class();
-    }
-    else
-    {
-        methods = ClassDB::class_get_method_list(p_class_name, true);
-        class_name = p_class_name;
-    }
+    ScriptServer::GlobalClass global_class;
+    if (ScriptServer::is_global_class(p_class_name))
+        global_class = ScriptServer::get_global_class(p_class_name);
 
-    if (ClassDB::can_instantiate(class_name))
+    Orchestration* orchestration = _context->filter->get_orchestration();
+    for (int i = 0; i < p_signals.size(); i++)
     {
-        const String category = vformat("Methods/%s/New Instance", class_name);
-        _register_node<OScriptNodeNew>(p_context, category, DictionaryUtils::of({ { "class_name", class_name } }));
-    }
+        const MethodInfo si = DictionaryUtils::to_method(p_signals[i]);
 
-    for (int i = 0; i < methods.size(); i++)
-    {
-        const MethodInfo mi = DictionaryUtils::to_method(methods[i]);
-        if (mi.name.begins_with("_") && !(mi.flags & METHOD_FLAG_VIRTUAL))
-            continue;
-
-        OrchestratorGraphActionSpec spec;
-        spec.category = vformat("Methods/%s/%s", class_name, mi.name);
-        spec.tooltip = _get_method_signature(mi);
-        spec.text = vformat("%s", mi.name).capitalize();
-        spec.keywords = vformat("%s,%s", class_name, mi.name);
-        spec.icon = _get_method_icon(mi);
-        spec.type_icon = _get_method_type_icon(mi);
-
-        OrchestratorGraphActionHandler* handler_ptr;
-        if (OScriptNodeEvent::is_event_method(mi))
-            handler_ptr = memnew(OrchestratorGraphNodeSpawnerEvent(mi));
-        else
-            handler_ptr = memnew(OrchestratorGraphNodeSpawnerCallMemberFunction(mi, class_name));
-
-        Ref<OrchestratorGraphActionHandler> handler(handler_ptr);
-        p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
-    }
-}
-
-void OrchestratorDefaultGraphActionRegistrar::_register_class_signals(const OrchestratorGraphActionRegistrarContext& p_context,
-                                                                const StringName& p_class_name)
-{
-    TypedArray<Dictionary> signals;
-    if (p_context.filter->has_target_object())
-        signals = p_context.filter->target_object->get_target_signal_list();
-    else
-        signals = ClassDB::class_get_signal_list(p_class_name, true);
+        // Skip signals that are defined in parent global class types
+        if (!global_class.name.is_empty() && ScriptServer::is_global_class(global_class.base_type))
+            if (ScriptServer::get_global_class(global_class.base_type).has_signal(si.name))
+                continue;
 
-    for (int i = 0; i < signals.size(); i++)
-    {
-        const MethodInfo si = DictionaryUtils::to_method(signals[i]);
-        OrchestratorGraphActionSpec spec;
-        spec.category = vformat("Signals/%s/%s", p_class_name, si.name);
-        spec.tooltip = "Emit the signal " + si.name;
-        spec.text = vformat("emit_%s", si.name).capitalize();
-        spec.keywords = vformat("emit,signal,%s,%s", p_class_name, si.name);
-        spec.icon = "Signal";
-        spec.type_icon = "MemberSignal";
+        const OrchestratorGraphActionSpec spec = _get_signal_spec(si.name, orchestration->get_base_type(), p_class_name);
 
         MethodInfo mi;
         mi.name = si.name;
@@ -635,11 +636,11 @@ void OrchestratorDefaultGraphActionRegistrar::_register_class_signals(const Orch
         mi.return_val = PropertyInfo(Variant::NIL, "");
 
         Ref<OrchestratorGraphActionHandler> handler(memnew(OrchestratorGraphNodeSpawnerEmitMemberSignal(mi, p_class_name)));
-        p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
+        _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_script_functions(const OrchestratorGraphActionRegistrarContext& p_context)
+void OrchestratorDefaultGraphActionRegistrar::_register_orchestration_functions()
 {
     OrchestratorGraphActionSpec call_function_spec;
     call_function_spec.category = "call_function";
@@ -648,13 +649,10 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_functions(const O
     call_function_spec.keywords = "call,function";
     call_function_spec.icon = "MemberMethod";
     call_function_spec.type_icon = "MemberMethod";
-    p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(call_function_spec)));
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(call_function_spec)));
 
-    if (OrchestratorGraphEdit* graph = p_context.graph)
+    if (OrchestratorGraphEdit* graph = _context->graph)
     {
-        OrchestratorSettings* settings = OrchestratorSettings::get_singleton();
-        bool friendly_names = settings->get_setting("ui/components_panel/show_function_friendly_names", true);
-
         Orchestration* orchestration = graph->get_orchestration();
         for (const Ref<OScriptFunction>& function : orchestration->get_functions())
         {
@@ -662,22 +660,15 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_functions(const O
                 continue;
 
             const MethodInfo& mi = function->get_method_info();
-
-            OrchestratorGraphActionSpec spec;
-            spec.category = vformat("Call Function/%s", mi.name);
-            spec.tooltip = _get_method_signature(mi);
-            spec.text = vformat("Call %s", friendly_names ? mi.name.capitalize() : String(mi.name));
-            spec.keywords = vformat("call,%s,%s", orchestration->get_base_type(), mi.name);
-            spec.icon = _get_method_icon(mi);
-            spec.type_icon = _get_method_type_icon(mi);
+            const OrchestratorGraphActionSpec spec = _get_method_spec(mi, orchestration->get_base_type());
 
             Ref<OrchestratorGraphActionHandler> handler(memnew(OrchestratorGraphNodeSpawnerCallScriptFunction(mi)));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
         }
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_script_variables(const OrchestratorGraphActionRegistrarContext& p_context)
+void OrchestratorDefaultGraphActionRegistrar::_register_orchestration_variables()
 {
     OrchestratorGraphActionSpec variables_spec;
     variables_spec.category = "variables";
@@ -686,9 +677,9 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_variables(const O
     variables_spec.keywords = "variable,variables";
     variables_spec.icon = "MemberProperty";
     variables_spec.type_icon = "MemberProperty";
-    p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(variables_spec)));
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(variables_spec)));
 
-    if (OrchestratorGraphEdit* graph = p_context.graph)
+    if (OrchestratorGraphEdit* graph = _context->graph)
     {
         for (const Ref<OScriptVariable>& variable : graph->get_orchestration()->get_variables())
         {
@@ -706,7 +697,7 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_variables(const O
             getter_spec.type_icon = "MemberProperty";
 
             Ref<OrchestratorGraphActionHandler> getter_handler(memnew(OrchestratorGraphNodeSpawnerVariableGet(variable_name)));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(getter_spec, getter_handler)));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(getter_spec, getter_handler)));
 
             OrchestratorGraphActionSpec setter_spec;
             setter_spec.category = vformat("Variables/set_%s", variable_name);
@@ -717,12 +708,12 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_variables(const O
             setter_spec.type_icon = "MemberProperty";
 
             Ref<OrchestratorGraphActionHandler> setter_handler(memnew(OrchestratorGraphNodeSpawnerVariableSet(variable_name)));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(setter_spec, setter_handler)));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(setter_spec, setter_handler)));
         }
     }
 }
 
-void OrchestratorDefaultGraphActionRegistrar::_register_script_signals(const OrchestratorGraphActionRegistrarContext& p_context)
+void OrchestratorDefaultGraphActionRegistrar::_register_orchestration_signals()
 {
     OrchestratorGraphActionSpec signals_spec;
     signals_spec.category = "emit_signals";
@@ -731,9 +722,9 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_signals(const Orc
     signals_spec.keywords = "signal,signals";
     signals_spec.icon = "MemberSignal";
     signals_spec.type_icon = "MemberSignal";
-    p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(signals_spec)));
+    _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(signals_spec)));
 
-    if (OrchestratorGraphEdit* graph = p_context.graph)
+    if (OrchestratorGraphEdit* graph = _context->graph)
     {
         Orchestration* orchestration = graph->get_owning_graph()->get_orchestration();
         for (const Ref<OScriptSignal>& signal : orchestration->get_custom_signals())
@@ -741,25 +732,80 @@ void OrchestratorDefaultGraphActionRegistrar::_register_script_signals(const Orc
             if (!signal.is_valid())
                 continue;
 
-            OrchestratorGraphActionSpec spec;
-            spec.category = vformat("Signals/emit_%s", signal->get_signal_name());
-            spec.tooltip = vformat("Emit signal '%s'", signal->get_signal_name());
-            spec.text = vformat("Emit %s", signal->get_signal_name());
-            spec.keywords = vformat("emit,signal,%s,%s", orchestration->get_base_type(), signal->get_signal_name());
-            spec.icon = "MemberSignal";
-            spec.type_icon = "MemberSignal";
+            const OrchestratorGraphActionSpec spec = _get_signal_spec(signal->get_signal_name(), orchestration->get_base_type());
 
             Ref<OrchestratorGraphActionHandler> handler(memnew(OrchestratorGraphNodeSpawnerEmitSignal(signal->get_method_info())));
-            p_context.list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
+            _context->list->push_back(memnew(OrchestratorGraphActionMenuItem(spec, handler)));
         }
     }
 }
 
 void OrchestratorDefaultGraphActionRegistrar::register_actions(const OrchestratorGraphActionRegistrarContext& p_context)
 {
-    _register_graph_items(p_context);
-    _register_script_nodes(p_context);
-    _register_script_functions(p_context);
-    _register_script_variables(p_context);
-    _register_script_signals(p_context);
+    OrchestratorSettings* settings = OrchestratorSettings::get_singleton();
+    _friendly_method_names = settings->get_setting("ui/components_panel/show_function_friendly_names", true);
+
+    _context = &p_context;
+
+    if (p_context.graph)
+    {
+        if (p_context.filter->has_target_object())
+        {
+            const Object* object = p_context.filter->target_object->get_target();
+            const Ref<Script> script = object->get_script();
+            if (script.is_valid() && !script->get_global_name().is_empty())
+            {
+                // The target object has a named script attached
+                // In this context,register script methods, properties, and signals using the script's
+                // class_name rather than adding these as part of the base script type.
+                const PackedStringArray script_class_names = ScriptServer::get_class_hierarchy(script->get_global_name());
+                for (const String& class_name : script_class_names)
+                {
+                    const ScriptServer::GlobalClass global_class = ScriptServer::get_global_class(class_name);
+                    _register_methods(class_name, global_class.get_method_list());
+                    _register_properties(class_name, global_class.get_property_list());
+                    _register_signals(class_name, global_class.get_signal_list());
+                }
+            }
+            else if (script.is_valid() && !script->get_class().match(OScript::get_class_static()))
+            {
+                const String script_class_name = p_context.filter->get_target_class();
+                _register_methods(script_class_name, script->get_script_method_list());
+                _register_properties(script_class_name, script->get_script_property_list());
+                _register_signals(script_class_name, script->get_script_signal_list());
+            }
+
+            const PackedStringArray class_names = _get_class_hierarchy(p_context.filter->get_target_class());
+            for (const String& class_name : class_names)
+                _register_class(class_name);
+        }
+        else if (!p_context.filter->target_classes.is_empty())
+        {
+            PackedStringArray classes_added;
+            for (const StringName& target_class_name : p_context.filter->target_classes)
+            {
+                PackedStringArray class_names = _get_class_hierarchy(target_class_name);
+                for (const String& class_name : class_names)
+                {
+                    if (!classes_added.has(class_name))
+                    {
+                        classes_added.push_back(class_name);
+                        _register_class(class_name);
+                    }
+                }
+            }
+        }
+        else
+        {
+            const String base_type = p_context.graph->get_orchestration()->get_base_type();
+            const PackedStringArray class_names = _get_class_hierarchy(base_type);
+            for (const String& class_name : class_names)
+                _register_class(class_name);
+        }
+    }
+
+    _register_orchestration_nodes();
+    _register_orchestration_functions();
+    _register_orchestration_variables();
+    _register_orchestration_signals();
 }
\ No newline at end of file
diff --git a/src/editor/graph/actions/default_action_registrar.h b/src/editor/graph/actions/default_action_registrar.h
index 69e695e3..bdc2f806 100644
--- a/src/editor/graph/actions/default_action_registrar.h
+++ b/src/editor/graph/actions/default_action_registrar.h
@@ -23,43 +23,102 @@
 /// and any nodes related to the filter or context details.
 class OrchestratorDefaultGraphActionRegistrar : public OrchestratorGraphActionRegistrar
 {
-    GDCLASS(OrchestratorDefaultGraphActionRegistrar, OrchestratorGraphActionRegistrar)
+    GDCLASS(OrchestratorDefaultGraphActionRegistrar, OrchestratorGraphActionRegistrar);
+    static void _bind_methods() { }
 
-    // Helper methods
+protected:
+    const OrchestratorGraphActionRegistrarContext* _context{ nullptr };   //! The action registrar context
+    Vector<String> _classes_new_instances;
+    bool _friendly_method_names{ false };
 
-    static String _get_method_signature(const MethodInfo& p_method);
+    /// Get the method's icon
+    /// @param p_method the method
+    /// @return the icon name to be used
     static String _get_method_icon(const MethodInfo& p_method);
+
+    /// Get the method's type icon
+    /// @param p_method the method
+    /// @return the type icon, such as event, function, etc.
     static String _get_method_type_icon(const MethodInfo& p_method);
+
+    /// Get the specified native class hierarchy
+    /// @param p_derived_class_name the class name
+    /// @return array of classes in the class hierarchy
     static PackedStringArray _get_class_hierarchy(const String& p_derived_class_name);
-    static void _register_node(const OrchestratorGraphActionRegistrarContext& p_context, const StringName& p_class_name,
-                               const StringName& p_category, const Dictionary& p_data = Dictionary());
 
+    /// Get the built-in type icon name
+    /// @param p_type the built-in type
+    /// @return the icon name
     String _get_builtin_type_icon_name(Variant::Type p_type) const;
+
+    /// Get the built-in type display name
+    /// @param p_type the built-in type
+    /// @return the type name
     String _get_builtin_type_display_name(Variant::Type p_type) const;
 
+    /// Returns a method action specification
+    /// @param p_method the method
+    /// @param p_base_type the orchestration base type
+    /// @param p_class_name the class name to register the method under, optional
+    /// @return the action spec
+    OrchestratorGraphActionSpec _get_method_spec(const MethodInfo& p_method, const String& p_base_type, const String& p_class_name = "");
+
+    /// Returns a signal action item specification
+    /// @param p_signal_name the signal name
+    /// @param p_base_type the orchestration base type
+    /// @param p_class_name the class name to register the signal under, optional
+    /// @return the action spec
+    OrchestratorGraphActionSpec _get_signal_spec(const StringName& p_signal_name, const String& p_base_type, const String& p_class_name = "");
+
+    /// Register a script node by class
+    /// @param p_class_name the script node class name
+    /// @param p_category the category to register the node under
+    /// @param p_data any additional data to pass to the constructed node
+    void _register_node(const StringName& p_class_name, const StringName& p_category, const Dictionary& p_data = Dictionary());
+
     /// Registration that uses OrchestratorGraphNodeSpawnerScriptNode
-    template <typename T>
-    void _register_node(const OrchestratorGraphActionRegistrarContext& p_context, const StringName& p_category,
-                        const Dictionary& p_data = Dictionary())
+    /// @param p_category the category to register the node under
+    /// @param p_data the additional data to pass to the constructed node
+    template <typename T> void _register_node(const StringName& p_category, const Dictionary& p_data = Dictionary())
     {
-        _register_node(p_context, T::get_class_static(), p_category, p_data);
+        _register_node(T::get_class_static(), p_category, p_data);
     }
 
-    // Registration steps
+    /// Register category
+    /// @param p_category the category name
+    /// @param p_display_name the category display name
+    /// @param p_icon the icon to use for the category
+    void _register_category(const String& p_category, const String& p_display_name, const String& p_icon = String());
 
-    void _register_category(const OrchestratorGraphActionRegistrarContext& p_context, const String& p_category, const String& p_display_name, const String& p_icon = String());
+    /// Registers a specific class
+    void _register_class(const String& p_class_name);
 
-    void _register_script_nodes(const OrchestratorGraphActionRegistrarContext& p_context);
-    void _register_graph_items(const OrchestratorGraphActionRegistrarContext& p_context);
-    void _register_class_properties(const OrchestratorGraphActionRegistrarContext& p_context, const StringName& p_class_name);
-    void _register_class_methods(const OrchestratorGraphActionRegistrarContext& p_context, const StringName& p_class_name);
-    void _register_class_signals(const OrchestratorGraphActionRegistrarContext& p_context, const StringName& p_class_name);
-    void _register_script_functions(const OrchestratorGraphActionRegistrarContext& p_context);
-    void _register_script_variables(const OrchestratorGraphActionRegistrarContext& p_context);
-    void _register_script_signals(const OrchestratorGraphActionRegistrarContext& p_context);
+    /// Registers an array of method definitions with the specified class name
+    /// @param p_class_name the class name
+    /// @param p_methods array of methods
+    void _register_methods(const String& p_class_name, const TypedArray<Dictionary>& p_methods);
 
-protected:
-    static void _bind_methods() { }
+    /// Registers an array of property definitions with the specified class name
+    /// @param p_class_name the class name
+    /// @param p_properties array of properties
+    void _register_properties(const String& p_class_name, const TypedArray<Dictionary>& p_properties);
+
+    /// Register an array of signal definitions with the specified class name
+    /// @param p_class_name the class name
+    /// @param p_signals array of signals
+    void _register_signals(const String& p_class_name, const TypedArray<Dictionary>& p_signals);
+
+    /// Registers all orchestration script nodes
+    void _register_orchestration_nodes();
+
+    /// Registers all orchestration functions
+    void _register_orchestration_functions();
+
+    /// Registers all orchestration variables
+    void _register_orchestration_variables();
+
+    /// Registers all orchestration signals
+    void _register_orchestration_signals();
 
 public:
     //~ Begin OrchestratorGraphActionRegistrar Interface
diff --git a/src/editor/graph/graph_edit.cpp b/src/editor/graph/graph_edit.cpp
index af63bfef..25350bed 100644
--- a/src/editor/graph/graph_edit.cpp
+++ b/src/editor/graph/graph_edit.cpp
@@ -585,7 +585,13 @@ void OrchestratorGraphEdit::_drop_data(const Vector2& p_position, const Variant&
             {
                 OScriptNodeInitContext context;
                 context.node_path = root->get_path_to(dropped_node);
-                context.class_name = dropped_node->get_class();
+
+                const Ref<Script> node_script = dropped_node->get_script();
+                if (node_script.is_valid() && !node_script->get_global_name().is_empty())
+                    context.class_name = node_script->get_global_name();
+                else
+                    context.class_name = dropped_node->get_class();
+
                 spawn_node<OScriptNodeSceneNode>(context, _saved_mouse_position);
             }
         }
diff --git a/src/editor/graph/graph_node.cpp b/src/editor/graph/graph_node.cpp
index 1b54393b..f83a27e8 100644
--- a/src/editor/graph/graph_node.cpp
+++ b/src/editor/graph/graph_node.cpp
@@ -207,7 +207,7 @@ int OrchestratorGraphNode::get_inputs_with_opacity(float p_opacity)
 int OrchestratorGraphNode::get_outputs_with_opacity(float p_opacity)
 {
     int count = 0;
-    for (int i = 0; i < get_input_port_count(); i++)
+    for (int i = 0; i < get_output_port_count(); i++)
     {
         if (is_slot_enabled_right(i))
         {
diff --git a/src/editor/graph/graph_node_pin.cpp b/src/editor/graph/graph_node_pin.cpp
index 1768e68c..104ed744 100644
--- a/src/editor/graph/graph_node_pin.cpp
+++ b/src/editor/graph/graph_node_pin.cpp
@@ -156,9 +156,7 @@ ResolvedType OrchestratorGraphNodePin::resolve_type() const
         resolved_type.class_name = "Object";
 
     // Primarily used by SceneNode to get scene attributes about the target
-    Ref<OScriptTargetObject> target = _pin->resolve_target();
-    if (target.is_valid() && target->has_target())
-        resolved_type.object = target->get_target();
+    resolved_type.object = _pin->resolve_target();
 
     return resolved_type;
 }
diff --git a/src/editor/graph/graph_node_spawner.h b/src/editor/graph/graph_node_spawner.h
index fe71af6b..38ed0171 100644
--- a/src/editor/graph/graph_node_spawner.h
+++ b/src/editor/graph/graph_node_spawner.h
@@ -48,7 +48,7 @@ class OrchestratorGraphNodeSpawnerProperty : public OrchestratorGraphNodeSpawner
 
     PropertyInfo _property;
     NodePath _node_path;
-    Vector<StringName> _target_classes;
+    PackedStringArray _target_classes;
 
 public:
     OrchestratorGraphNodeSpawnerProperty(const PropertyInfo& p_property, const NodePath& p_node_path)
@@ -56,7 +56,7 @@ class OrchestratorGraphNodeSpawnerProperty : public OrchestratorGraphNodeSpawner
         , _node_path(p_node_path)
     {
     }
-    OrchestratorGraphNodeSpawnerProperty(const PropertyInfo& p_property, const Vector<StringName>& p_target_classes)
+    OrchestratorGraphNodeSpawnerProperty(const PropertyInfo& p_property, const PackedStringArray& p_target_classes)
         : _property(p_property)
         , _target_classes(p_target_classes)
     {
@@ -82,7 +82,7 @@ class OrchestratorGraphNodeSpawnerPropertyGet : public OrchestratorGraphNodeSpaw
         : OrchestratorGraphNodeSpawnerProperty(p_property, p_node_path)
     {
     }
-    OrchestratorGraphNodeSpawnerPropertyGet(const PropertyInfo& p_property, const Vector<StringName>& p_target_classes)
+    OrchestratorGraphNodeSpawnerPropertyGet(const PropertyInfo& p_property, const PackedStringArray& p_target_classes)
         : OrchestratorGraphNodeSpawnerProperty(p_property, p_target_classes)
     {
     }
@@ -111,7 +111,7 @@ class OrchestratorGraphNodeSpawnerPropertySet : public OrchestratorGraphNodeSpaw
         : OrchestratorGraphNodeSpawnerProperty(p_property, p_node_path), _default_value(p_default_value)
     {
     }
-    OrchestratorGraphNodeSpawnerPropertySet(const PropertyInfo& p_property, const Vector<StringName>& p_target_classes)
+    OrchestratorGraphNodeSpawnerPropertySet(const PropertyInfo& p_property, const PackedStringArray& p_target_classes)
         : OrchestratorGraphNodeSpawnerProperty(p_property, p_target_classes)
     {
     }
diff --git a/src/editor/graph/pins/graph_node_pin_object.cpp b/src/editor/graph/pins/graph_node_pin_object.cpp
index 8fea2977..326ee62a 100644
--- a/src/editor/graph/pins/graph_node_pin_object.cpp
+++ b/src/editor/graph/pins/graph_node_pin_object.cpp
@@ -33,7 +33,7 @@ void OrchestratorGraphNodePinObject::_update_label()
 {
     if (Object::cast_to<OScriptNodeCallFunction>(_pin->get_owning_node()))
     {
-        if (_pin->get_pin_name().match("target"))
+        if (_pin->get_pin_name().match("target") && !_pin->has_any_connections())
         {
             const String target_class = _pin->get_property_info().class_name;
             const String base_type = _pin->get_owning_node()->get_orchestration()->get_base_type();
diff --git a/src/script/node_pin.cpp b/src/script/node_pin.cpp
index 8ba438f8..352b3880 100644
--- a/src/script/node_pin.cpp
+++ b/src/script/node_pin.cpp
@@ -22,6 +22,7 @@
 #include "nodes/functions/event.h"
 #include "script/node.h"
 #include "script/nodes/data/coercion_node.h"
+#include "script_server.h"
 
 void OScriptNodePin::_bind_methods()
 {
@@ -480,6 +481,10 @@ bool OScriptNodePin::can_accept(const Ref<OScriptNodePin>& p_pin) const
         const String source_class = p_pin->get_property_info().class_name;
         if (!target_class.is_empty() && !source_class.is_empty())
         {
+            // Check inheritance of global classes
+            if (ScriptServer::is_global_class(source_class) && ScriptServer::is_parent_class(source_class, target_class))
+                return true;
+
             // Either must be the same or the target must be a super type of the source
             // The equality check is to handle enum classes that aren't registered as "classes" in Godot terms
             if (ClassDB::is_parent_class(source_class, target_class) || target_class == source_class)
diff --git a/src/script/nodes/functions/call_function.cpp b/src/script/nodes/functions/call_function.cpp
index 4afce547..4be5b180 100644
--- a/src/script/nodes/functions/call_function.cpp
+++ b/src/script/nodes/functions/call_function.cpp
@@ -462,16 +462,17 @@ void OScriptNodeCallFunction::validate_node_during_build(BuildLog& p_log) const
         const Ref<OScriptNodePin> property_pin = find_pin(property.name, PD_Input);
         if (property_pin.is_valid())
         {
-            switch (property_pin->get_property_info().type)
+            Variant::Type pin_type = property_pin->get_property_info().type;
+            if (pin_type == Variant::OBJECT || pin_type == Variant::CALLABLE)
             {
-                case Variant::OBJECT:
-                case Variant::CALLABLE:
-                case Variant::NODE_PATH:
-                    if (!property_pin->has_any_connections())
-                        p_log.error(this, property_pin, "Requires a connection.");
-                break;
-                default:
-                    break;
+                if (!property_pin->has_any_connections())
+                    p_log.error(this, property_pin, "Requires a connection.");
+            }
+            else if (pin_type == Variant::NODE_PATH && !property_pin->has_any_connections())
+            {
+                const NodePath value = property_pin->get_effective_default_value();
+                if (value.is_empty())
+                    p_log.error(this, property_pin, "Requires a NodePath value or a connection.");
             }
         }
     }
diff --git a/src/script/nodes/functions/call_member_function.cpp b/src/script/nodes/functions/call_member_function.cpp
index 6928b89b..75a273bd 100644
--- a/src/script/nodes/functions/call_member_function.cpp
+++ b/src/script/nodes/functions/call_member_function.cpp
@@ -23,6 +23,7 @@
 #include "common/variant_utils.h"
 #include "common/version.h"
 #include "script/nodes/variables/variable_get.h"
+#include "script/script_server.h"
 
 #include <godot_cpp/classes/node3d.hpp>
 
@@ -138,7 +139,12 @@ StringName OScriptNodeCallMemberFunction::_get_method_class_hierarchy_owner(cons
     String class_name = p_class_name;
     while (!class_name.is_empty())
     {
-        const TypedArray<Dictionary> methods = ClassDB::class_get_method_list(class_name, true);
+        TypedArray<Dictionary> methods;
+        if (ScriptServer::is_global_class(class_name))
+            methods = ScriptServer::get_global_class(class_name).get_method_list();
+        else
+            methods = ClassDB::class_get_method_list(class_name, true);
+
         for (int index = 0; index < methods.size(); ++index)
         {
             const Dictionary& dict = methods[index];
diff --git a/src/script/nodes/functions/call_static_function.cpp b/src/script/nodes/functions/call_static_function.cpp
index 1dfd2577..ad6c8bf8 100644
--- a/src/script/nodes/functions/call_static_function.cpp
+++ b/src/script/nodes/functions/call_static_function.cpp
@@ -21,6 +21,7 @@
 #include "common/method_utils.h"
 #include "common/property_utils.h"
 #include "common/version.h"
+#include "script/script_server.h"
 
 class OScriptNodeCallStaticFunctionInstance : public OScriptNodeInstance
 {
@@ -115,7 +116,12 @@ bool OScriptNodeCallStaticFunction::_set(const StringName& p_name, const Variant
 void OScriptNodeCallStaticFunction::_resolve_method_info()
 {
     // Lookup the MethodInfo
-    TypedArray<Dictionary> methods = ClassDB::class_get_method_list(_class_name, true);
+    TypedArray<Dictionary> methods;
+    if (ScriptServer::is_global_class(_class_name))
+        methods = ScriptServer::get_global_class(_class_name).get_method_list();
+    else
+        methods = ClassDB::class_get_method_list(_class_name, true);
+
     for (int i = 0; i < methods.size(); i++)
     {
         const Dictionary& dict = methods[i];
diff --git a/src/script/nodes/properties/property.cpp b/src/script/nodes/properties/property.cpp
index aad865ad..3076843d 100644
--- a/src/script/nodes/properties/property.cpp
+++ b/src/script/nodes/properties/property.cpp
@@ -18,6 +18,7 @@
 
 #include "common/dictionary_utils.h"
 #include "script/script.h"
+#include "script/script_server.h"
 
 #include <godot_cpp/classes/engine.hpp>
 #include <godot_cpp/classes/node.hpp>
@@ -133,9 +134,28 @@ bool OScriptNodeProperty::_set(const StringName& p_name, const Variant& p_value)
     return false;
 }
 
+bool OScriptNodeProperty::_property_exists(const TypedArray<Dictionary>& p_properties) const
+{
+    for (int index = 0; index < p_properties.size(); ++index)
+    {
+        const Dictionary& property = p_properties[index];
+        if (property.has("name") && _property.name.match(property["name"]))
+            return true;
+    }
+    return false;
+}
+
+TypedArray<Dictionary> OScriptNodeProperty::_get_class_property_list(const String& p_class_name) const
+{
+    if (ScriptServer::is_global_class(p_class_name))
+        return ScriptServer::get_global_class(p_class_name).get_property_list();
+
+    return ClassDB::class_get_property_list(p_class_name);
+}
+
 bool OScriptNodeProperty::_get_class_property(const String& p_class_name, const String& p_name, PropertyInfo& r_property)
 {
-    TypedArray<Dictionary> properties = ClassDB::class_get_property_list(p_class_name);
+    const TypedArray<Dictionary> properties = _get_class_property_list(p_class_name);
     for (int index = 0; index < properties.size(); index++)
     {
         const Dictionary& dict = properties[index];
@@ -281,26 +301,54 @@ void OScriptNodeProperty::initialize(const OScriptNodeInitContext& p_context)
 
 void OScriptNodeProperty::validate_node_during_build(BuildLog& p_log) const
 {
-    if (_call_mode != CALL_NODE_PATH)
+    if (_call_mode == CALL_INSTANCE)
     {
-        bool found = false;
-
-        const String class_name = _call_mode == CALL_INSTANCE ? _base_type : get_orchestration()->get_base_type();
-        const TypedArray<Dictionary> properties = ClassDB::class_get_property_list(class_name);
-        for (int i = 0; i < properties.size(); i++)
+        const Ref<OScriptNodePin> target = find_pin("target", PD_Input);
+        if (!target->has_any_connections())
+        {
+            p_log.error(this, "Requires a connection.");
+        }
+        else
         {
-            const Dictionary& property = properties[i];
-            if (property.has("name") && _property.name.match(property["name"]))
+            const Ref<OScriptNodePin> source = target->get_connections()[0];
+            const Ref<OScriptTargetObject> target_object = source->resolve_target();
+            if (!target_object.is_valid() || !target_object->has_target())
             {
-                found = true;
-                break;
+                p_log.error(this, "No valid target was found.");
             }
-        }
+            else
+            {
+                const Ref<Script> script = target_object->get_target()->get_script();
+                const bool script_property = script.is_valid() && _property_exists(script->get_script_property_list());
+                const bool object_property = _property_exists(target_object->get_target()->get_property_list());
 
-        if (!found)
-            p_log.error(this, vformat("No property named '%s' on class '%s'", _property.name, class_name));
+                if (!script_property && !object_property)
+                    p_log.error(this, vformat("No property name '%s' found", _property.name));
+            }
+        }
+    }
+    else if (_call_mode == CALL_SELF)
+    {
+        const String base_type = get_orchestration()->get_base_type();
+        if (!_property_exists(_get_class_property_list(base_type)))
+            p_log.error(this, vformat("No property named '%s' on class '%s'", _property.name, base_type));
     }
+    else if (_call_mode == CALL_NODE_PATH)
+    {
+        if (SceneTree* st = Object::cast_to<SceneTree>(Engine::get_singleton()->get_main_loop()))
+        {
+            // Only if the node is found in the current edited scene, validate existance of property
+            if (Node* node = st->get_edited_scene_root()->get_node_or_null(_node_path))
+            {
+                const Ref<Script> script = node->get_script();
+                const bool script_property = script.is_valid() && _property_exists(script->get_script_property_list());
+                const bool object_property = _property_exists(node->get_property_list());
 
+                if (!script_property && !object_property)
+                    p_log.error(this, vformat("No property name '%s' found for node path '%s'.", _property.name, _node_path));
+            }
+        }
+    }
     super::validate_node_during_build(p_log);
 }
 
diff --git a/src/script/nodes/properties/property.h b/src/script/nodes/properties/property.h
index e5258763..609d85b4 100644
--- a/src/script/nodes/properties/property.h
+++ b/src/script/nodes/properties/property.h
@@ -58,6 +58,16 @@ class OScriptNodeProperty : public OScriptNode
     bool _set(const StringName& p_name, const Variant& p_value);
     //~ End Wrapped Interface
 
+    /// Checks whether a property exists with the given name in the array
+    /// @param p_properties an array of properties
+    /// @return true if the property exists, false otherwise
+    bool _property_exists(const TypedArray<Dictionary>& p_properties) const;
+
+    /// Gets the property list for a given class name
+    /// @param p_class_name the class name
+    /// @return array of properties
+    TypedArray<Dictionary> _get_class_property_list(const String& p_class_name) const;
+
     /// Gets the class property if found
     /// @param p_class_name the class name
     /// @param p_name the property name
diff --git a/src/script/nodes/properties/property_get.cpp b/src/script/nodes/properties/property_get.cpp
index 6023b491..86f114f4 100644
--- a/src/script/nodes/properties/property_get.cpp
+++ b/src/script/nodes/properties/property_get.cpp
@@ -93,9 +93,15 @@ void OScriptNodePropertyGet::allocate_default_pins()
 String OScriptNodePropertyGet::get_tooltip_text() const
 {
     if (!_property.name.is_empty())
-        return vformat("Returns the value the property '%s'", _property.name);
-    else
-        return "Returns the value of a given property";
+    {
+        String tooltip = vformat("Returns the value of the property '%s'.", _property.name);
+        if (!_node_path.is_empty())
+            tooltip += "\nNode Path: " + _node_path;
+
+        return tooltip;
+    }
+
+    return "Returns the value of a given property";
 }
 
 String OScriptNodePropertyGet::get_node_title() const
diff --git a/src/script/nodes/properties/property_set.cpp b/src/script/nodes/properties/property_set.cpp
index 4914ef4f..972d4339 100644
--- a/src/script/nodes/properties/property_set.cpp
+++ b/src/script/nodes/properties/property_set.cpp
@@ -86,7 +86,13 @@ void OScriptNodePropertySet::allocate_default_pins()
 String OScriptNodePropertySet::get_tooltip_text() const
 {
     if (!_property.name.is_empty())
-        return vformat("Set the value for the property '%s'", _property.name);
+    {
+        String tooltip = vformat("Sets the value of the property '%s'", _property.name);
+        if (!_node_path.is_empty())
+            tooltip += "\nNode Path: " + _node_path;
+
+        return tooltip;
+    }
 
     return "Sets the value for a given property";
 }
diff --git a/src/script/nodes/utilities/engine_singleton.cpp b/src/script/nodes/utilities/engine_singleton.cpp
index e6c09999..faf13a33 100644
--- a/src/script/nodes/utilities/engine_singleton.cpp
+++ b/src/script/nodes/utilities/engine_singleton.cpp
@@ -109,7 +109,7 @@ String OScriptNodeEngineSingleton::get_icon() const
 
 PackedStringArray OScriptNodeEngineSingleton::get_keywords() const
 {
-    return Engine::get_singleton()->get_singleton_list();
+    return {};
 }
 
 StringName OScriptNodeEngineSingleton::resolve_type_class(const Ref<OScriptNodePin>& p_pin) const
diff --git a/src/script/script.cpp b/src/script/script.cpp
index ac0d93ce..d423f252 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -176,7 +176,7 @@ bool OScript::_inherits_script(const Ref<Script>& p_script) const
 
 StringName OScript::_get_global_name() const
 {
-    return "Orchestration";
+    return "";
 }
 
 StringName OScript::_get_instance_base_type() const
diff --git a/src/script/script_server.cpp b/src/script/script_server.cpp
new file mode 100644
index 00000000..1190f1ae
--- /dev/null
+++ b/src/script/script_server.cpp
@@ -0,0 +1,158 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "script/script_server.h"
+
+#include <godot_cpp/classes/node.hpp>
+#include <godot_cpp/classes/project_settings.hpp>
+#include <godot_cpp/classes/resource_loader.hpp>
+#include <godot_cpp/classes/script.hpp>
+
+TypedArray<Dictionary> ScriptServer::GlobalClass::get_property_list() const
+{
+    const Ref<Script> script = ResourceLoader::get_singleton()->load(path, "", ResourceLoader::CACHE_MODE_IGNORE);
+    return script.is_valid() ? script->get_script_property_list() : TypedArray<Dictionary>();
+}
+
+TypedArray<Dictionary> ScriptServer::GlobalClass::get_method_list() const
+{
+    const Ref<Script> script = ResourceLoader::get_singleton()->load(path, "", ResourceLoader::CACHE_MODE_IGNORE);
+    return script.is_valid() ? script->get_script_method_list() : TypedArray<Dictionary>();
+}
+
+TypedArray<Dictionary> ScriptServer::GlobalClass::get_signal_list() const
+{
+    const Ref<Script> script = ResourceLoader::get_singleton()->load(path, "", ResourceLoader::CACHE_MODE_IGNORE);
+    return script.is_valid() ? script->get_script_signal_list() : TypedArray<Dictionary>();
+}
+
+bool ScriptServer::GlobalClass::has_method(const StringName& p_method_name) const
+{
+    if (!name.is_empty() && !path.is_empty())
+    {
+        const TypedArray<Dictionary> methods = get_method_list();
+        for (int index = 0; index < methods.size(); ++index)
+        {
+            const Dictionary& dict = methods[index];
+            if (dict.has("name") && p_method_name.match(dict["name"]))
+                return true;
+        }
+    }
+    return false;
+}
+
+bool ScriptServer::GlobalClass::has_property(const StringName& p_property_name) const
+{
+    if (!name.is_empty() && !path.is_empty())
+    {
+        const TypedArray<Dictionary> properties = get_property_list();
+        for (int index = 0; index < properties.size(); ++index)
+        {
+            const Dictionary& dict = properties[index];
+            if (dict.has("name") && p_property_name.match(dict["name"]))
+                return true;
+        }
+    }
+    return false;
+}
+
+bool ScriptServer::GlobalClass::has_signal(const StringName& p_signal_name) const
+{
+    if (!name.is_empty() && !path.is_empty())
+    {
+        const TypedArray<Dictionary> signals = get_signal_list();
+        for (int index = 0; index < signals.size(); ++index)
+        {
+            const Dictionary& dict = signals[index];
+            if (dict.has("name") && p_signal_name.match(dict["name"]))
+                return true;
+        }
+    }
+    return false;
+}
+
+Dictionary ScriptServer::_get_global_class(const StringName& p_class_name)
+{
+    TypedArray<Dictionary> global_classes = ProjectSettings::get_singleton()->get_global_class_list();
+    for (int index = 0; index < global_classes.size(); ++index)
+    {
+        const Dictionary& entry = global_classes[index];
+        if (entry.has("class") && p_class_name.match(entry["class"]))
+            return entry;
+    }
+    return {};
+}
+
+bool ScriptServer::is_global_class(const StringName& p_class_name)
+{
+    return !_get_global_class(p_class_name).is_empty();
+}
+
+bool ScriptServer::is_parent_class(const StringName& p_source_class_name, const StringName& p_target_class_name)
+{
+    return get_class_hierarchy(p_source_class_name, true).has(p_target_class_name);
+}
+
+ScriptServer::GlobalClass ScriptServer::get_global_class(const StringName& p_class_name)
+{
+    GlobalClass global_class;
+
+    const Dictionary entry = _get_global_class(p_class_name);
+    if (!entry.is_empty())
+    {
+        global_class.name = entry["class"];
+        global_class.base_type = entry["base"];
+        global_class.path = entry["path"];
+        global_class.language = entry["language"];
+
+        if (entry.has("icon"))
+            global_class.icon_path = entry["icon"];
+    }
+    return global_class;
+}
+
+StringName ScriptServer::get_native_class_name(const StringName& p_class_name)
+{
+    PackedStringArray hierarchy = get_class_hierarchy(p_class_name, true);
+    for (const String& class_name : hierarchy)
+    {
+        if (!is_global_class(class_name))
+            return class_name;
+    }
+    return Object::get_class_static();
+}
+
+PackedStringArray ScriptServer::get_class_hierarchy(const StringName& p_class_name, bool p_include_native_classes)
+{
+    PackedStringArray hierarchy;
+    StringName class_name = p_class_name;
+    while (!class_name.is_empty())
+    {
+        if (is_global_class(class_name))
+        {
+            hierarchy.push_back(class_name);
+            class_name = get_global_class(class_name).base_type;
+        }
+        else if (p_include_native_classes)
+        {
+            hierarchy.push_back(class_name);
+            class_name = ClassDB::get_parent_class(class_name);
+        }
+        else
+            break;
+    }
+    return hierarchy;
+}
\ No newline at end of file
diff --git a/src/script/script_server.h b/src/script/script_server.h
new file mode 100644
index 00000000..e6242594
--- /dev/null
+++ b/src/script/script_server.h
@@ -0,0 +1,101 @@
+// This file is part of the Godot Orchestrator project.
+//
+// Copyright (c) 2023-present Vahera Studios LLC and its contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//		http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef ORCHESTRATOR_SCRIPT_SERVER_H
+#define ORCHESTRATOR_SCRIPT_SERVER_H
+
+#include <godot_cpp/variant/typed_array.hpp>
+#include <godot_cpp/variant/variant.hpp>
+
+using namespace godot;
+
+/// A helper class to accessing methods similarly found in Godot's ScriptServer.
+class ScriptServer
+{
+public:
+    /// Represents a Global Class entry in the script server.
+    struct GlobalClass
+    {
+        StringName name;        //! Global class name
+        StringName base_type;   //! The type that the global class extends
+        String icon_path;       //! The path to the `@icon`
+        String path;            //! The path to the global class script
+        String language;        //! Language that contributes the class
+
+        /// Returns the list of properties on the global class
+        /// @return an array of dictionary entries for properties
+        TypedArray<Dictionary> get_property_list() const;
+
+        /// Returns the list of methods on the global class
+        /// @return an array of dictionary entries for methods
+        TypedArray<Dictionary> get_method_list() const;
+
+        /// Returns the list of signals on the global class
+        /// @return an array of dictionary entries for signals
+        TypedArray<Dictionary> get_signal_list() const;
+
+        /// Checks whether the method name exists for the global class
+        /// @param p_method_name the method name to check
+        /// @return true if the method exists, false otherwise
+        bool has_method(const StringName& p_method_name) const;
+
+        /// Checks whether the property exists for the global class
+        /// @param p_property_name the property name to check
+        /// @return true if the property exists, false otherwise
+        bool has_property(const StringName& p_property_name) const;
+
+        /// Checks whether the signal exists for the global class
+        /// @param p_signal_name the signal name to check
+        /// @return true if the signal exists, false otherwise
+        bool has_signal(const StringName& p_signal_name) const;
+    };
+
+protected:
+    /// Get the global class dictionary entry
+    /// @param p_class_name the global class name to find
+    /// @return the dictionary for the global class, or an empty dictionary if not found
+    static Dictionary _get_global_class(const StringName& p_class_name);
+
+public:
+    /// Checks whether the specified class name is a global script class.
+    /// @param p_class_name the global class name to check
+    /// @return true if the class is a global class, or false if not
+    static bool is_global_class(const StringName& p_class_name);
+
+    /// Checks whether the specified source class name is descendent of the target class.
+    /// @param p_source_class_name the source class name
+    /// @param p_target_class_name the target class_name
+    /// @return true if the source is a descendant of the target class, false otherwise
+    static bool is_parent_class(const StringName& p_source_class_name, const StringName& p_target_class_name);
+
+    /// Returns the global class entry for a specified class name.
+    /// @param p_class_name the global class name to check
+    /// @return the global class info structure, or an empty structure if not found
+    static GlobalClass get_global_class(const StringName& p_class_name);
+
+    /// Returns the native class for which this global class derives
+    /// @param p_class_name the global class name
+    /// @return the native class name
+    static StringName get_native_class_name(const StringName& p_class_name);
+
+    /// Returns a list of class hierarchies, starting with the global class first
+    /// @param p_class_name the global class name to check
+    /// @param p_include_native_classes if true, all native classes are included in bottom-up order
+    /// @return all classes in the hierarchy, in bottom-up order
+    static PackedStringArray get_class_hierarchy(const StringName& p_class_name, bool p_include_native_classes = false);
+};
+
+#endif // ORCHESTRATOR_SCRIPT_SERVER_H
\ No newline at end of file