diff --git a/.nuget/Cuemon.Core/PackageReleaseNotes.txt b/.nuget/Cuemon.Core/PackageReleaseNotes.txt
index 9cf7a4f38..31b091347 100644
--- a/.nuget/Cuemon.Core/PackageReleaseNotes.txt
+++ b/.nuget/Cuemon.Core/PackageReleaseNotes.txt
@@ -45,6 +45,21 @@ Availability: .NET 9, .NET 8 and .NET Standard 2.0
 - REMOVED UnitPrefix enum from the Cuemon namespace
 - REMOVED UnitPrefixFormatter class from the Cuemon namespace
 - REMOVED ZeroPrefix class from the Cuemon namespace
+- REMOVED DataPairCollection class from the Cuemon.Collections namespace
+- REMOVED DataPairDictionary class from the Cuemon.Collections namespace
+- REMOVED Initializer class from the Cuemon namespace
+- REMOVED InitializerBuilder class from the Cuemon namespace
+- REMOVED Mapping class from the Cuemon namespace
+- REMOVED IndexMapping class from the Cuemon namespace
+- REMOVED HorizontalDirection enum from the Cuemon namespace
+- REMOVED VerticalDirection enum from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED IWrapper interface from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED Wrapper class from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED HierarchyDecoratorExtensions class from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED Hierarchy class from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED IHierarchy interface from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- REMOVED ObjectHierarchyOptions class from the Cuemon.Reflection namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly and renamed to HierarchyOptions)
+- REMOVED HierarchySerializer class from the Cuemon.Runtime.Serialization namespace (moved to the Cuemon.Extensions.Runtime.Serialization namespace in the Cuemon.Extensions.Core assembly)
  
 # New Features
 - ADDED Failure record in the Cuemon.Diagnostics namespace that represents a failure model with detailed information about an exception
diff --git a/.nuget/Cuemon.Extensions.Core/PackageReleaseNotes.txt b/.nuget/Cuemon.Extensions.Core/PackageReleaseNotes.txt
index 6db089461..c293c891d 100644
--- a/.nuget/Cuemon.Extensions.Core/PackageReleaseNotes.txt
+++ b/.nuget/Cuemon.Extensions.Core/PackageReleaseNotes.txt
@@ -9,6 +9,7 @@ Availability: .NET 9, .NET 8 and .NET Standard 2.0
 - REMOVED ConditionExtensions class from the Cuemon.Extensions namespace and moved members to Condition class in the Cuemon.Core assembly (Cuemon namespace)
 - REMOVED ValidatorExtensions class from the Cuemon.Extensions namespace and moved members to Validator class in the Cuemon.Core assembly (Cuemon namespace)
 - REMOVED ReplaceLineEndings extension method from the StringExtensions class in the Cuemon.Extensions namespace
+- REMOVED MappingExtensions class from the Cuemon.Extensions namespace
  
 # New Features
 - ADDED ActionFactory class in the Cuemon.Extensions namespace that provides access to factory methods for creating ActionFactory{TTuple} objects that encapsulate a delegate with a variable amount of generic arguments
@@ -16,6 +17,14 @@ Availability: .NET 9, .NET 8 and .NET Standard 2.0
 - ADDED MutableTupleFactory class in the Cuemon.Extensions namespace that provides access to factory methods for creating MutableTuple objects
 - ADDED TesterFuncFactory class in the Cuemon.Extensions namespace that provides access to factory methods for creating TesterFuncFactory{TTuple, TResult, TSuccess} objects that encapsulate a tester function delegate with a variable amount of generic arguments
 - ADDED AsyncDisposable class in the Cuemon.Extensions namespace that provides a mechanism for asynchronously releasing both managed and unmanaged resources with focus on the former
+- ADDED VerticalDirection enum in the Cuemon.Extensions namespace that specifies a set of values defining a vertical direction
+- ADDED IWrapper interface in the Cuemon.Extensions namespace that defines a generic way to wrap an object instance inside another object
+- ADDED Wrapper class in the Cuemon.Extensions namespace that provides a way to wrap an object instance inside another object
+- ADDED Hierarchy class in the Cuemon.Extensions.Runtime namespace that represents a way to expose a node of a hierarchical structure, including the node object type
+- ADDED HierarchyDecoratorExtensions class in the Cuemon.Extensions.Runtime namespace that provides (hidden) extensions to the IHierarchy interface
+- ADDED HierarchyOptions class in the Cuemon.Extensions.Runtime namespace that represents a set of options to configure the behavior of the Hierarchy and HierarchySerializer class
+- ADDED IHierarchy interface in the Cuemon.Extensions.Runtime namespace that defines a way to expose a node of a hierarchical structure
+- ADDED HierarchySerializer class in the Cuemon.Extensions.Runtime.Serialization namespace that provides a way to serialize objects to nodes of IHierarchy
  
 Version 8.3.2
 Availability: .NET 8, .NET 6 and .NET Standard 2.0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eabb946a6..8e5f05b3d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 For more details, please refer to `PackageReleaseNotes.txt` on a per assembly basis in the `.nuget` folder.
 
