diff --git a/ReflectorNet.Tests/src/Utils/AssemblyUtilsTests.cs b/ReflectorNet.Tests/src/Utils/AssemblyUtilsTests.cs
new file mode 100644
index 00000000..e73240b2
--- /dev/null
+++ b/ReflectorNet.Tests/src/Utils/AssemblyUtilsTests.cs
@@ -0,0 +1,502 @@
+/*
+ * ReflectorNet
+ * Author: Ivan Murzak (https://github.com/IvanMurzak)
+ * Copyright (c) 2025 Ivan Murzak
+ * Licensed under the Apache License, Version 2.0. See LICENSE file in the project root for full license information.
+ */
+
+using com.IvanMurzak.ReflectorNet.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace com.IvanMurzak.ReflectorNet.Tests.Utils
+{
+    public class AssemblyUtilsTests
+    {
+        #region GetAssemblyTypes Tests
+
+        [Fact]
+        public void GetAssemblyTypes_CurrentAssembly_ReturnsTypes()
+        {
+            // Arrange
+            var assembly = typeof(AssemblyUtilsTests).Assembly;
+
+            // Act
+            var types = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert
+            Assert.NotNull(types);
+            Assert.NotEmpty(types);
+            Assert.Contains(typeof(AssemblyUtilsTests), types);
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_MscorlibAssembly_ReturnsTypes()
+        {
+            // Arrange
+            var assembly = typeof(object).Assembly;
+
+            // Act
+            var types = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert
+            Assert.NotNull(types);
+            Assert.NotEmpty(types);
+            Assert.Contains(typeof(object), types);
+            Assert.Contains(typeof(string), types);
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_SameAssembly_ReturnsDifferentInstances()
+        {
+            // Arrange
+            var assembly = typeof(AssemblyUtilsTests).Assembly;
+
+            // Act
+            var types1 = AssemblyUtils.GetAssemblyTypes(assembly);
+            var types2 = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert - should return different array instances (no caching)
+            Assert.NotSame(types1, types2);
+            Assert.Equal(types1.Length, types2.Length);
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_MultipleAssemblies_ReturnsDifferentArrays()
+        {
+            // Arrange
+            var testAssembly = typeof(AssemblyUtilsTests).Assembly;
+            var coreAssembly = typeof(object).Assembly;
+
+            // Act
+            var testTypes = AssemblyUtils.GetAssemblyTypes(testAssembly);
+            var coreTypes = AssemblyUtils.GetAssemblyTypes(coreAssembly);
+
+            // Assert
+            Assert.NotSame(testTypes, coreTypes);
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_ReturnsNonNullTypes()
+        {
+            // Arrange
+            var assembly = typeof(AssemblyUtilsTests).Assembly;
+
+            // Act
+            var types = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert
+            Assert.All(types, t => Assert.NotNull(t));
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_ReflectorNetAssembly_ContainsExpectedTypes()
+        {
+            // Arrange
+            var assembly = typeof(AssemblyUtils).Assembly;
+
+            // Act
+            var types = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert
+            Assert.Contains(types, t => t.Name == "AssemblyUtils");
+            Assert.Contains(types, t => t.Name == "TypeUtils");
+            Assert.Contains(types, t => t.Name == "Reflector");
+        }
+
+        #endregion
+
+        #region AllAssemblies Tests
+
+        [Fact]
+        public void AllAssemblies_ReturnsAssemblies()
+        {
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert
+            Assert.NotEmpty(allAssemblies);
+        }
+
+        [Fact]
+        public void AllAssemblies_ContainsCurrentTestAssembly()
+        {
+            // Arrange
+            var testAssembly = typeof(AssemblyUtilsTests).Assembly;
+
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert
+            Assert.Contains(testAssembly, allAssemblies);
+        }
+
+        [Fact]
+        public void AllAssemblies_ContainsReflectorNetAssembly()
+        {
+            // Arrange
+            var reflectorAssembly = typeof(AssemblyUtils).Assembly;
+
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert
+            Assert.Contains(reflectorAssembly, allAssemblies);
+        }
+
+        [Fact]
+        public void AllAssemblies_ContainsCoreLibAssembly()
+        {
+            // Arrange
+            var coreLibAssembly = typeof(object).Assembly;
+
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert
+            Assert.Contains(coreLibAssembly, allAssemblies);
+        }
+
+        [Fact]
+        public void AllAssemblies_AllAssembliesAreNotNull()
+        {
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert
+            Assert.All(allAssemblies, a => Assert.NotNull(a));
+        }
+
+        [Fact]
+        public void AllAssemblies_MultipleEnumerations_Succeed()
+        {
+            // Act - enumerate multiple times
+            var count1 = AssemblyUtils.AllAssemblies.Count();
+            var count2 = AssemblyUtils.AllAssemblies.Count();
+
+            // Assert - both enumerations should return assemblies
+            // Note: counts may differ slightly if new assemblies are loaded between enumerations
+            Assert.True(count1 > 0, "First enumeration should return assemblies");
+            Assert.True(count2 > 0, "Second enumeration should return assemblies");
+            // The counts should be reasonably close (within 50 assemblies)
+            var difference = Math.Abs(count1 - count2);
+            Assert.True(difference <= 50,
+                $"Counts differ too much: {count1} vs {count2} (difference: {difference})");
+        }
+
+        [Fact]
+        public void AllAssemblies_CanIterateWithForeach()
+        {
+            // Act
+            var count = 0;
+            foreach (var assembly in AssemblyUtils.AllAssemblies)
+            {
+                Assert.NotNull(assembly);
+                count++;
+            }
+
+            // Assert
+            Assert.True(count > 0, "Should iterate at least one assembly");
+        }
+
+        [Fact]
+        public void AllAssemblies_ConcurrentEnumeration_Succeeds()
+        {
+            // Arrange
+            var counts = new int[5];
+
+            // Act - enumerate from multiple threads simultaneously
+            Parallel.For(0, 5, i =>
+            {
+                counts[i] = AssemblyUtils.AllAssemblies.Count();
+            });
+
+            // Assert - all counts should be positive
+            Assert.All(counts, c => Assert.True(c > 0));
+        }
+
+        [Fact]
+        public void AllAssemblies_ContainsMultipleAssemblies()
+        {
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+
+            // Assert - should have multiple assemblies loaded
+            Assert.True(allAssemblies.Count > 5, $"Expected more than 5 assemblies, got {allAssemblies.Count}");
+        }
+
+        [Fact]
+        public void AllAssemblies_NoDuplicates()
+        {
+            // Act
+            var allAssemblies = AssemblyUtils.AllAssemblies.ToList();
+            var distinctCount = allAssemblies.Distinct().Count();
+
+            // Assert
+            Assert.Equal(allAssemblies.Count, distinctCount);
+        }
+
+        #endregion
+
+        #region AllTypes Tests
+
+        [Fact]
+        public void AllTypes_ReturnsTypes()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.NotEmpty(allTypes);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsCommonTypes()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(typeof(object), allTypes);
+            Assert.Contains(typeof(string), allTypes);
+            Assert.Contains(typeof(int), allTypes);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsTestTypes()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(typeof(AssemblyUtilsTests), allTypes);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsAssemblyUtilsType()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(typeof(AssemblyUtils), allTypes);
+        }
+
+        [Fact]
+        public void AllTypes_AllTypesAreNotNull()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.All(allTypes, t => Assert.NotNull(t));
+        }
+
+        [Fact]
+        public void AllTypes_MultipleEnumerations_Succeed()
+        {
+            // Act - enumerate multiple times
+            var count1 = AssemblyUtils.AllTypes.Count();
+            var count2 = AssemblyUtils.AllTypes.Count();
+
+            // Assert - both enumerations should return types
+            // Note: counts may differ slightly if new assemblies are loaded between enumerations
+            Assert.True(count1 > 0, "First enumeration should return types");
+            Assert.True(count2 > 0, "Second enumeration should return types");
+            // The counts should be reasonably close (within 10% or 500 types)
+            var difference = Math.Abs(count1 - count2);
+            var maxAllowedDifference = Math.Max(500, count1 / 10);
+            Assert.True(difference <= maxAllowedDifference,
+                $"Counts differ too much: {count1} vs {count2} (difference: {difference})");
+        }
+
+        [Fact]
+        public void AllTypes_CanIterateWithForeach()
+        {
+            // Act
+            var count = 0;
+            foreach (var type in AssemblyUtils.AllTypes)
+            {
+                Assert.NotNull(type);
+                count++;
+                if (count > 100) break; // Don't iterate all to keep test fast
+            }
+
+            // Assert
+            Assert.True(count > 100);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsTypesFromMultipleAssemblies()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Get assemblies that contributed types
+            var assemblies = allTypes.Select(t => t.Assembly).Distinct().ToList();
+
+            // Assert - should have types from multiple assemblies
+            Assert.True(assemblies.Count > 1, "Should contain types from multiple assemblies");
+        }
+
+        #endregion
+
+        #region Thread Safety Tests
+
+        [Fact]
+        public void GetAssemblyTypes_ConcurrentAccess_ReturnsValidTypes()
+        {
+            // Arrange
+            var assembly = typeof(AssemblyUtilsTests).Assembly;
+            var results = new Type[10][];
+            using (var barrier = new Barrier(10))
+            {
+                // Act - access from multiple threads simultaneously
+                Parallel.For(0, 10, i =>
+                {
+                    barrier.SignalAndWait(); // Ensure all threads start at the same time
+                    results[i] = AssemblyUtils.GetAssemblyTypes(assembly);
+                });
+            }
+
+            // Assert - all should be valid and different instances
+            for (int i = 0; i < results.Length; i++)
+            {
+                Assert.NotNull(results[i]);
+                Assert.NotEmpty(results[i]);
+                if (i > 0)
+                {
+                    Assert.NotSame(results[0], results[i]);
+                }
+            }
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_ConcurrentAccessDifferentAssemblies_Succeeds()
+        {
+            // Arrange
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies().Take(10).ToArray();
+            var results = new Dictionary<Assembly, Type[]>();
+            var lockObj = new object();
+
+            // Act - access different assemblies from multiple threads
+            Parallel.ForEach(assemblies, assembly =>
+            {
+                var types = AssemblyUtils.GetAssemblyTypes(assembly);
+                lock (lockObj)
+                {
+                    results[assembly] = types;
+                }
+            });
+
+            // Assert
+            Assert.Equal(assemblies.Length, results.Count);
+            foreach (var kvp in results)
+            {
+                Assert.NotNull(kvp.Value);
+            }
+        }
+
+        [Fact]
+        public void AllTypes_ConcurrentEnumeration_Succeeds()
+        {
+            // Arrange
+            var counts = new int[5];
+
+            // Act - enumerate from multiple threads simultaneously
+            Parallel.For(0, 5, i =>
+            {
+                counts[i] = AssemblyUtils.AllTypes.Count();
+            });
+            for (int i = 1; i < counts.Length; i++)
+            {
+                var diff = Math.Abs(counts[0] - counts[i]);
+                Assert.Equal(counts[0], counts[i]);
+            }
+        }
+
+        #endregion
+
+        #region Edge Cases
+
+        [Fact]
+        public void AllTypes_ContainsGenericTypeDefinitions()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert - should contain generic type definitions like List<>
+            Assert.Contains(allTypes, t => t.IsGenericTypeDefinition);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsNestedTypes()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert - should contain nested types
+            Assert.Contains(allTypes, t => t.IsNested);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsInterfaces()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(allTypes, t => t.IsInterface);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsAbstractClasses()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(allTypes, t => t.IsAbstract && t.IsClass);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsEnums()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(allTypes, t => t.IsEnum);
+        }
+
+        [Fact]
+        public void AllTypes_ContainsStructs()
+        {
+            // Act
+            var allTypes = AssemblyUtils.AllTypes.ToList();
+
+            // Assert
+            Assert.Contains(allTypes, t => t.IsValueType && !t.IsEnum && !t.IsPrimitive);
+        }
+
+        [Fact]
+        public void GetAssemblyTypes_SystemAssembly_ContainsExceptionTypes()
+        {
+            // Arrange
+            var assembly = typeof(Exception).Assembly;
+
+            // Act
+            var types = AssemblyUtils.GetAssemblyTypes(assembly);
+
+            // Assert
+            Assert.Contains(types, t => typeof(Exception).IsAssignableFrom(t));
+        }
+
+        #endregion
+
+    }
+}
diff --git a/ReflectorNet/ReflectorNet.csproj b/ReflectorNet/ReflectorNet.csproj
index 19e22289..b3a67747 100644
--- a/ReflectorNet/ReflectorNet.csproj
+++ b/ReflectorNet/ReflectorNet.csproj
@@ -9,7 +9,7 @@
 
     <!-- NuGet Package Information -->
     <PackageId>com.IvanMurzak.ReflectorNet</PackageId>
-    <Version>3.3.1</Version>
+    <Version>3.4.0</Version>
     <Authors>Ivan Murzak</Authors>
     <Copyright>Copyright © Ivan Murzak 2025</Copyright>
     <Description>ReflectorNet is an advanced .NET reflection toolkit designed for AI-driven scenarios. Effortlessly search for C# methods using natural language queries, invoke any method by supplying arguments as JSON, and receive results as JSON. The library also provides a powerful API to inspect, modify, and manage in-memory object instances dynamically via JSON data. Ideal for automation, testing, and AI integration workflows.</Description>
diff --git a/ReflectorNet/src/Reflector/Reflector.FindMethod.cs b/ReflectorNet/src/Reflector/Reflector.FindMethod.cs
index 27653a1f..2ac403a1 100644
--- a/ReflectorNet/src/Reflector/Reflector.FindMethod.cs
+++ b/ReflectorNet/src/Reflector/Reflector.FindMethod.cs
@@ -9,7 +9,7 @@ namespace com.IvanMurzak.ReflectorNet
 {
     public partial class Reflector
     {
-        public static IEnumerable<MethodInfo> AllMethods => TypeUtils.AllTypes
+        public static IEnumerable<MethodInfo> AllMethods => AssemblyUtils.AllTypes
             .SelectMany(type => type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static))
             .Where(method => method.DeclaringType != null && !method.DeclaringType.IsAbstract);
 
@@ -152,7 +152,7 @@ public IEnumerable<MethodInfo> FindMethod(
             // Prepare Namespace
             filter.Namespace = filter.Namespace?.Trim()?.Replace(StringUtils.Null, string.Empty);
 
-            var typesEnumerable = TypeUtils.AllTypes
+            var typesEnumerable = AssemblyUtils.AllTypes
                 .Where(type => type.IsVisible)
                 .Where(type => !type.IsInterface)
                 .Where(type => !type.IsAbstract || type.IsSealed)
diff --git a/ReflectorNet/src/Utils/AssemblyUtils.cs b/ReflectorNet/src/Utils/AssemblyUtils.cs
new file mode 100644
index 00000000..18c3b643
--- /dev/null
+++ b/ReflectorNet/src/Utils/AssemblyUtils.cs
@@ -0,0 +1,97 @@
+/*
+ * ReflectorNet
+ * Author: Ivan Murzak (https://github.com/IvanMurzak)
+ * Copyright (c) 2025 Ivan Murzak
+ * Licensed under the Apache License, Version 2.0. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace com.IvanMurzak.ReflectorNet.Utils
+{
+    public static class AssemblyUtils
+    {
+        /// <summary>
+        /// Gets all assemblies loaded in the current application domain with exception protection.
+        /// </summary>
+        public static IEnumerable<Assembly> AllAssemblies
+        {
+            get
+            {
+                Assembly[] assemblies;
+                try
+                {
+                    assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                }
+                catch (AppDomainUnloadedException)
+                {
+                    yield break;
+                }
+
+                for (int i = 0; i < assemblies.Length; i++)
+                {
+                    yield return assemblies[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets all types from all loaded assemblies with exception protection.
+        /// </summary>
+        public static IEnumerable<Type> AllTypes
+        {
+            get
+            {
+                foreach (var assembly in AllAssemblies)
+                {
+                    var types = GetAssemblyTypes(assembly);
+                    for (int i = 0; i < types.Length; i++)
+                    {
+                        yield return types[i];
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets all types from an assembly.
+        /// </summary>
+        /// <remarks>
+        /// This method handles exceptions gracefully to ensure robust type enumeration:
+        /// <list type="bullet">
+        /// <item><description><see cref="ReflectionTypeLoadException"/>: Returns only the types that loaded successfully.
+        /// This commonly occurs when an assembly references types from dependencies that are not loaded.</description></item>
+        /// <item><description>Other exceptions (e.g., <see cref="System.IO.FileNotFoundException"/>, <see cref="BadImageFormatException"/>):
+        /// Returns an empty array. These can occur with dynamic assemblies, native assemblies, or corrupted modules.</description></item>
+        /// </list>
+        /// </remarks>
+        /// <param name="assembly">The assembly to get types from.</param>
+        /// <returns>Array of types from the assembly. May be empty if the assembly cannot be inspected.</returns>
+        public static Type[] GetAssemblyTypes(Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                // Some types failed to load (e.g., missing dependencies).
+                // Return the types that did load successfully.
+                return ex.Types
+                    ?.Where(t => t != null)
+                    .Select(x => x!)
+                    .ToArray() ?? Array.Empty<Type>();
+            }
+            catch
+            {
+                // Other exceptions (FileNotFoundException, BadImageFormatException, etc.)
+                // can occur with dynamic assemblies, native assemblies, or corrupted modules.
+                // Return empty array to allow enumeration to continue with other assemblies.
+                return Array.Empty<Type>();
+            }
+        }
+    }
+}
diff --git a/ReflectorNet/src/Utils/TypeUtils.cs b/ReflectorNet/src/Utils/TypeUtils.cs
index dbb0adc4..e041e5dd 100644
--- a/ReflectorNet/src/Utils/TypeUtils.cs
+++ b/ReflectorNet/src/Utils/TypeUtils.cs
@@ -17,12 +17,43 @@ namespace com.IvanMurzak.ReflectorNet.Utils
 {
     public static partial class TypeUtils
     {
-        public static IEnumerable<Type> AllTypes => AppDomain.CurrentDomain.GetAssemblies()
-            .SelectMany(assembly => assembly.GetTypes());
+        /// <summary>
+        /// Gets all types from all loaded assemblies.
+        /// </summary>
+        /// <remarks>
+        /// This property delegates to <see cref="AssemblyUtils.AllTypes"/> and provides
+        /// exception-safe enumeration of types across all loaded assemblies.
+        /// </remarks>
+        public static IEnumerable<Type> AllTypes => AssemblyUtils.AllTypes;
 
         // Cache for resolved type names to avoid repeated AllTypes enumeration (thread-safe)
-        private static readonly ConcurrentDictionary<string, Type?> _typeCache = new ConcurrentDictionary<string, Type?>();
+        private static readonly ConcurrentDictionary<string, Type?> _typeCache = new();
+
+        /// <summary>
+        /// Clears the type name resolution cache.
+        /// </summary>
+        public static void ClearTypeCache()
+        {
+            _typeCache.Clear();
+        }
 
+        /// <summary>
+        /// Resolves a <see cref="Type"/> from its string representation.
+        /// </summary>
+        /// <remarks>
+        /// This method attempts to resolve types using multiple strategies in order:
+        /// <list type="number">
+        /// <item><description>Built-in <see cref="Type.GetType(string)"/></description></item>
+        /// <item><description>Array type resolution (e.g., "Namespace.Type[]", "int[,]")</description></item>
+        /// <item><description>C#-style generic types (e.g., "List&lt;int&gt;", "Dictionary&lt;string, int&gt;")</description></item>
+        /// <item><description>CLR-style generic types (e.g., "System.Collections.Generic.List`1[[System.Int32]]")</description></item>
+        /// <item><description>Search across all loaded assemblies by FullName, AssemblyQualifiedName, or TypeId</description></item>
+        /// </list>
+        /// Results are cached for performance. Use <see cref="ClearTypeCache"/> to clear the cache.
+        /// </remarks>
+        /// <param name="typeName">The type name to resolve. Can be a simple name, full name, assembly-qualified name,
+        /// or C#-style generic syntax.</param>
+        /// <returns>The resolved <see cref="Type"/>, or <c>null</c> if the type cannot be found.</returns>
         public static Type? GetType(string? typeName)
         {
             if (string.IsNullOrWhiteSpace(typeName))
@@ -74,7 +105,7 @@ public static partial class TypeUtils
             }
 
             // If Type.GetType() fails, try to find the type in all loaded assemblies
-            type = AllTypes.FirstOrDefault(t =>
+            type = AssemblyUtils.AllTypes.FirstOrDefault(t =>
                 typeName == t.FullName ||
                 typeName == t.AssemblyQualifiedName ||
                 typeName == t.GetTypeId());
@@ -94,7 +125,7 @@ public static partial class TypeUtils
             if (type != null)
                 return type;
 
-            return AllTypes.FirstOrDefault(t =>
+            return AssemblyUtils.AllTypes.FirstOrDefault(t =>
                 name == t.AssemblyQualifiedName ||
                 name == t.FullName ||
                 name == t.Name);
@@ -469,6 +500,12 @@ private static int FindMatchingCloseBracket(string typeName, int openIndex)
             return args.Count > 0 ? args.ToArray() : null;
         }
 
+        /// <summary>
+        /// Determines whether the specified type is a dictionary type.
+        /// </summary>
+        /// <param name="type">The type to check.</param>
+        /// <returns><c>true</c> if the type is <see cref="Dictionary{TKey, TValue}"/>,
+        /// <see cref="IDictionary{TKey, TValue}"/>, or implements <see cref="IDictionary{TKey, TValue}"/>.</returns>
         public static bool IsDictionary(Type type)
         {
             if (type.IsGenericType &&
@@ -482,6 +519,11 @@ public static bool IsDictionary(Type type)
                 .Any(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(IDictionary<,>)));
         }
 
+        /// <summary>
+        /// Gets the key and value types from a dictionary type.
+        /// </summary>
+        /// <param name="type">The dictionary type to inspect.</param>
+        /// <returns>An array containing [TKey, TValue] types, or <c>null</c> if the type is not a dictionary.</returns>
         public static Type[]? GetDictionaryGenericArguments(Type type)
         {
             if (type.IsGenericType &&
@@ -497,6 +539,12 @@ public static bool IsDictionary(Type type)
             return dictionaryInterface?.GetGenericArguments();
         }
 
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a type.
+        /// </summary>
+        /// <param name="type">The type to get the description from.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.
+        /// Falls back to the base type's description if the type itself has none.</returns>
         public static string? GetDescription(Type type)
         {
             return type
@@ -506,6 +554,13 @@ public static bool IsDictionary(Type type)
                     ? GetDescription(type.BaseType!)
                     : null);
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a parameter.
+        /// </summary>
+        /// <param name="parameterInfo">The parameter to get the description from.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.
+        /// Falls back to the parameter type's description if the parameter itself has none.</returns>
         public static string? GetDescription(ParameterInfo? parameterInfo)
         {
             return parameterInfo
@@ -515,6 +570,13 @@ public static bool IsDictionary(Type type)
                     ? GetDescription(parameterInfo.ParameterType)
                     : null);
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a member.
+        /// </summary>
+        /// <param name="memberInfo">The member to get the description from.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.
+        /// For fields and properties, falls back to the member type's description.</returns>
         public static string? GetDescription(MemberInfo? memberInfo)
         {
             if (memberInfo == null)
@@ -534,6 +596,13 @@ public static bool IsDictionary(Type type)
                 _ => null
             };
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a field.
+        /// </summary>
+        /// <param name="fieldInfo">The field to get the description from.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.
+        /// Falls back to the field type's description if the field itself has none.</returns>
         public static string? GetFieldDescription(FieldInfo? fieldInfo)
         {
             if (fieldInfo == null)
@@ -546,6 +615,13 @@ public static bool IsDictionary(Type type)
                     ? GetDescription(fieldInfo.FieldType)
                     : null);
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a property.
+        /// </summary>
+        /// <param name="propertyInfo">The property to get the description from.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.
+        /// Falls back to the property type's description if the property itself has none.</returns>
         public static string? GetPropertyDescription(PropertyInfo? propertyInfo)
         {
             if (propertyInfo == null)
@@ -558,12 +634,32 @@ public static bool IsDictionary(Type type)
                     ? GetDescription(propertyInfo.PropertyType)
                     : null);
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a property by name.
+        /// </summary>
+        /// <param name="type">The type containing the property.</param>
+        /// <param name="propertyName">The name of the property.</param>
+        /// <returns>The description string, or <c>null</c> if the property is not found or has no description.</returns>
         public static string? GetPropertyDescription(Type type, string propertyName)
         {
             var propertyInfo = type.GetProperty(propertyName);
             return propertyInfo != null ? GetPropertyDescription(propertyInfo) : null;
         }
 #if NETSTANDARD2_1_OR_GREATER || NET8_0_OR_GREATER
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> using JSON schema exporter context.
+        /// </summary>
+        /// <remarks>
+        /// This method handles JSON naming policy transformations by attempting to match:
+        /// <list type="number">
+        /// <item><description>Exact name match</description></item>
+        /// <item><description>PascalCase conversion from camelCase</description></item>
+        /// <item><description>Case-insensitive match</description></item>
+        /// </list>
+        /// </remarks>
+        /// <param name="context">The JSON schema exporter context containing property information.</param>
+        /// <returns>The description string, or <c>null</c> if no description is found.</returns>
         public static string? GetPropertyDescription(System.Text.Json.Schema.JsonSchemaExporterContext context)
         {
             if (context.PropertyInfo == null || context.PropertyInfo.DeclaringType == null)
@@ -610,6 +706,13 @@ private static string ToPascalCase(string camelCase)
 
             return char.ToUpperInvariant(camelCase[0]) + camelCase.Substring(1);
         }
+
+        /// <summary>
+        /// Gets the description from a <see cref="DescriptionAttribute"/> on a field by name.
+        /// </summary>
+        /// <param name="type">The type containing the field.</param>
+        /// <param name="fieldName">The name of the field.</param>
+        /// <returns>The description string, or <c>null</c> if the field is not found or has no description.</returns>
         public static string? GetFieldDescription(Type type, string fieldName)
         {
             var fieldInfo = type.GetField(fieldName);
@@ -636,6 +739,21 @@ public static bool IsAssignableTo(object? obj, Type targetType)
             return targetType.IsAssignableFrom(obj.GetType());
         }
 
+        /// <summary>
+        /// Determines whether a type can be cast to another type.
+        /// </summary>
+        /// <remarks>
+        /// This method checks for:
+        /// <list type="bullet">
+        /// <item><description>Direct assignability (including inheritance)</description></item>
+        /// <item><description>Primitive type conversions</description></item>
+        /// <item><description>String to object conversion</description></item>
+        /// </list>
+        /// Nullable types are unwrapped before comparison.
+        /// </remarks>
+        /// <param name="type">The source type to cast from.</param>
+        /// <param name="to">The target type to cast to.</param>
+        /// <returns><c>true</c> if the cast is possible; otherwise, <c>false</c>.</returns>
         public static bool IsCastable(Type? type, Type to)
         {
             if (type == null || to == null)
@@ -662,6 +780,13 @@ public static bool IsCastable(Type? type, Type to)
             return false;
         }
 
+        /// <summary>
+        /// Calculates the inheritance distance between two types.
+        /// </summary>
+        /// <param name="baseType">The base type (ancestor).</param>
+        /// <param name="targetType">The target type (descendant).</param>
+        /// <returns>The number of inheritance levels between the types, or -1 if <paramref name="targetType"/>
+        /// does not inherit from <paramref name="baseType"/>.</returns>
         public static int GetInheritanceDistance(Type baseType, Type targetType)
         {
             if (!baseType.IsAssignableFrom(targetType))
@@ -676,6 +801,17 @@ public static int GetInheritanceDistance(Type baseType, Type targetType)
             }
             return current == baseType ? distance : -1;
         }
+
+        /// <summary>
+        /// Determines whether a type is considered a primitive type for serialization purposes.
+        /// </summary>
+        /// <remarks>
+        /// This includes CLR primitives, enums, and common value types:
+        /// <see cref="string"/>, <see cref="decimal"/>, <see cref="DateTime"/>,
+        /// <see cref="DateTimeOffset"/>, <see cref="TimeSpan"/>, and <see cref="Guid"/>.
+        /// </remarks>
+        /// <param name="type">The type to check.</param>
+        /// <returns><c>true</c> if the type is a primitive or primitive-like type.</returns>
         public static bool IsPrimitive(Type type)
         {
             return type.IsPrimitive ||
@@ -687,6 +823,13 @@ public static bool IsPrimitive(Type type)
                    type == typeof(TimeSpan) ||
                    type == typeof(Guid);
         }
+
+        /// <summary>
+        /// Recursively enumerates all generic type arguments from a type and its base types.
+        /// </summary>
+        /// <param name="type">The type to extract generic arguments from.</param>
+        /// <param name="visited">Optional set to track visited types and prevent infinite recursion.</param>
+        /// <returns>An enumerable of all generic type arguments found in the type hierarchy.</returns>
         public static IEnumerable<Type> GetGenericTypes(Type type, HashSet<int>? visited = null)
         {
             visited ??= new HashSet<int>();
@@ -722,6 +865,12 @@ public static IEnumerable<Type> GetGenericTypes(Type type, HashSet<int>? visited
             foreach (var baseGenericType in GetGenericTypes(type.BaseType, visited))
                 yield return baseGenericType;
         }
+
+        /// <summary>
+        /// Determines whether a type implements <see cref="IEnumerable{T}"/>.
+        /// </summary>
+        /// <param name="type">The type to check.</param>
+        /// <returns><c>true</c> if the type is an array or implements <see cref="IEnumerable{T}"/>.</returns>
         public static bool IsIEnumerable(Type type)
         {
             if (type.IsArray)
@@ -733,6 +882,12 @@ public static bool IsIEnumerable(Type type)
             return type.GetInterfaces()
                 .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>));
         }
+
+        /// <summary>
+        /// Gets the element type of an enumerable or array type.
+        /// </summary>
+        /// <param name="type">The enumerable type to inspect.</param>
+        /// <returns>The element type (T in <see cref="IEnumerable{T}"/>), or <c>null</c> if the type is not enumerable.</returns>
         public static Type? GetEnumerableItemType(Type type)
         {
             if (type.IsArray)
@@ -768,6 +923,14 @@ public static bool IsIEnumerable(Type type)
 
             return null;
         }
+
+        /// <summary>
+        /// Resolves a type with priority given to the object's runtime type.
+        /// </summary>
+        /// <param name="obj">The object whose runtime type to use (if not null).</param>
+        /// <param name="fallbackType">The fallback type to use if the object is null.</param>
+        /// <param name="error">Set to an error message if the type cannot be resolved; otherwise, <c>null</c>.</param>
+        /// <returns>The resolved type, or <c>null</c> if resolution fails.</returns>
         public static Type? GetTypeWithObjectPriority(object? obj, Type? fallbackType, out string? error)
         {
             var type = obj?.GetType() ?? fallbackType;
@@ -780,6 +943,14 @@ public static bool IsIEnumerable(Type type)
             error = null;
             return type;
         }
+
+        /// <summary>
+        /// Resolves a type with priority given to the <see cref="SerializedMember.typeName"/>.
+        /// </summary>
+        /// <param name="member">The serialized member containing the type name.</param>
+        /// <param name="fallbackType">The fallback type to use if the type name cannot be resolved.</param>
+        /// <param name="error">Set to an error message if the type cannot be resolved; otherwise, <c>null</c>.</param>
+        /// <returns>The resolved type, or <c>null</c> if resolution fails.</returns>
         public static Type? GetTypeWithNamePriority(SerializedMember? member, Type? fallbackType, out string? error)
         {
             if (StringUtils.IsNullOrEmpty(member?.typeName) && fallbackType == null)
@@ -803,6 +974,14 @@ public static bool IsIEnumerable(Type type)
             error = null;
             return type;
         }
+
+        /// <summary>
+        /// Resolves a type with priority given to the provided type parameter.
+        /// </summary>
+        /// <param name="type">The primary type to use (if not null).</param>
+        /// <param name="fallbackMember">The fallback serialized member to extract type name from.</param>
+        /// <param name="error">Set to an error message if the type cannot be resolved; otherwise, <c>null</c>.</param>
+        /// <returns>The resolved type, or <c>null</c> if resolution fails.</returns>
         public static Type? GetTypeWithValuePriority(Type? type, SerializedMember? fallbackMember, out string? error)
         {
             if (type == null)