-## [9.0.0] - TBD (sometime in November 2024)
+## [9.0.0] - 2024-11-13
 
 > [!IMPORTANT]  
 > The following projects has been removed with this release and migrated to [Codebelt](https://github.com/codebeltnet):
@@ -21,6 +21,8 @@ For more details, please refer to `PackageReleaseNotes.txt` on a per assembly ba
 
 > [!NOTE]
 > Types that are removed from this solution (but otherwise fits naturally together) will be migrated to smaller and more focused repositories in the [Codebelt](https://github.com/codebeltnet) organization, renamed to better reflect their purpose and published as standalone packages on NuGet.
+>
+> - [Codebelt.Unitify](https://github.com/codebeltnet/unitify) is an example of a repository that received types from this solution and is now a standalone library that provides a uniform way of working with prefixes and multiples in the context of units of measure.
 
 This major release is first and foremost focused on ironing out any wrinkles that have been introduced with .NET 9 preview releases so the final release is production ready together with the official launch from Microsoft.
 
@@ -32,6 +34,9 @@ Highlighted features included in this release:
 
 - Support for both **FaultDetails** (HttpExceptionDescriptor) and **ProblemDetails** in the context of ASP.NET (both vanilla and MVC)
 - Reduced footprint in the core assemblies by removing obsolete and redundant code
+  - Went from approximately 700 KB to 500 KB in the core assembly
+  - Types reduced with approximately 20% which is about 100 types
+- Central Package Management (CPM) for all projects in the solution
 
 ### Added
 
@@ -54,6 +59,14 @@ Highlighted features included in this release:
 - MutableTupleFactory class in the Cuemon.Extensions namespace that provides access to factory methods for creating MutableTuple objects
 - TesterFuncFactory class in the Cuemon.Extensions namespace that provides access to factory methods for creating TesterFuncFactory{TTuple, TResult, TSuccess} objects that encapsulate a tester function delegate with a variable amount of generic arguments
 - AsyncDisposable class in the Cuemon.Extensions namespace that provides a mechanism for asynchronously releasing both managed and unmanaged resources with focus on the former
+- VerticalDirection enum in the Cuemon.Extensions namespace that specifies a set of values defining a vertical direction
+- IWrapper interface in the Cuemon.Extensions namespace that defines a generic way to wrap an object instance inside another object
+- Wrapper class in the Cuemon.Extensions namespace that provides a way to wrap an object instance inside another object
+- Hierarchy class in the Cuemon.Extensions.Runtime namespace that represents a way to expose a node of a hierarchical structure, including the node object type
+- HierarchyDecoratorExtensions class in the Cuemon.Extensions.Runtime namespace that provides (hidden) extensions to the IHierarchy interface
+- HierarchyOptions class in the Cuemon.Extensions.Runtime namespace that represents a set of options to configure the behavior of the Hierarchy and HierarchySerializer class
+- IHierarchy interface in the Cuemon.Extensions.Runtime namespace that defines a way to expose a node of a hierarchical structure
+- HierarchySerializer class in the Cuemon.Extensions.Runtime.Serialization namespace that provides a way to serialize objects to nodes of IHierarchy
 
 ### Changed
 
@@ -165,6 +178,21 @@ Highlighted features included in this release:
 - UnitPrefix enum from the Cuemon namespace (breaking change)
 - UnitPrefixFormatter class from the Cuemon namespace (breaking change)
 - ZeroPrefix class from the Cuemon namespace (breaking change)
+- DataPairCollection class from the Cuemon.Collections namespace
+- DataPairDictionary class from the Cuemon.Collections namespace
+- Initializer class from the Cuemon namespace
+- InitializerBuilder class from the Cuemon namespace
+- Mapping class from the Cuemon namespace
+- IndexMapping class from the Cuemon namespace
+- HorizontalDirection enum from the Cuemon namespace
+- VerticalDirection enum from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- IWrapper interface from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- Wrapper class from the Cuemon namespace (moved to the Cuemon.Extensions namespace in the Cuemon.Extensions.Core assembly)
+- HierarchyDecoratorExtensions class from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- Hierarchy class from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- IHierarchy interface from the Cuemon namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly)
+- ObjectHierarchyOptions class from the Cuemon.Reflection namespace (moved to the Cuemon.Extensions.Runtime namespace in the Cuemon.Extensions.Core assembly and renamed to HierarchyOptions)
+- HierarchySerializer class from the Cuemon.Runtime.Serialization namespace (moved to the Cuemon.Extensions.Runtime.Serialization namespace in the Cuemon.Extensions.Core assembly)
 
 ## [8.3.2] - 2024-08-04
 
diff --git a/src/Cuemon.Core/Collections/DataPairCollection.cs b/src/Cuemon.Core/Collections/DataPairCollection.cs
deleted file mode 100644
index a266ba63d..000000000
--- a/src/Cuemon.Core/Collections/DataPairCollection.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.Collections.ObjectModel;
-
-namespace Cuemon.Collections
-{
-    /// <summary>
-    /// Provides a collection of <see cref="DataPair"/>.
-    /// </summary>
-    public class DataPairCollection : Collection<DataPair>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DataPairCollection"/> class.
-        /// </summary>
-        public DataPairCollection() : base()
-        {
-        }
-
-        /// <summary>
-        /// Adds a new <see cref="DataPair{T}"/> to the end of this <see cref="DataPairCollection"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the data being added to this instance.</typeparam>
-        /// <param name="name">The name of the data pair.</param>
-        /// <param name="value">The value of the data pair.</param>
-        public void Add<T>(string name, T value)
-        {
-            Add(name, value, typeof(T));
-        }
-
-        /// <summary>
-        /// Adds a new <see cref="DataPair{T}"/> to the end of this <see cref="DataPairCollection"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the data being added to this instance.</typeparam>
-        /// <param name="name">The name of the data pair.</param>
-        /// <param name="value">The value of the data pair.</param>
-        /// <param name="typeOf">The type of the data pair.</param>
-        public void Add<T>(string name, T value, Type typeOf)
-        {
-            base.Add(new DataPair<T>(name, value, typeOf));
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/Collections/DataPairDictionary.cs b/src/Cuemon.Core/Collections/DataPairDictionary.cs
deleted file mode 100644
index 16f0a245c..000000000
--- a/src/Cuemon.Core/Collections/DataPairDictionary.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Cuemon.Collections
-{
-    /// <summary>
-    /// Provides a collection of <see cref="DataPair"/>.
-    /// </summary>
-    public class DataPairDictionary : Dictionary<string, DataPair>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DataPairDictionary"/> class.
-        /// </summary>
-        public DataPairDictionary() : base()
-        {
-        }
-
-        /// <summary>
-        /// Adds a new <see cref="DataPair{T}"/> to the end of this <see cref="DataPairDictionary"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the data being added to this instance.</typeparam>
-        /// <param name="name">The name of the data pair.</param>
-        /// <param name="value">The value of the data pair.</param>
-        public void Add<T>(string name, T value)
-        {
-            Add(name, value, typeof(T));
-        }
-
-        /// <summary>
-        /// Adds a new <see cref="DataPair{T}"/> to the end of this <see cref="DataPairDictionary"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the data being added to this instance.</typeparam>
-        /// <param name="name">The name of the data pair.</param>
-        /// <param name="value">The value of the data pair.</param>
-        /// <param name="typeOf">The type of the data pair.</param>
-        public void Add<T>(string name, T value, Type typeOf)
-        {
-            base.Add(name, new DataPair<T>(name, value, typeOf));
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/Extensions/ExceptionDecoratorExtensions.cs b/src/Cuemon.Core/Extensions/ExceptionDecoratorExtensions.cs
index 826258520..ab3272825 100644
--- a/src/Cuemon.Core/Extensions/ExceptionDecoratorExtensions.cs
+++ b/src/Cuemon.Core/Extensions/ExceptionDecoratorExtensions.cs
@@ -28,7 +28,7 @@ public static IEnumerable<Exception> Flatten(this IDecorator<Exception> decorato
         {
             Validator.ThrowIfNull(decorator);
             if (decorator.Inner is AggregateException ae) { return ae.Flatten().InnerExceptions; }
-            return Hierarchy.WhileSourceTraversalHasElements(decorator.Inner, FlattenCallback).Skip(1);
+            return Decorator.RawEnclose(decorator.Inner).TraverseWhileNotEmpty(FlattenCallback).Skip(1);
         }
 
         private static IEnumerable<Exception> FlattenCallback(Exception source)
@@ -37,4 +37,4 @@ private static IEnumerable<Exception> FlattenCallback(Exception source)
             return source.InnerException == null ? Enumerable.Empty<Exception>() : Arguments.Yield(source.InnerException);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cuemon.Core/Extensions/ObjectDecoratorExtensions.cs b/src/Cuemon.Core/Extensions/ObjectDecoratorExtensions.cs
index 511bc9405..4cc3023f5 100644
--- a/src/Cuemon.Core/Extensions/ObjectDecoratorExtensions.cs
+++ b/src/Cuemon.Core/Extensions/ObjectDecoratorExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Globalization;
 using System.Reflection;
@@ -95,5 +96,48 @@ public static object ChangeType(this IDecorator<object> decorator, Type targetTy
                 }
             }
         }
+
+        /// <summary>
+        /// Resolves the default value of a property from the enclosed object of the specified <paramref name="decorator"/>.
+        /// </summary>
+        /// <param name="decorator">The <see cref="IDecorator{T}"/> to extend.</param>
+        /// <param name="pi">The <see cref="PropertyInfo"/> of the property to resolve the value for.</param>
+        /// <returns>The value of the property if the enclosed object is not null; otherwise, <c>null</c>.</returns>
+        /// <remarks>This API supports the product infrastructure and is not intended to be used directly from your code.</remarks>
+        public static object DefaultPropertyValueResolver(this IDecorator<object> decorator, PropertyInfo pi)
+        {
+            var source = decorator?.Inner;
+            return source == null
+                ? null
+                : pi?.GetValue(source, null);
+        }
+
+        /// <summary>
+        /// Invokes the specified <paramref name="traversal"/> path of the enclosed object of the specified <paramref name="decorator"/> until obstructed by an empty sequence.
+        /// </summary>
+        /// <param name="decorator">The <see cref="IDecorator{T}"/> to extend.</param>
+        /// <param name="traversal">The function delegate that is invoked until the traveled path is obstructed by an empty sequence.</param>
+        /// <returns>An <see cref="IEnumerable{T}"/> sequence equal to the traveled path of the enclosed object of the specified <paramref name="decorator"/>.</returns>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="decorator"/> -or- <paramref name="traversal"/> is null.
+        /// </exception>
+        public static IEnumerable<TSource> TraverseWhileNotEmpty<TSource>(this IDecorator<TSource> decorator, Func<TSource, IEnumerable<TSource>> traversal) where TSource : class
+        {
+            Validator.ThrowIfNull(decorator);
+            Validator.ThrowIfNull(traversal);
+
+            var source = decorator.Inner;
+            var stack = new Stack<TSource>();
+            stack.Push(source);
+            while (stack.Count != 0)
+            {
+                var current = stack.Pop();
+                foreach (var element in traversal(current))
+                {
+                    stack.Push(element);
+                }
+                yield return current;
+            }
+        }
     }
 }
diff --git a/src/Cuemon.Core/Extensions/TypeDecoratorExtensions.cs b/src/Cuemon.Core/Extensions/TypeDecoratorExtensions.cs
index ea44ac8b8..cf66f76a0 100644
--- a/src/Cuemon.Core/Extensions/TypeDecoratorExtensions.cs
+++ b/src/Cuemon.Core/Extensions/TypeDecoratorExtensions.cs
@@ -417,7 +417,7 @@ public static bool HasCircularReference(this IDecorator<Type> decorator, object
             Validator.ThrowIfNull(source);
             Validator.ThrowIfLowerThanOrEqual(maxDepth, 0, nameof(maxDepth));
             if (source.GetType() != decorator.Inner) { throw new InvalidOperationException("The specified source has a different type than the underlying type of the extended decorator."); }
-            valueResolver ??= Infrastructure.DefaultPropertyValueResolver;
+            valueResolver ??= (s, i) => Decorator.RawEnclose(s).DefaultPropertyValueResolver(i);
             var hasCircularReference = false;
             var currentDepth = 0;
             var stack = new Stack<object>();
diff --git a/src/Cuemon.Core/GlobalSuppressions.cs b/src/Cuemon.Core/GlobalSuppressions.cs
index 8a975064f..567bf7a51 100644
--- a/src/Cuemon.Core/GlobalSuppressions.cs
+++ b/src/Cuemon.Core/GlobalSuppressions.cs
@@ -33,14 +33,12 @@
 [assembly: SuppressMessage("Major Code Smell", "S2436:Types and methods should not have too many generic parameters", Justification = "By design; allow up till 5 arguments (more under certain conditions).", Scope = "member", Target = "~M:Cuemon.Reflection.ActivatorFactory.CreateInstance``5(``0,``1,``2,``3,System.Action{Cuemon.Reflection.ActivatorOptions})~``4")]
 [assembly: SuppressMessage("Major Code Smell", "S2436:Types and methods should not have too many generic parameters", Justification = "By design; allow up till 5 arguments (more under certain conditions).", Scope = "member", Target = "~M:Cuemon.Reflection.ActivatorFactory.CreateInstance``6(``0,``1,``2,``3,``4,System.Action{Cuemon.Reflection.ActivatorOptions})~``5")]
 [assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "By design; although a good rule, this is the exception to the rule.", Scope = "member", Target = "~M:Cuemon.Calculator.CalculateCore``1(``0,``0,Cuemon.AssignmentOperator)~``0")]
-[assembly: SuppressMessage("Major Code Smell", "S3925:\"ISerializable\" should be implemented correctly", Justification = "Out of scope.", Scope = "type", Target = "~T:Cuemon.Collections.DataPairDictionary")]
 [assembly: SuppressMessage("Major Code Smell", "S3011:Reflection should not be used to increase accessibility of classes, methods, or fields", Justification = "By design.", Scope = "member", Target = "~F:Cuemon.Reflection.MemberReflection.Everything")]
 [assembly: SuppressMessage("Major Code Smell", "S3011:Reflection should not be used to increase accessibility of classes, methods, or fields", Justification = "By design.", Scope = "member", Target = "~M:Cuemon.Reflection.MemberReflection.#ctor(System.Action{Cuemon.Reflection.MemberReflectionOptions})")]
 [assembly: SuppressMessage("Major Code Smell", "S3011:Reflection should not be used to increase accessibility of classes, methods, or fields", Justification = "By design.", Scope = "member", Target = "~M:Cuemon.Globalization.ResourceAttribute.GetString(System.String)~System.String")]
 [assembly: SuppressMessage("Major Code Smell", "S1854:Unused assignments should be removed", Justification = "False Positive", Scope = "member", Target = "~M:Cuemon.DateSpan.#ctor(System.DateTime,System.DateTime,System.Globalization.Calendar)")]
 [assembly: SuppressMessage("Style", "IDE0220:Add explicit cast", Justification = "False-Positive", Scope = "member", Target = "~M:Cuemon.StringReplaceEngine.RenderReplacement~System.String")]
 [assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "Prioritize functionality and correctness over complexity metrics.", Scope = "member", Target = "~M:Cuemon.DateSpan.#ctor(System.DateTime,System.DateTime,System.Globalization.Calendar)")]
-[assembly: SuppressMessage("Major Code Smell", "S2589:Boolean expressions should not be gratuitous", Justification = "False Positive", Scope = "member", Target = "~M:Cuemon.Hierarchy.WhileSourceTraversalIsNotNullIterator``1(``0,System.Func{``0,``0})~System.Collections.Generic.IEnumerable{``0}")]
 [assembly: SuppressMessage("Major Code Smell", "S2589:Boolean expressions should not be gratuitous", Justification = "False Positive", Scope = "member", Target = "~M:Cuemon.Security.CyclicRedundancyCheck.PolynomialTableInitializerCore(System.UInt64)~System.Collections.Generic.List{System.UInt64}")]
 [assembly: SuppressMessage("Minor Code Smell", "S3236:Caller information arguments should not be provided explicitly", Justification = "By design - and unit tested to that no information is lost.", Scope = "member", Target = "~M:Cuemon.Decorator`1.#ctor(`0,System.Boolean,System.String)")]
 [assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "Acceptable.", Scope = "member", Target = "~M:Cuemon.Text.ParserFactory.FromValueType~Cuemon.Text.IConfigurableParser{System.Object,Cuemon.FormattingOptions}")]
@@ -68,7 +66,6 @@
 [assembly: SuppressMessage("Design", "CA1000:Do not declare static members on generic types", Justification = "By design; supports consistent developer experience for all formatters, e.g., SerializeObject/DeserializeObject.", Scope = "member", Target = "~M:Cuemon.Runtime.Serialization.Formatters.StreamFormatter`1.SerializeObject(System.Object,System.Type,`0)~System.IO.Stream")]
 [assembly: SuppressMessage("Design", "CA1000:Do not declare static members on generic types", Justification = "By design; supports consistent developer experience for all formatters, e.g., SerializeObject/DeserializeObject.", Scope = "member", Target = "~M:Cuemon.Runtime.Serialization.Formatters.StreamFormatter`1.SerializeObject(System.Object,System.Type,System.Action{`0})~System.IO.Stream")]
 [assembly: SuppressMessage("Globalization", "CA1304:Specify CultureInfo", Justification = "False-Positive. Overload exists.", Scope = "member", Target = "~M:Cuemon.DateSpan.Parse(System.String)~Cuemon.DateSpan")]
-[assembly: SuppressMessage("Globalization", "CA1305:Specify IFormatProvider", Justification = "Not relevant in this context.", Scope = "member", Target = "~M:Cuemon.Runtime.Serialization.HierarchySerializer.ToString(System.Text.StringBuilder,Cuemon.IHierarchy{System.Object})")]
 [assembly: SuppressMessage("Globalization", "CA1304:Specify CultureInfo", Justification = "Intentionally written for only en-US support.", Scope = "member", Target = "~M:Cuemon.Reflection.MemberArgumentDecoratorExtensions.CreateException(Cuemon.IDecorator{System.Collections.Generic.Stack{System.Collections.Generic.IList{Cuemon.Reflection.MemberArgument}}},System.Boolean)~System.Exception")]
 [assembly: SuppressMessage("Naming", "CA1710:Identifiers should have correct suffix", Justification = "Explicit implementation.", Scope = "type", Target = "~T:Cuemon.Diagnostics.Failure")]
 [assembly: SuppressMessage("Reliability", "CA2022:Avoid inexact read with 'Stream.Read'", Justification = "Byteordermark - best effort.", Scope = "member", Target = "~M:Cuemon.Text.ByteOrderMark.TryDetectEncoding(System.IO.Stream,System.Text.Encoding@)~System.Boolean")]
diff --git a/src/Cuemon.Core/HorizontalDirection.cs b/src/Cuemon.Core/HorizontalDirection.cs
deleted file mode 100644
index 5abb56ef0..000000000
--- a/src/Cuemon.Core/HorizontalDirection.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-namespace Cuemon
-{
-    /// <summary>
-    /// Specifies a set of values defining a horizontal direction.
-    /// </summary>
-    public enum HorizontalDirection
-    {
-        /// <summary>
-        /// Indicates a vertical direction of Left.
-        /// </summary>
-        Left,
-        /// <summary>
-        /// Indicates a vertical direction of Right.
-        /// </summary>
-        Right
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/IndexMapping.cs b/src/Cuemon.Core/IndexMapping.cs
deleted file mode 100644
index 482f131bd..000000000
--- a/src/Cuemon.Core/IndexMapping.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-namespace Cuemon
-{
-    /// <summary>
-    /// Defines the mapping between a column/field/item in a data source and a column/field/item in the data destination. This class cannot be inherited.
-    /// </summary>
-    public sealed class IndexMapping : Mapping
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Mapping" /> class.
-        /// </summary>
-        /// <param name="source">The name of the source column/field/item within the data source.</param>
-        /// <param name="destination">The name of the destination column/field/item within the data destination.</param>
-        public IndexMapping(string source, string destination) : base(source, destination)
-        {
-            SourceIndex = -1;
-            DestinationIndex = -1;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="IndexMapping"/> class.
-        /// </summary>
-        /// <param name="source">The name of the source column/field/item within the data source.</param>
-        /// <param name="destinationIndex">The ordinal position of the destination column/field/item within the data destination.</param>
-        public IndexMapping(string source, int destinationIndex) : base(source, "")
-        {
-            Validator.ThrowIfLowerThan(destinationIndex, 0, nameof(destinationIndex));
-            SourceIndex = -1;
-            DestinationIndex = destinationIndex;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="IndexMapping"/> class.
-        /// </summary>
-        /// <param name="sourceIndex">The ordinal position of the source column/field/item within the data source.</param>
-        /// <param name="destination">The name of the destination column/field/item within the data destination.</param>
-        public IndexMapping(int sourceIndex, string destination) : base("", destination)
-        {
-            Validator.ThrowIfLowerThan(sourceIndex, 0, nameof(sourceIndex));
-            SourceIndex = sourceIndex;
-            DestinationIndex = -1;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="IndexMapping"/> class.
-        /// </summary>
-        /// <param name="sourceIndex">The ordinal position of the source column/field/item within the data source.</param>
-        /// <param name="destinationIndex">The ordinal position of the destination column/field/item within the data destination.</param>
-        public IndexMapping(int sourceIndex, int destinationIndex) : base("", "")
-        {
-            Validator.ThrowIfLowerThan(sourceIndex, 0, nameof(sourceIndex));
-            Validator.ThrowIfLowerThan(destinationIndex, 0, nameof(destinationIndex));
-            SourceIndex = sourceIndex;
-            DestinationIndex = destinationIndex;
-        }
-
-        /// <summary>
-        /// Gets the ordinal position of the column/field/item within the data source.
-        /// </summary>
-        /// <value>The integer value of the column/field/item within the data source.</value>
-        public int SourceIndex { get; private set; }
-
-        /// <summary>
-        /// Gets the ordinal position of the column/field/item within the data destination.
-        /// </summary>
-        /// <value>The integer value of the column/field/item within the data destination.</value>
-        public int DestinationIndex { get; private set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/Infrastructure.cs b/src/Cuemon.Core/Infrastructure.cs
deleted file mode 100644
index 0bee963ba..000000000
--- a/src/Cuemon.Core/Infrastructure.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System.Reflection;
-
-namespace Cuemon
-{
-    internal static class Infrastructure
-    {
-        internal static object DefaultPropertyValueResolver(object source, PropertyInfo pi)
-        {
-            return source == null ? null : pi.GetValue(source, null);
-        }
-    }
-}
diff --git a/src/Cuemon.Core/Initializer.cs b/src/Cuemon.Core/Initializer.cs
deleted file mode 100644
index a7ab049f4..000000000
--- a/src/Cuemon.Core/Initializer.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-namespace Cuemon
-{
-    /// <summary>
-    /// Provides a generic way to wrap and initialize a class for countless scenarios.
-    /// </summary>
-    public static class Initializer
-    {
-        /// <summary>
-        /// Creates a new instance of the <see cref="InitializerBuilder{T}"/> wrapping the specified <paramref name="instance"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of object to wrap.</typeparam>
-        /// <param name="instance">The instance to initialize within a protective wrapping.</param>
-        /// <returns>A new instance of <see cref="InitializerBuilder{T}"/> with the specified <paramref name="instance"/> wrapped.</returns>
-        public static InitializerBuilder<T> Create<T>(T instance) where T : class
-        {
-            return new InitializerBuilder<T>(instance);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/InitializerBuilder.cs b/src/Cuemon.Core/InitializerBuilder.cs
deleted file mode 100644
index 9aed3fd8f..000000000
--- a/src/Cuemon.Core/InitializerBuilder.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using System;
-
-namespace Cuemon
-{
-    /// <summary>
-    /// Supports the <see cref="Initializer"/> for building custom initializers.
-    /// </summary>
-    /// <typeparam name="T">The type of object to wrap.</typeparam>
-    public class InitializerBuilder<T> where T : class
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="InitializerBuilder{T}"/> class.
-        /// </summary>
-        /// <param name="instance">The instance to initialize within a protective wrapping.</param>
-        internal InitializerBuilder(T instance)
-        {
-            Validator.ThrowIfNull(instance);
-            Instance = instance;
-        }
-
-        /// <summary>
-        /// Gets the initialized instance.
-        /// </summary>
-        /// <value>The initialized instance.</value>
-        public T Instance { get; }
-
-        /// <summary>
-        /// Ignores any <see cref="MissingMethodException"/> that might be thrown by instance <typeparamref name="T"/>.
-        /// </summary>
-        /// <param name="initializer">The delegate that will continue initializing instance <typeparamref name="T"/> while ignoring any <see cref="MissingMethodException"/>.</param>
-        /// <returns>A reference to this instance.</returns>
-        public InitializerBuilder<T> IgnoreMissingMethod(Action<T> initializer)
-        {
-            return Ignore(initializer, ex => ex is MissingMethodException);
-        }
-
-        /// <summary>
-        /// Ignores any exceptions that might be thrown by instance <typeparamref name="T"/>.
-        /// </summary>
-        /// <param name="initializer">The delegate that will continue initializing instance <typeparamref name="T"/> while ignoring any exceptions.</param>
-        /// <returns>A reference to this instance.</returns>
-        public InitializerBuilder<T> IgnoreAny(Action<T> initializer)
-        {
-            return Ignore(initializer, ex => true);
-        }
-
-        /// <summary>
-        /// Ignores exceptions thrown by instance <typeparamref name="T"/> that is specified by the function delegate <paramref name="ignorer"/>.
-        /// </summary>
-        /// <param name="initializer">The delegate that will continue initializing instance <typeparamref name="T"/> while ignoring any exceptions specified by <paramref name="ignorer"/>.</param>
-        /// <param name="ignorer">The function delegate that will parse thrown exceptions and ignore those specified.</param>
-        /// <returns>A reference to this instance.</returns>
-        public InitializerBuilder<T> Ignore(Action<T> initializer, Func<Exception, bool> ignorer)
-        {
-            Validator.ThrowIfNull(ignorer);
-            Validator.ThrowIfNull(initializer);
-            try
-            {
-                initializer(Instance);
-            }
-            catch (Exception ex)
-            {
-                if (!ignorer(ex)) { throw; }
-            }
-            return this;
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/Mapping.cs b/src/Cuemon.Core/Mapping.cs
deleted file mode 100644
index d37c2c72b..000000000
--- a/src/Cuemon.Core/Mapping.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-namespace Cuemon
-{
-    /// <summary>
-    /// Defines the mapping between a column/field/item in a data source and a column/field/item in the data destination.
-    /// </summary>
-    public class Mapping
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Mapping"/> class.
-        /// </summary>
-        /// <param name="source">The name of the source column/field/item within the data source.</param>
-        /// <param name="destination">The name of the destination column/field/item within the data destination.</param>
-        public Mapping(string source, string destination)
-        {
-            Source = source;
-            Destination = destination;
-        }
-
-        /// <summary>
-        /// Gets the name of the column/field/item being mapped in the data source.
-        /// </summary>
-        /// <value>The string value of the column/field/item being mapped in the data source.</value>
-        public string Source { get; private set; }
-
-        /// <summary>
-        /// Get the name of the column/field/item being mapped in the data destination.
-        /// </summary>
-        /// <value>The string value of the column/field/item being mapped in the data destination.</value>
-        public string Destination { get; private set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/ObjectPortrayalOptions.cs b/src/Cuemon.Core/ObjectPortrayalOptions.cs
index 8958cb5d1..e89800205 100644
--- a/src/Cuemon.Core/ObjectPortrayalOptions.cs
+++ b/src/Cuemon.Core/ObjectPortrayalOptions.cs
@@ -78,7 +78,7 @@ public ObjectPortrayalOptions()
                     {
                         return string.Format(provider, "{0}={1}", property.Name, Decorator.Enclose(property.PropertyType).ToFriendlyName(o => o.FullName = true));
                     }
-                    var instanceValue = Infrastructure.DefaultPropertyValueResolver(instance, property);
+                    var instanceValue = Decorator.RawEnclose(instance).DefaultPropertyValueResolver(property);
                     return string.Format(provider, "{0}={1}", property.Name, instanceValue ?? NullValue);
                 }
                 return string.Format(provider, "{0}={1}", property.Name, NoGetterValue);
diff --git a/src/Cuemon.Data.SqlClient/SqlDataManager.cs b/src/Cuemon.Data.SqlClient/SqlDataManager.cs
index 2a0ca99aa..ebf6d16b0 100644
--- a/src/Cuemon.Data.SqlClient/SqlDataManager.cs
+++ b/src/Cuemon.Data.SqlClient/SqlDataManager.cs
@@ -224,7 +224,7 @@ private static void HandleSqlDateTime(SqlParameter parameter)
 
         private static SqlException ParseException(Exception exception)
         {
-            var exceptions = Arguments.Yield(exception).Concat(Decorator.Enclose(exception).Flatten());
+            var exceptions = Arguments.Yield(exception).Concat(Decorator.EncloseToExpose(exception).Flatten());
             return exceptions.FirstOrDefault(ex => ex is SqlException) as SqlException;
         }
     }
diff --git a/src/Cuemon.Extensions.Core/GlobalSuppressions.cs b/src/Cuemon.Extensions.Core/GlobalSuppressions.cs
index d19e48ecf..dcce8d859 100644
--- a/src/Cuemon.Extensions.Core/GlobalSuppressions.cs
+++ b/src/Cuemon.Extensions.Core/GlobalSuppressions.cs
@@ -105,3 +105,4 @@
 [assembly: SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "By design; allow to exceed generic arguments recommendation.", Scope = "member", Target = "~M:Cuemon.Extensions.TesterFuncFactory.Create``16(Cuemon.TesterFunc{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15},``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13)~Cuemon.TesterFuncFactory{Cuemon.MutableTuple{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13},``14,``15}")]
 [assembly: SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "By design; allow to exceed generic arguments recommendation.", Scope = "member", Target = "~M:Cuemon.Extensions.TesterFuncFactory.Create``17(Cuemon.TesterFunc{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14,``15,``16},``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14)~Cuemon.TesterFuncFactory{Cuemon.MutableTuple{``0,``1,``2,``3,``4,``5,``6,``7,``8,``9,``10,``11,``12,``13,``14},``15,``16}")]
 [assembly: SuppressMessage("Major Code Smell", "S107:Methods should not have too many parameters", Justification = "By design; allow to exceed generic arguments recommendation.", Scope = "member", Target = "~M:Cuemon.Extensions.TesterFuncFactory.Create``9(Cuemon.TesterFunc{``0,``1,``2,``3,``4,``5,``6,``7,``8},``0,``1,``2,``3,``4,``5,``6)~Cuemon.TesterFuncFactory{Cuemon.MutableTuple{``0,``1,``2,``3,``4,``5,``6},``7,``8}")]
+[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "TODO - due to .NET 9 release this week, its kept as-is with this round of refactoring.", Scope = "member", Target = "~M:Cuemon.Extensions.Runtime.Hierarchy.GetObjectHierarchy(System.Object,System.Action{Cuemon.Extensions.Runtime.HierarchyOptions})~Cuemon.Extensions.Runtime.IHierarchy{System.Object}")]
diff --git a/src/Cuemon.Core/IWrapper.cs b/src/Cuemon.Extensions.Core/IWrapper.cs
similarity index 95%
rename from src/Cuemon.Core/IWrapper.cs
rename to src/Cuemon.Extensions.Core/IWrapper.cs
index a77f0df29..5622c90e8 100644
--- a/src/Cuemon.Core/IWrapper.cs
+++ b/src/Cuemon.Extensions.Core/IWrapper.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Reflection;
 
-namespace Cuemon
+namespace Cuemon.Extensions
 {
     /// <summary>
     /// Provides a generic way to wrap an object instance of <typeparamref name="T"/> inside another object.
@@ -9,7 +9,6 @@ namespace Cuemon
     /// <typeparam name="T">The type of the object instance to wrap inside another object.</typeparam>
     public interface IWrapper<out T> : IData
     {
-        #region Properties
         /// <summary>
         /// Gets the instance of the <see cref="IWrapper{T}"/> object.
         /// </summary>
@@ -33,9 +32,7 @@ public interface IWrapper<out T> : IData
         /// </summary>
         /// <value><c>true</c> if this instance has a member reference; otherwise, <c>false</c>.</value>
         bool HasMemberReference { get; }
-        #endregion
 
-        #region Methods
         /// <summary>
         /// Returns a value that is equivalent to the instance of the node that this hierarchical structure represents.
         /// </summary>
@@ -50,6 +47,5 @@ public interface IWrapper<out T> : IData
         /// <param name="provider">An object that supplies culture-specific formatting information.</param>
         /// <returns>A value that is equivalent to the instance of the node that this hierarchical structure represents.</returns>
         TResult InstanceAs<TResult>(IFormatProvider provider);
-        #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cuemon.Extensions.Core/MappingExtensions.cs b/src/Cuemon.Extensions.Core/MappingExtensions.cs
deleted file mode 100644
index c870109b8..000000000
--- a/src/Cuemon.Extensions.Core/MappingExtensions.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-using System.Collections.Generic;
-
-namespace Cuemon.Extensions
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Mapping"/> class.
-    /// </summary>
-    public static class MappingExtensions
-    {
-        /// <summary>
-        /// Creates a new <see cref="Mapping"/> using column/field/item names to refer to a <paramref name="source"/> and a <paramref name="destination"/> which is added to the specified <paramref name="collection"/> of mappings.
-        /// </summary>
-        /// <param name="collection">A collection of <see cref="Mapping"/> elements.</param>
-        /// <param name="source">The name of the column/field/item within the data source.</param>
-        /// <param name="destination">The name of the destination column/field/item within the data destination.</param>
-        public static void AddMapping(this ICollection<Mapping> collection, string source, string destination)
-        {
-            Validator.ThrowIfNull(collection);
-            collection.Add(new Mapping(source, destination));
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="Mapping"/> using an ordinal for the <paramref name="sourceIndex"/> and a column/field/item name to describe the <paramref name="destination"/> which is added to the specified <paramref name="collection"/> of mappings.
-        /// </summary>
-        /// <param name="collection">A collection of <see cref="Mapping"/> elements.</param>
-        /// <param name="sourceIndex">The ordinal position of the source column/field/item within the data source.</param>
-        /// <param name="destination">The name of the destination column/field/item within the data destination.</param>
-        public static void AddMapping(this ICollection<Mapping> collection, int sourceIndex, string destination)
-        {
-            Validator.ThrowIfNull(collection);
-            collection.Add(new IndexMapping(sourceIndex, destination));
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="Mapping"/> using a column/field/item name to describe the <paramref name="source"/> and an ordinal to specify the <paramref name="destinationIndex"/> which is added to the specified <paramref name="collection"/> of mappings.
-        /// </summary>
-        /// <param name="collection">A collection of <see cref="Mapping"/> elements.</param>
-        /// <param name="source">The name of the column/field/item within the data source.</param>
-        /// <param name="destinationIndex">The ordinal position of the destination column/field/item within the data destination.</param>
-        public static void AddMapping(this ICollection<Mapping> collection, string source, int destinationIndex)
-        {
-            Validator.ThrowIfNull(collection);
-            collection.Add(new IndexMapping(source, destinationIndex));
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="Mapping"/> using ordinals to specify both <paramref name="sourceIndex"/> and <paramref name="destinationIndex"/> columns/fields/items which is added to the specified <paramref name="collection"/> of mappings.
-        /// </summary>
-        /// <param name="collection">A collection of <see cref="Mapping"/> elements.</param>
-        /// <param name="sourceIndex">The ordinal position of the source column/field/item within the data source.</param>
-        /// <param name="destinationIndex">The ordinal position of the destination column/field/item within the data destination.</param>
-        public static void AddMapping(this ICollection<Mapping> collection, int sourceIndex, int destinationIndex)
-        {
-            Validator.ThrowIfNull(collection);
-            collection.Add(new IndexMapping(sourceIndex, destinationIndex));
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Cuemon.Core/Hierarchy.cs b/src/Cuemon.Extensions.Core/Runtime/Hierarchy.cs
similarity index 92%
rename from src/Cuemon.Core/Hierarchy.cs
rename to src/Cuemon.Extensions.Core/Runtime/Hierarchy.cs
index 8d8025b25..728efb04c 100644
--- a/src/Cuemon.Core/Hierarchy.cs
+++ b/src/Cuemon.Extensions.Core/Runtime/Hierarchy.cs
@@ -3,9 +3,8 @@
 using System.Linq;
 using System.Reflection;
 using System.Text;
-using Cuemon.Reflection;
 
-namespace Cuemon
+namespace Cuemon.Extensions.Runtime
 {
     /// <summary>
     /// Represents a way to expose a node of a hierarchical structure, including the node object of type <typeparamref name="T"/>.
@@ -15,7 +14,6 @@ public sealed class Hierarchy<T> : Wrapper<T>, IHierarchy<T>
     {
         private SortedList<int, IHierarchy<T>> _children;
 
-        #region Constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="Hierarchy{T}" /> class.
         /// </summary>
@@ -23,9 +21,7 @@ public Hierarchy()
         {
             IsNew = true;
         }
-        #endregion
 
-        #region Properties
         private bool IsNew { get; set; }
 
         /// <summary>
@@ -44,13 +40,13 @@ public Hierarchy()
         /// Gets a value indicating whether this instance has a parent.
         /// </summary>
         /// <value><c>true</c> if this instance has a parent; otherwise, <c>false</c>.</value>
-        public bool HasParent => (Parent != null);
+        public bool HasParent => Parent != null;
 
         /// <summary>
         /// Gets a value indicating whether this instance has any children.
         /// </summary>
         /// <value><c>true</c> if this instance has any children; otherwise, <c>false</c>.</value>
-        public bool HasChildren => (Children.Count > 0);
+        public bool HasChildren => Children.Count > 0;
 
         private SortedList<int, IHierarchy<T>> Children => _children ??= new SortedList<int, IHierarchy<T>>();
 
@@ -62,9 +58,6 @@ public Hierarchy()
         /// <value>The node at the specified index.</value>
         public IHierarchy<T> this[int index] => Decorator.Enclose(this).NodeAt(index);
 
-        #endregion
-
-        #region Methods
         /// <summary>
         /// Allows for the instance on the current node to be replaced with a new <paramref name="instance" />.
         /// </summary>
@@ -211,7 +204,6 @@ public IHierarchy<T> GetParent()
         {
             return Parent;
         }
-        #endregion
     }
 
     /// <summary>
@@ -239,12 +231,12 @@ public static IEnumerable<IHierarchy<T>> Find<T>(IHierarchy<T> hierarchy, Func<I
         /// Gets the tree structure of the specified <paramref name="source"/> wrapped in an <see cref="IHierarchy{T}"/> node representing a hierarchical structure.
         /// </summary>
         /// <param name="source">The source whose properties will be traversed while building the hierarchical structure.</param>
-        /// <param name="setup">The <see cref="ObjectHierarchyOptions"/> which need to be configured.</param>
+        /// <param name="setup">The <see cref="HierarchyOptions"/> which need to be configured.</param>
         /// <returns>An <see cref="IHierarchy{T}"/> node representing the entirety of a hierarchical structure from the specified <paramref name="source"/>.</returns>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source"/> is null.
         /// </exception>
-        public static IHierarchy<object> GetObjectHierarchy(object source, Action<ObjectHierarchyOptions> setup = null)
+        public static IHierarchy<object> GetObjectHierarchy(object source, Action<HierarchyOptions> setup = null)
         {
             Validator.ThrowIfNull(source);
             var options = Patterns.Configure(setup);
@@ -320,15 +312,15 @@ public static IHierarchy<object> GetObjectHierarchy(object source, Action<Object
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source"/> -or- <paramref name="traversal"/> is null.
         /// </exception>
-        public static IEnumerable<TSource> WhileSourceTraversalIsNotNull<TSource>(TSource source, Func<TSource, TSource> traversal) where TSource : class
+        public static IEnumerable<TSource> TraverseWhileNotNull<TSource>(TSource source, Func<TSource, TSource> traversal) where TSource : class
         {
             Validator.ThrowIfNull(source);
             Validator.ThrowIfNull(traversal);
 
-            return WhileSourceTraversalIsNotNullIterator(source, traversal);
+            return TraverseWhileNotNullIterator(source, traversal);
         }
 
-        private static IEnumerable<TSource> WhileSourceTraversalIsNotNullIterator<TSource>(TSource source, Func<TSource, TSource> traversal) where TSource : class
+        private static IEnumerable<TSource> TraverseWhileNotNullIterator<TSource>(TSource source, Func<TSource, TSource> traversal) where TSource : class
         {
             var stack = new Stack<TSource>();
             stack.Push(traversal(source));
@@ -351,19 +343,9 @@ private static IEnumerable<TSource> WhileSourceTraversalIsNotNullIterator<TSourc
         /// <exception cref="ArgumentNullException">
         /// <paramref name="source"/> -or- <paramref name="traversal"/> is null.
         /// </exception>
-        public static IEnumerable<TSource> WhileSourceTraversalHasElements<TSource>(TSource source, Func<TSource, IEnumerable<TSource>> traversal) where TSource : class
+        public static IEnumerable<TSource> TraverseWhileNotEmpty<TSource>(TSource source, Func<TSource, IEnumerable<TSource>> traversal) where TSource : class
         {
-            var stack = new Stack<TSource>();
-            stack.Push(source);
-            while (stack.Count != 0)
-            {
-                var current = stack.Pop();
-                foreach (var element in traversal(current))
-                {
-                    stack.Push(element);
-                }
-                yield return current;
-            }
+            return Decorator.EncloseToExpose(source).TraverseWhileNotEmpty(traversal);
         }
 
         internal static IHierarchy<TSource> AncestorsAndSelf<TSource>(IHierarchy<TSource> source)
diff --git a/src/Cuemon.Core/Extensions/HierarchyDecoratorExtensions.cs b/src/Cuemon.Extensions.Core/Runtime/HierarchyDecoratorExtensions.cs
similarity index 94%
rename from src/Cuemon.Core/Extensions/HierarchyDecoratorExtensions.cs
rename to src/Cuemon.Extensions.Core/Runtime/HierarchyDecoratorExtensions.cs
index 4aff91cb1..18be42f62 100644
--- a/src/Cuemon.Core/Extensions/HierarchyDecoratorExtensions.cs
+++ b/src/Cuemon.Extensions.Core/Runtime/HierarchyDecoratorExtensions.cs
@@ -6,7 +6,7 @@
 using System.Reflection;
 using Cuemon.Collections.Generic;
 
-namespace Cuemon
+namespace Cuemon.Extensions.Runtime
 {
     /// <summary>
     /// Extension methods for the <see cref="IHierarchy{T}"/> interface hidden behind the <see cref="IDecorator{T}"/> interface.
@@ -69,7 +69,7 @@ public static DateTime UseDateTimeFormatter(this IDecorator<IHierarchy<DataPair>
         public static Guid UseGuidFormatter(this IDecorator<IHierarchy<DataPair>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return UseGenericConverter<Guid>(decorator.Inner);
+            return decorator.Inner.UseGenericConverter<Guid>();
         }
 
         /// <summary>
@@ -83,7 +83,7 @@ public static Guid UseGuidFormatter(this IDecorator<IHierarchy<DataPair>> decora
         public static string UseStringFormatter(this IDecorator<IHierarchy<DataPair>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return UseGenericConverter<string>(decorator.Inner);
+            return decorator.Inner.UseGenericConverter<string>();
         }
 
         /// <summary>
@@ -97,7 +97,7 @@ public static string UseStringFormatter(this IDecorator<IHierarchy<DataPair>> de
         public static decimal UseDecimalFormatter(this IDecorator<IHierarchy<DataPair>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return UseGenericConverter<decimal>(decorator.Inner);
+            return decorator.Inner.UseGenericConverter<decimal>();
         }
 
         /// <summary>
@@ -155,7 +155,7 @@ public static IDictionary UseDictionary(this IDecorator<IHierarchy<DataPair>> de
         /// <returns>An <see cref="IWrapper{T}.Instance"/>  that match the conditions defined by the function delegate <paramref name="match"/>, or a default value if no node is found.</returns>
         public static T FindFirstInstance<T>(this IDecorator<IHierarchy<T>> decorator, Func<IHierarchy<T>, bool> match)
         {
-            return FindInstance(decorator, match).FirstOrDefault();
+            return decorator.FindInstance(match).FirstOrDefault();
         }
 
         /// <summary>
@@ -167,7 +167,7 @@ public static T FindFirstInstance<T>(this IDecorator<IHierarchy<T>> decorator, F
         /// <returns>An <see cref="IWrapper{T}.Instance"/> node that match the conditions defined by the function delegate <paramref name="match"/>, or a default value if no node instance is found.</returns>
         public static T FindSingleInstance<T>(this IDecorator<IHierarchy<T>> decorator, Func<IHierarchy<T>, bool> match)
         {
-            return FindInstance(decorator, match).SingleOrDefault();
+            return decorator.FindInstance(match).SingleOrDefault();
         }
 
         /// <summary>
@@ -179,7 +179,7 @@ public static T FindSingleInstance<T>(this IDecorator<IHierarchy<T>> decorator,
         /// <returns>An <see cref="IEnumerable{T}"/> sequence containing all node instances that match the conditions defined by the specified predicate, if found.</returns>
         public static IEnumerable<T> FindInstance<T>(this IDecorator<IHierarchy<T>> decorator, Func<IHierarchy<T>, bool> match)
         {
-            return Find(decorator, match).Select(h => h.Instance);
+            return decorator.Find(match).Select(h => h.Instance);
         }
 
         /// <summary>
@@ -191,7 +191,7 @@ public static IEnumerable<T> FindInstance<T>(this IDecorator<IHierarchy<T>> deco
         /// <returns>An <see cref="IHierarchy{T}"/> node that match the conditions defined by the function delegate <paramref name="match"/>, or a default value if no node is found.</returns>
         public static IHierarchy<T> FindFirst<T>(this IDecorator<IHierarchy<T>> decorator, Func<IHierarchy<T>, bool> match)
         {
-            return Find(decorator, match).FirstOrDefault();
+            return decorator.Find(match).FirstOrDefault();
         }
 
         /// <summary>
@@ -203,7 +203,7 @@ public static IHierarchy<T> FindFirst<T>(this IDecorator<IHierarchy<T>> decorato
         /// <returns>An <see cref="IHierarchy{T}"/> node that match the conditions defined by the function delegate <paramref name="match"/>, or a default value if no node is found.</returns>
         public static IHierarchy<T> FindSingle<T>(this IDecorator<IHierarchy<T>> decorator, Func<IHierarchy<T>, bool> match)
         {
-            return Find(decorator, match).SingleOrDefault();
+            return decorator.Find(match).SingleOrDefault();
         }
 
         /// <summary>
@@ -217,7 +217,7 @@ public static IEnumerable<IHierarchy<T>> Find<T>(this IDecorator<IHierarchy<T>>
         {
             Validator.ThrowIfNull(decorator);
             Validator.ThrowIfNull(match);
-            return DescendantsAndSelf(decorator).Where(match);
+            return decorator.DescendantsAndSelf().Where(match);
         }
 
         /// <summary>
@@ -245,7 +245,7 @@ public static void ReplaceAll<T>(this IDecorator<IEnumerable<IHierarchy<T>>> dec
             Validator.ThrowIfNull(replacer);
             foreach (var node in decorator.Inner)
             {
-                Replace(Decorator.Enclose(node), replacer);
+                Decorator.Enclose(node).Replace(replacer);
             }
         }
 
@@ -261,7 +261,7 @@ public static void ReplaceAll<T>(this IDecorator<IEnumerable<IHierarchy<T>>> dec
         public static IHierarchy<T> Root<T>(this IDecorator<IHierarchy<T>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return decorator.Inner.HasParent ? AncestorsAndSelf(decorator).FirstOrDefault() : decorator.Inner;
+            return decorator.Inner.HasParent ? decorator.AncestorsAndSelf().FirstOrDefault() : decorator.Inner;
         }
 
         /// <summary>
@@ -276,7 +276,7 @@ public static IHierarchy<T> Root<T>(this IDecorator<IHierarchy<T>> decorator)
         public static IEnumerable<IHierarchy<T>> AncestorsAndSelf<T>(this IDecorator<IHierarchy<T>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            IList<IHierarchy<T>> result = new List<IHierarchy<T>>(Hierarchy.WhileSourceTraversalIsNotNull(decorator.Inner, Hierarchy.AncestorsAndSelf));
+            IList<IHierarchy<T>> result = new List<IHierarchy<T>>(Hierarchy.TraverseWhileNotNull(decorator.Inner, Hierarchy.AncestorsAndSelf));
             return result.Count > 0 ? result.Reverse() : Arguments.Yield(decorator.Inner);
         }
 
@@ -292,7 +292,7 @@ public static IEnumerable<IHierarchy<T>> AncestorsAndSelf<T>(this IDecorator<IHi
         public static IEnumerable<IHierarchy<T>> DescendantsAndSelf<T>(this IDecorator<IHierarchy<T>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return Hierarchy.WhileSourceTraversalHasElements(decorator.Inner, Hierarchy.DescendantsAndSelf).Reverse();
+            return Hierarchy.TraverseWhileNotEmpty(decorator.Inner, Hierarchy.DescendantsAndSelf).Reverse();
         }
 
         /// <summary>
@@ -307,7 +307,7 @@ public static IEnumerable<IHierarchy<T>> DescendantsAndSelf<T>(this IDecorator<I
         public static IEnumerable<IHierarchy<T>> SiblingsAndSelf<T>(this IDecorator<IHierarchy<T>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            return SiblingsAndSelfAt(decorator, decorator.Inner.Depth);
+            return decorator.SiblingsAndSelfAt(decorator.Inner.Depth);
         }
 
         /// <summary>
@@ -327,8 +327,8 @@ public static IEnumerable<IHierarchy<T>> SiblingsAndSelfAt<T>(this IDecorator<IH
         {
             Validator.ThrowIfNull(decorator);
             Validator.ThrowIfLowerThan(depth, 0, nameof(depth));
-            var root = AncestorsAndSelf(decorator).FirstOrDefault();
-            var descendantsFromRoot = DescendantsAndSelf(Decorator.Enclose(root));
+            var root = decorator.AncestorsAndSelf().FirstOrDefault();
+            var descendantsFromRoot = Decorator.Enclose(root).DescendantsAndSelf();
             foreach (var descendantItem in descendantsFromRoot)
             {
                 if (descendantItem.Depth == depth) { yield return descendantItem; }
@@ -353,7 +353,7 @@ public static IHierarchy<T> NodeAt<T>(this IDecorator<IHierarchy<T>> decorator,
             Validator.ThrowIfNull(decorator);
             Validator.ThrowIfLowerThan(index, 0, nameof(index));
             if (decorator.Inner.Index == index) { return decorator.Inner; }
-            var allNodes = FlattenAll(decorator);
+            var allNodes = decorator.FlattenAll();
             foreach (var element in allNodes)
             {
                 if (element.Index == index) { return element; }
@@ -373,8 +373,8 @@ public static IHierarchy<T> NodeAt<T>(this IDecorator<IHierarchy<T>> decorator,
         public static IEnumerable<IHierarchy<T>> FlattenAll<T>(this IDecorator<IHierarchy<T>> decorator)
         {
             Validator.ThrowIfNull(decorator);
-            var root = AncestorsAndSelf(decorator).FirstOrDefault();
-            return DescendantsAndSelf(Decorator.Enclose(root));
+            var root = decorator.AncestorsAndSelf().FirstOrDefault();
+            return Decorator.Enclose(root).DescendantsAndSelf();
         }
 
         private static T UseGenericConverter<T>(this IHierarchy<DataPair> hierarchy)
diff --git a/src/Cuemon.Core/Reflection/ObjectHierarchyOptions.cs b/src/Cuemon.Extensions.Core/Runtime/HierarchyOptions.cs
similarity index 94%
rename from src/Cuemon.Core/Reflection/ObjectHierarchyOptions.cs
rename to src/Cuemon.Extensions.Core/Runtime/HierarchyOptions.cs
index 77c05e124..3e256b046 100644
--- a/src/Cuemon.Core/Reflection/ObjectHierarchyOptions.cs
+++ b/src/Cuemon.Extensions.Core/Runtime/HierarchyOptions.cs
@@ -1,15 +1,16 @@
 using System;
 using System.Reflection;
 using Cuemon.Configuration;
-using Cuemon.Runtime.Serialization;
+using Cuemon.Extensions.Runtime.Serialization;
+using Cuemon.Reflection;
 
-namespace Cuemon.Reflection
+namespace Cuemon.Extensions.Runtime
 {
     /// <summary>
     /// Specifies options that is related to <see cref="Hierarchy"/> and <see cref="HierarchySerializer"/> operations.
     /// </summary>
     /// <seealso cref="IParameterObject"/>
-    public class ObjectHierarchyOptions : IParameterObject
+    public class HierarchyOptions : IParameterObject
     {
         private int _maxDepth;
         private int _maxCircularCalls;
@@ -20,9 +21,9 @@ public class ObjectHierarchyOptions : IParameterObject
         private MemberReflection _reflectionRules;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ObjectHierarchyOptions"/> class.
+        /// Initializes a new instance of the <see cref="HierarchyOptions"/> class.
         /// </summary>
-        public ObjectHierarchyOptions()
+        public HierarchyOptions()
         {
             MaxDepth = 10;
             MaxCircularCalls = 2;
@@ -66,7 +67,7 @@ public ObjectHierarchyOptions()
                         property.Name.Equals("TargetSite", StringComparison.Ordinal));
             };
             HasCircularReference = i => Decorator.Enclose(i.GetType()).HasCircularReference(i);
-            ValueResolver = Infrastructure.DefaultPropertyValueResolver;
+            ValueResolver = (s, i) => Decorator.RawEnclose(s).DefaultPropertyValueResolver(i);
         }
 
         /// <summary>
diff --git a/src/Cuemon.Core/IHierarchy.cs b/src/Cuemon.Extensions.Core/Runtime/IHierarchy.cs
similarity index 97%
rename from src/Cuemon.Core/IHierarchy.cs
rename to src/Cuemon.Extensions.Core/Runtime/IHierarchy.cs
index a9b8eb0eb..576b898e6 100644
--- a/src/Cuemon.Core/IHierarchy.cs
+++ b/src/Cuemon.Extensions.Core/Runtime/IHierarchy.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 
-namespace Cuemon
+namespace Cuemon.Extensions.Runtime
 {
     /// <summary>
     /// Provides a generic way to expose a node of a hierarchical structure, including the node object of type <typeparamref name="T"/>.
@@ -10,7 +10,6 @@ namespace Cuemon
     /// <typeparam name="T">The type of the node represented in the hierarchical structure.</typeparam>
     public interface IHierarchy<T> : IWrapper<T>
     {
-        #region Properties
         /// <summary>
         /// Indicates whether the current node has a parent node.
         /// </summary>
@@ -40,9 +39,7 @@ public interface IHierarchy<T> : IWrapper<T>
         /// </summary>
         /// <value>The node at the specified index.</value>
         IHierarchy<T> this[int index] { get; }
-        #endregion
 
-        #region Methods
         /// <summary>
         /// Adds the specified instance to a node in the hierarchical structure representation.
         /// </summary>
@@ -88,6 +85,5 @@ public interface IHierarchy<T> : IWrapper<T>
         /// </summary>
         /// <returns>An <see cref="IEnumerable{T}"/> sequence that represents all the child nodes of the current hierarchical node.</returns>
         IEnumerable<IHierarchy<T>> GetChildren();
-        #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cuemon.Core/Runtime/Serialization/HierarchySerializer.cs b/src/Cuemon.Extensions.Core/Runtime/Serialization/HierarchySerializer.cs
similarity index 85%
rename from src/Cuemon.Core/Runtime/Serialization/HierarchySerializer.cs
rename to src/Cuemon.Extensions.Core/Runtime/Serialization/HierarchySerializer.cs
index 9189e0472..bed41e2a6 100644
--- a/src/Cuemon.Core/Runtime/Serialization/HierarchySerializer.cs
+++ b/src/Cuemon.Extensions.Core/Runtime/Serialization/HierarchySerializer.cs
@@ -1,8 +1,7 @@
 using System;
 using System.Text;
-using Cuemon.Reflection;
 
-namespace Cuemon.Runtime.Serialization
+namespace Cuemon.Extensions.Runtime.Serialization
 {
     /// <summary>
     /// Provides a way to serialize objects to nodes of <see cref="IHierarchy{T}"/>.
@@ -13,8 +12,8 @@ public class HierarchySerializer
         /// Initializes a new instance of the <see cref="HierarchySerializer"/> class.
         /// </summary>
         /// <param name="source">The object to convert to nodes of <see cref="IHierarchy{T}"/>.</param>
-        /// <param name="setup">The <see cref="ObjectHierarchyOptions"/> which need to be configured.</param>
-        public HierarchySerializer(object source, Action<ObjectHierarchyOptions> setup = null)
+        /// <param name="setup">The <see cref="HierarchyOptions"/> which need to be configured.</param>
+        public HierarchySerializer(object source, Action<HierarchyOptions> setup = null)
         {
             Nodes = Decorator.Enclose(Hierarchy.GetObjectHierarchy(source, setup)).Root();
         }
diff --git a/src/Cuemon.Core/VerticalDirection.cs b/src/Cuemon.Extensions.Core/VerticalDirection.cs
similarity index 91%
rename from src/Cuemon.Core/VerticalDirection.cs
rename to src/Cuemon.Extensions.Core/VerticalDirection.cs
index 7c49e010f..ee131a851 100644
--- a/src/Cuemon.Core/VerticalDirection.cs
+++ b/src/Cuemon.Extensions.Core/VerticalDirection.cs
@@ -1,4 +1,4 @@
-namespace Cuemon
+namespace Cuemon.Extensions
 {
     /// <summary>
     /// Specifies a set of values defining a vertical direction.
@@ -14,4 +14,4 @@ public enum VerticalDirection
         /// </summary>
         Up
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cuemon.Core/Wrapper.cs b/src/Cuemon.Extensions.Core/Wrapper.cs
similarity index 98%
rename from src/Cuemon.Core/Wrapper.cs
rename to src/Cuemon.Extensions.Core/Wrapper.cs
index 4d5e9f237..ad13b6fb8 100644
--- a/src/Cuemon.Core/Wrapper.cs
+++ b/src/Cuemon.Extensions.Core/Wrapper.cs
@@ -3,7 +3,7 @@
 using System.Globalization;
 using System.Reflection;
 
-namespace Cuemon
+namespace Cuemon.Extensions
 {
     /// <summary>
     /// Provides helper method for a <see cref="Wrapper{T}"/> object.
@@ -84,7 +84,6 @@ public class Wrapper<T> : IWrapper<T>
         private Type _instanceType;
         private MemberInfo _memberReference;
 
-        #region Constructors
         /// <summary>
         /// Initializes a new instance of the <see cref="Wrapper{T}"/> class.
         /// </summary>
@@ -103,9 +102,7 @@ public Wrapper(T instance, MemberInfo memberReference = null)
             _instanceType = instance.GetType();
             _memberReference = memberReference;
         }
-        #endregion
 
-        #region Properties
         /// <summary>
         /// Gets the object that this wrapper represents.
         /// </summary>
@@ -148,9 +145,6 @@ public virtual MemberInfo MemberReference
         /// <value>An object that implements the <see cref="IDictionary{TKey,TValue}"/> interface and contains a collection of user-defined key/value pairs.</value>
         public virtual IDictionary<string, object> Data { get; } = new Dictionary<string, object>();
 
-        #endregion
-
-        #region Methods
         /// <summary>
         /// Returns a value that is equivalent to the instance of the object that this wrapper represents.
         /// </summary>
@@ -199,6 +193,5 @@ public override string ToString()
         {
             return Wrapper.ParseInstance(this);
         }
-        #endregion
     }
 }
diff --git a/src/Cuemon.Extensions.Text.Json/GlobalSuppressions.cs b/src/Cuemon.Extensions.Text.Json/GlobalSuppressions.cs
index cbabe6827..5d5c3bb5b 100644
--- a/src/Cuemon.Extensions.Text.Json/GlobalSuppressions.cs
+++ b/src/Cuemon.Extensions.Text.Json/GlobalSuppressions.cs
@@ -5,6 +5,4 @@
 
 using System.Diagnostics.CodeAnalysis;
 
-[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "Transitioned legacy code ;-)", Scope = "member", Target = "~M:Cuemon.Extensions.Text.Json.JsonReaderExtensions.ToHierarchy(System.Text.Json.Utf8JsonReader)~Cuemon.IHierarchy{Cuemon.DataPair}")]
-[assembly: SuppressMessage("Major Code Smell", "S907:\"goto\" statement should not be used", Justification = "Transitioned legacy code ;-)", Scope = "member", Target = "~M:Cuemon.Extensions.Text.Json.JsonReaderExtensions.ToHierarchy(System.Text.Json.Utf8JsonReader)~Cuemon.IHierarchy{Cuemon.DataPair}")]
 [assembly: SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "False-positive; .NET 7 reads this value.", Scope = "member", Target = "~P:Cuemon.Extensions.Text.Json.Converters.FlagsEnumConverter.TypeToConvert")]
diff --git a/src/Cuemon.Extensions.Text.Json/JsonReaderExtensions.cs b/src/Cuemon.Extensions.Text.Json/JsonReaderExtensions.cs
deleted file mode 100644
index f5b4bae91..000000000
--- a/src/Cuemon.Extensions.Text.Json/JsonReaderExtensions.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-using System.Collections.Generic;
-using System.Text.Json;
-using Cuemon.Text;
-using Cuemon.Collections.Generic;
-
-namespace Cuemon.Extensions.Text.Json
-{
-    /// <summary>
-    /// Extension methods for the <see cref="Utf8JsonReader"/> struct.
-    /// </summary>
-    public static class JsonReaderExtensions
-    {
-        private const string PropertyNameKey = "reader.Value";
-
-        /// <summary>
-        /// Converts the JSON hierarchy of an <see cref="Utf8JsonReader"/> into an <see cref="IHierarchy{T}"/>.
-        /// </summary>
-        /// <param name="reader">The reader to convert.</param>
-        /// <returns>An <see cref="IHierarchy{T}"/> implementation that uses <see cref="DataPair"/>.</returns>
-        public static IHierarchy<DataPair> ToHierarchy(this Utf8JsonReader reader)
-        {
-            var index = 0;
-            var depthIndexes = new Dictionary<int, Dictionary<int, int>>();
-            var dimension = 0;
-            IHierarchy<DataPair> hierarchy = new Hierarchy<DataPair>();
-            var array = new List<DataPair>();
-            hierarchy.Add(new DataPair("root", null, typeof(string)));
-            while (reader.Read())
-            {
-                object typeStrongValue;
-                switch (reader.TokenType)
-                {
-                    case JsonTokenType.StartArray:
-                        if (reader.TokenType == JsonTokenType.EndArray) { goto case JsonTokenType.EndArray; }
-                        if (reader.TokenType != JsonTokenType.StartArray && reader.TokenType != JsonTokenType.StartObject && reader.TokenType != JsonTokenType.EndObject)
-                        {
-                            typeStrongValue = ParserFactory.FromValueType().Parse(reader.GetString());
-                            array.Add(new DataPair(hierarchy[index].Data[PropertyNameKey]?.ToString(), typeStrongValue, typeStrongValue.GetType()));
-                        }
-                        while (reader.Read()) { goto case JsonTokenType.StartArray; }
-                        break;
-                    case JsonTokenType.PropertyName:
-                        hierarchy[Decorator.Enclose(depthIndexes).GetDepthIndex(reader.CurrentDepth, index, dimension)].Add(new DataPair(reader.GetString(), null, typeof(string))).Data.Add(PropertyNameKey, reader.GetString());
-                        index++;
-                        break;
-                    case JsonTokenType.EndArray:
-                        var indexCopy = index;
-                        foreach (var item in array)
-                        {
-                            hierarchy[indexCopy].Add(item);
-                            index++;
-                        }
-                        array.Clear();
-                        break;
-                    case JsonTokenType.EndObject:
-                        if (reader.CurrentDepth == 1) { dimension++; }
-                        break;
-                    case JsonTokenType.Number:
-                    case JsonTokenType.String:
-                    case JsonTokenType.True:
-                    case JsonTokenType.False:
-                    case JsonTokenType.Null:
-                        typeStrongValue = ParserFactory.FromValueType().Parse(reader.GetString());
-                        hierarchy[index].Replace(new DataPair(hierarchy[index].Data[PropertyNameKey]?.ToString(), typeStrongValue, typeStrongValue.GetType()));
-                        hierarchy[index].Data.Remove(PropertyNameKey);
-                        break;
-                }
-            }
-            return hierarchy;
-        }
-    }
-}
diff --git a/src/Cuemon.Extensions.Xml/HierarchyExtensions.cs b/src/Cuemon.Extensions.Xml/HierarchyExtensions.cs
index e07cdedca..eba9edd48 100644
--- a/src/Cuemon.Extensions.Xml/HierarchyExtensions.cs
+++ b/src/Cuemon.Extensions.Xml/HierarchyExtensions.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Xml.Serialization;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Xml;
 using Cuemon.Xml.Serialization;
 
@@ -74,4 +75,4 @@ public static IEnumerable<IHierarchy<T>> OrderByXmlAttributes<T>(this IEnumerabl
             return Decorator.Enclose(hierarchies).OrderByXmlAttributes();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cuemon.Extensions.Xml/XmlReaderExtensions.cs b/src/Cuemon.Extensions.Xml/XmlReaderExtensions.cs
index f1253c6a7..5de92055b 100644
--- a/src/Cuemon.Extensions.Xml/XmlReaderExtensions.cs
+++ b/src/Cuemon.Extensions.Xml/XmlReaderExtensions.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Xml;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Xml;
 
 namespace Cuemon.Extensions.Xml
diff --git a/src/Cuemon.Xml/Cuemon.Xml.csproj b/src/Cuemon.Xml/Cuemon.Xml.csproj
index 58b6ca218..02f7aa648 100644
--- a/src/Cuemon.Xml/Cuemon.Xml.csproj
+++ b/src/Cuemon.Xml/Cuemon.Xml.csproj
@@ -11,7 +11,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Cuemon.Core\Cuemon.Core.csproj" />
+    <ProjectReference Include="..\Cuemon.Extensions.Core\Cuemon.Extensions.Core.csproj" />
     <ProjectReference Include="..\Cuemon.Diagnostics\Cuemon.Diagnostics.csproj" />
   </ItemGroup>
 
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/Cuemon.Xml/Extensions/HierarchyDecoratorExtensions.cs b/src/Cuemon.Xml/Extensions/HierarchyDecoratorExtensions.cs
index 0ea6d868c..8c48a1345 100644
--- a/src/Cuemon.Xml/Extensions/HierarchyDecoratorExtensions.cs
+++ b/src/Cuemon.Xml/Extensions/HierarchyDecoratorExtensions.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Xml.Serialization;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Reflection;
 using Cuemon.Xml.Serialization;
 
diff --git a/src/Cuemon.Xml/Extensions/Serialization/Converters/XmlConverterDecoratorExtensions.cs b/src/Cuemon.Xml/Extensions/Serialization/Converters/XmlConverterDecoratorExtensions.cs
index 85b4b2287..4310b99b1 100644
--- a/src/Cuemon.Xml/Extensions/Serialization/Converters/XmlConverterDecoratorExtensions.cs
+++ b/src/Cuemon.Xml/Extensions/Serialization/Converters/XmlConverterDecoratorExtensions.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Xml;
 using Cuemon.Diagnostics;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Xml.Linq;
 
 namespace Cuemon.Xml.Serialization.Converters
diff --git a/src/Cuemon.Xml/Extensions/XmlReaderDecoratorExtensions.cs b/src/Cuemon.Xml/Extensions/XmlReaderDecoratorExtensions.cs
index 351a61ad2..0273ee419 100644
--- a/src/Cuemon.Xml/Extensions/XmlReaderDecoratorExtensions.cs
+++ b/src/Cuemon.Xml/Extensions/XmlReaderDecoratorExtensions.cs
@@ -5,6 +5,7 @@
 using System.Xml.XPath;
 using Cuemon.Text;
 using Cuemon.Collections.Generic;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Xml.Serialization;
 
 namespace Cuemon.Xml
diff --git a/src/Cuemon.Xml/Extensions/XmlWriterDecoratorExtensions.cs b/src/Cuemon.Xml/Extensions/XmlWriterDecoratorExtensions.cs
index 2e9c13eab..711588a4c 100644
--- a/src/Cuemon.Xml/Extensions/XmlWriterDecoratorExtensions.cs
+++ b/src/Cuemon.Xml/Extensions/XmlWriterDecoratorExtensions.cs
@@ -2,7 +2,8 @@
 using System.Reflection;
 using System.Xml;
 using Cuemon.Collections.Generic;
-using Cuemon.Runtime.Serialization;
+using Cuemon.Extensions.Runtime;
+using Cuemon.Extensions.Runtime.Serialization;
 using Cuemon.Xml.Serialization;
 using Cuemon.Xml.Serialization.Formatters;
 
diff --git a/src/Cuemon.Xml/GlobalSuppressions.cs b/src/Cuemon.Xml/GlobalSuppressions.cs
index 1e1230d11..f02a27557 100644
--- a/src/Cuemon.Xml/GlobalSuppressions.cs
+++ b/src/Cuemon.Xml/GlobalSuppressions.cs
@@ -7,8 +7,6 @@
 
 [assembly: SuppressMessage("Major Code Smell", "S907:\"goto\" statement should not be used", Justification = "Legacy implementation.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.DefaultXmlConverter.ParseReadXmlDefault(System.Xml.XmlReader,System.Type)~System.Object")]
 [assembly: SuppressMessage("Minor Code Smell", "S3626:Jump statements should not be redundant", Justification = "False-positive.", Scope = "member", Target = "~M:Cuemon.Xml.XmlStreamFactory.CreateStream(System.Action{System.Xml.XmlWriter},System.Action{System.Xml.XmlWriterSettings})~System.IO.Stream")]
-[assembly: SuppressMessage("Major Code Smell", "S907:\"goto\" statement should not be used", Justification = "Legacy implementation.", Scope = "member", Target = "~M:Cuemon.Xml.XmlReaderDecoratorExtensions.BuildHierarchy(System.Xml.XmlReader)~Cuemon.IHierarchy{Cuemon.DataPair}")]
-[assembly: SuppressMessage("Major Code Smell", "S1066:Collapsible \"if\" statements should be merged", Justification = "Readability; at least for me.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.DefaultXmlConverter.SkipIfNullOrEmptyEnumerable(Cuemon.IHierarchy{System.Object})~System.Boolean")]
 [assembly: SuppressMessage("Critical Bug", "S4275:Getters and setters should access the expected fields", Justification = "By design; to provide XmlIgnoreAttribute.", Scope = "member", Target = "~P:Cuemon.Xml.Serialization.XmlWrapper.InstanceType")]
 [assembly: SuppressMessage("Critical Bug", "S4275:Getters and setters should access the expected fields", Justification = "By design; to provide XmlIgnoreAttribute.", Scope = "member", Target = "~P:Cuemon.Xml.Serialization.XmlWrapper.MemberReference")]
 [assembly: SuppressMessage("Style", "IDE0130:Namespace does not match folder structure", Justification = "Intentional as these embark on IDecorator.", Scope = "namespace", Target = "~N:Cuemon.Xml")]
@@ -18,3 +16,7 @@
 [assembly: SuppressMessage("Security", "CA5372:Use XmlReader for XPathDocument constructor", Justification = "Convenience.", Scope = "member", Target = "~M:Cuemon.Xml.XPath.XPathDocumentFactory.CreateDocument(System.Uri)~System.Xml.XPath.XPathDocument")]
 [assembly: SuppressMessage("Security", "CA5372:Use XmlReader for XPathDocument constructor", Justification = "Convenience.", Scope = "member", Target = "~M:Cuemon.Xml.XPath.XPathDocumentFactory.CreateDocument(System.IO.Stream,System.Boolean)~System.Xml.XPath.XPathDocument")]
 [assembly: SuppressMessage("Major Code Smell", "S1172:Unused method parameters should be removed", Justification = "False-positive; value is conditionally used.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.ExceptionConverter.ParseXmlReader(System.Xml.XmlReader,System.Type)~System.Collections.Generic.Stack{System.Collections.Generic.IList{Cuemon.Reflection.MemberArgument}}")]
+[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "TODO - due to .NET 9 release this week, its kept as-is with this round of refactoring.", Scope = "member", Target = "~M:Cuemon.Xml.XmlReaderDecoratorExtensions.BuildHierarchy(System.Xml.XmlReader)~Cuemon.Extensions.Runtime.IHierarchy{Cuemon.DataPair}")]
+[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "TODO - due to .NET 9 release this week, its kept as-is with this round of refactoring.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.XmlConverterDecoratorExtensions.AddEnumerableConverter(Cuemon.IDecorator{System.Collections.Generic.IList{Cuemon.Xml.Serialization.Converters.XmlConverter}})~Cuemon.IDecorator{System.Collections.Generic.IList{Cuemon.Xml.Serialization.Converters.XmlConverter}}")]
+[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "TODO - due to .NET 9 release this week, its kept as-is with this round of refactoring.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.DefaultXmlConverter.ParseReadXmlDefault(System.Xml.XmlReader,System.Type)~System.Object")]
+[assembly: SuppressMessage("Critical Code Smell", "S3776:Cognitive Complexity of methods should not be too high", Justification = "TODO - due to .NET 9 release this week, its kept as-is with this round of refactoring.", Scope = "member", Target = "~M:Cuemon.Xml.Serialization.Converters.ExceptionConverter.ParseXmlReader(System.Xml.XmlReader,System.Type)~System.Collections.Generic.Stack{System.Collections.Generic.IList{Cuemon.Reflection.MemberArgument}}")]
diff --git a/src/Cuemon.Xml/Serialization/Converters/DefaultXmlConverter.cs b/src/Cuemon.Xml/Serialization/Converters/DefaultXmlConverter.cs
index cbc4ef64e..bc9e3f7fa 100644
--- a/src/Cuemon.Xml/Serialization/Converters/DefaultXmlConverter.cs
+++ b/src/Cuemon.Xml/Serialization/Converters/DefaultXmlConverter.cs
@@ -8,6 +8,8 @@
 using System.Xml;
 using System.Xml.Serialization;
 using Cuemon.Collections.Generic;
+using Cuemon.Extensions;
+using Cuemon.Extensions.Runtime;
 using Cuemon.Reflection;
 using Cuemon.Xml.Linq;
 
diff --git a/src/Cuemon.Xml/Serialization/XmlWrapper.cs b/src/Cuemon.Xml/Serialization/XmlWrapper.cs
index ed87c3daf..104bfa528 100644
--- a/src/Cuemon.Xml/Serialization/XmlWrapper.cs
+++ b/src/Cuemon.Xml/Serialization/XmlWrapper.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 using System.Xml.Serialization;
+using Cuemon.Extensions;
 
 namespace Cuemon.Xml.Serialization
 {
diff --git a/test/Cuemon.Core.Tests/Reflection/AssemblyDecoratorExtensionsTest.cs b/test/Cuemon.Core.Tests/Reflection/AssemblyDecoratorExtensionsTest.cs
index 269720070..a86b4d515 100644
--- a/test/Cuemon.Core.Tests/Reflection/AssemblyDecoratorExtensionsTest.cs
+++ b/test/Cuemon.Core.Tests/Reflection/AssemblyDecoratorExtensionsTest.cs
@@ -41,7 +41,7 @@ public void GetTypes_ShouldReturnAllTypesFromCuemonCore()
 
             TestOutput.WriteLine(disposableTypes.ToDelimitedString());
 
-            Assert.InRange(allTypesCount, 375, 425); // range because of tooling on CI adding dynamic types and high range of refactoring
+            Assert.InRange(allTypesCount, 325, 375); // range because of tooling on CI adding dynamic types and high range of refactoring
             Assert.Equal(5, disposableTypesCount);
             Assert.Equal(4, configurationTypesCount);
         }
diff --git a/test/Cuemon.Core.Tests/Runtime/Serialization/HierarchySerializerTest.cs b/test/Cuemon.Core.Tests/Runtime/Serialization/HierarchySerializerTest.cs
index ff91bdcef..c93eb29b9 100644
--- a/test/Cuemon.Core.Tests/Runtime/Serialization/HierarchySerializerTest.cs
+++ b/test/Cuemon.Core.Tests/Runtime/Serialization/HierarchySerializerTest.cs
@@ -1,5 +1,6 @@
 using Cuemon.Assets;
 using Codebelt.Extensions.Xunit;
+using Cuemon.Extensions.Runtime.Serialization;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/test/Cuemon.Core.Tests/Text/ParserFactoryTest.cs b/test/Cuemon.Core.Tests/Text/ParserFactoryTest.cs
index 2d26445ad..03b39043e 100644
--- a/test/Cuemon.Core.Tests/Text/ParserFactoryTest.cs
+++ b/test/Cuemon.Core.Tests/Text/ParserFactoryTest.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using Codebelt.Extensions.Xunit;
+using Cuemon.Extensions;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/test/Cuemon.Core.Tests/ValidatorTest.cs b/test/Cuemon.Core.Tests/ValidatorTest.cs
index 5038e7cd3..5bdf1d75f 100644
--- a/test/Cuemon.Core.Tests/ValidatorTest.cs
+++ b/test/Cuemon.Core.Tests/ValidatorTest.cs
@@ -8,6 +8,7 @@
 using Cuemon.Extensions;
 #endif
 using Codebelt.Extensions.Xunit;
+using Cuemon.Extensions;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/test/Cuemon.Extensions.Core.Tests/MappingExtensionsTest.cs b/test/Cuemon.Extensions.Core.Tests/MappingExtensionsTest.cs
deleted file mode 100644
index ec4ac0a54..000000000
--- a/test/Cuemon.Extensions.Core.Tests/MappingExtensionsTest.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Codebelt.Extensions.Xunit;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace Cuemon.Extensions
-{
-    public class MappingExtensionsTest : Test
-    {
-        public MappingExtensionsTest(ITestOutputHelper output) : base(output)
-        {
-        }
-
-        [Fact]
-        public void Add_ShouldAddMappingWithStringValues()
-        {
-            var sut1 = new List<Mapping>();
-            var sut2 = new List<Mapping>(sut1);
-            var sut3 = new Mapping("Source", "Destination");
-            sut2.AddMapping("Source", "Destination");
-
-            Assert.Empty(sut1);
-            Assert.Equal(1, sut2.Count);
-            Assert.Equal(sut3.Source, sut2.Single().Source);
-            Assert.Equal(sut3.Destination, sut2.Single().Destination);
-        }
-
-        [Fact]
-        public void Add_ShouldAddIndexMappingWithOrdinalAndString()
-        {
-            var sut1 = new List<Mapping>();
-            var sut2 = new List<Mapping>(sut1);
-            var sut3 = new IndexMapping(42, "Destination");
-            sut2.AddMapping(42, "Destination");
-
-            Assert.Empty(sut1);
-            Assert.Equal(1, sut2.Count);
-            Assert.Equal(sut3.SourceIndex, sut2.Single().As<IndexMapping>().SourceIndex);
-            Assert.Equal(sut3.Destination, sut2.Single().Destination);
-        }
-
-        [Fact]
-        public void Add_ShouldAddIndexMappingWithStringAndOrdinal()
-        {
-            var sut1 = new List<Mapping>();
-            var sut2 = new List<Mapping>(sut1);
-            var sut3 = new IndexMapping("Source", 42);
-            sut2.AddMapping("Source", 42);
-
-            Assert.Empty(sut1);
-            Assert.Equal(1, sut2.Count);
-            Assert.Equal(sut3.Source, sut2.Single().Source);
-            Assert.Equal(sut3.DestinationIndex, sut2.Single().As<IndexMapping>().DestinationIndex);
-        }
-
-        [Fact]
-        public void Add_ShouldAddIndexMappingWithOrdinals()
-        {
-            var sut1 = new List<Mapping>();
-            var sut2 = new List<Mapping>(sut1);
-            var sut3 = new IndexMapping(24, 42);
-            sut2.AddMapping(24, 42);
-
-            Assert.Empty(sut1);
-            Assert.Equal(1, sut2.Count);
-            Assert.Equal(sut3.SourceIndex, sut2.Single().As<IndexMapping>().SourceIndex);
-            Assert.Equal(sut3.DestinationIndex, sut2.Single().As<IndexMapping>().DestinationIndex);
-        }
-    }
-}
\ No newline at end of file
diff --git a/test/Cuemon.Extensions.Text.Json.Tests/Converters/JsonConverterCollectionExtensionsTest.cs b/test/Cuemon.Extensions.Text.Json.Tests/Converters/JsonConverterCollectionExtensionsTest.cs
index 41bda0b80..349b9cb4e 100644
--- a/test/Cuemon.Extensions.Text.Json.Tests/Converters/JsonConverterCollectionExtensionsTest.cs
+++ b/test/Cuemon.Extensions.Text.Json.Tests/Converters/JsonConverterCollectionExtensionsTest.cs
@@ -18,7 +18,7 @@ public JsonConverterCollectionExtensionsTest(ITestOutputHelper output) : base(ou
         [Fact]
         public void AddStringEnumConverter_ShouldAddStringEnumConverterToConverterCollection_WithPascalCase()
         {
-            var sut1 = HorizontalDirection.Left;
+            var sut1 = DayOfWeek.Friday;
             var sut2 = new JsonFormatterOptions();
             sut2.Settings.PropertyNamingPolicy = null; // set PascalCase
             sut2.Settings.Converters.Clear();
@@ -32,8 +32,8 @@ public void AddStringEnumConverter_ShouldAddStringEnumConverterToConverterCollec
 
                 var json = result.ToEncodedString();
 
-                Assert.True(jc.CanConvert(typeof(HorizontalDirection)));
-                Assert.Equal("\"Left\"", json);
+                Assert.True(jc.CanConvert(typeof(DayOfWeek)));
+                Assert.Equal("\"Friday\"", json);
 
                 TestOutput.WriteLine(json);
             });
@@ -73,7 +73,7 @@ public void AddStringFlagsEnumConverter_ShouldAddStringFlagsEnumConverterToConve
         [Fact]
         public void AddStringEnumConverter_ShouldAddStringEnumConverterToConverterCollection()
         {
-            var sut1 = HorizontalDirection.Left;
+            var sut1 = DayOfWeek.Friday;
             var sut2 = new JsonFormatterOptions();
             sut2.Settings.Converters.Clear();
             sut2.Settings.Converters.AddStringEnumConverter();
@@ -86,8 +86,8 @@ public void AddStringEnumConverter_ShouldAddStringEnumConverterToConverterCollec
 
                 var json = result.ToEncodedString();
 
-                Assert.True(jc.CanConvert(typeof(HorizontalDirection)));
-                Assert.Equal("\"left\"", json);
+                Assert.True(jc.CanConvert(typeof(DayOfWeek)));
+                Assert.Equal("\"friday\"", json);
 
                 TestOutput.WriteLine(json);
             });
diff --git a/test/Cuemon.Extensions.Xml.Tests/XmlReaderExtensionsTest.cs b/test/Cuemon.Extensions.Xml.Tests/XmlReaderExtensionsTest.cs
index 722e71be4..6b163e1f2 100644
--- a/test/Cuemon.Extensions.Xml.Tests/XmlReaderExtensionsTest.cs
+++ b/test/Cuemon.Extensions.Xml.Tests/XmlReaderExtensionsTest.cs
@@ -4,7 +4,7 @@
 using Cuemon.Extensions.IO;
 using Cuemon.Extensions.Xml.Assets;
 using Codebelt.Extensions.Xunit;
-using Cuemon.Runtime.Serialization;
+using Cuemon.Extensions.Runtime.Serialization;
 using Cuemon.Xml.Serialization.Formatters;
 using Xunit;
 using Xunit.Abstractions;
@@ -112,6 +112,7 @@ public void ToHierarchy_ShouldConvertReaderToHierarchy()
             var sut4 = sut3.ToHierarchy();
             var sut5 = sut4.GetChildren(); // namespace
 
+            TestOutput.WriteLine(sut1.ToString());
             TestOutput.WriteLine(sut2.ToEncodedString());
 
             Assert.NotNull(sut3);
diff --git a/test/Cuemon.Security.Cryptography.Tests/UnkeyedHashFactoryTest.cs b/test/Cuemon.Security.Cryptography.Tests/UnkeyedHashFactoryTest.cs
index 8b0646ad3..aa72f9f5a 100644
--- a/test/Cuemon.Security.Cryptography.Tests/UnkeyedHashFactoryTest.cs
+++ b/test/Cuemon.Security.Cryptography.Tests/UnkeyedHashFactoryTest.cs
@@ -26,7 +26,7 @@ public void CreateCryptoSha384_ShouldBeValidHashResult()
             var h = UnkeyedHashFactory.CreateCryptoSha384();
             Assert.Equal("1761336e3f7cbfe51deb137f026f89e01a448e3b1fafa64039c1464ee8732f11a5341a6f41e0c202294736ed64db1a84", h.ComputeHash(Alphanumeric.LettersAndNumbers).ToHexadecimalString());
             Assert.Equal("90ae531f24e48697904a4d0286f354c50a350ebb6c2b9efcb22f71c96ceaeffc11c6095e9ca0df0ec30bf685dcf2e5e5", h.ComputeHash(Alphanumeric.Numbers).ToHexadecimalString());
-            Assert.Equal("7210af19145ec2a8e250a7fe8e9eeeac1301e524daab82366c36be614dc35402a289101e48cad61c45337f2f32c14fdc", h.ComputeHash(VerticalDirection.Up).ToHexadecimalString());
+            Assert.Equal("d3b3f28933c5c91daa6a355aef5e09252e9c78baf751db717a2fde4b88e962a55e740acd869a3057b6020ad68e650a5f", h.ComputeHash(DayOfWeek.Friday).ToHexadecimalString());
         }
 
         [Fact]