Merge branch 'development' of https://github.com/o3de/o3de into sc-editor-asset-redux

2021-10-28 10:51:40 -07:00
parent 658da08495 67f90a9b37
commit 1b9f6c385d
1233 changed files with 62254 additions and 14819 deletions
@@ -65,8 +65,35 @@ namespace AZ

            //////////////////////////////////////////////////////////////////////////
            // EBusTraits overrides - Application is a singleton
-            static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-            typedef AZStd::recursive_mutex MutexType;
+            static constexpr AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+            using MutexType = AZStd::recursive_mutex;
+
+            static constexpr bool EnableEventQueue = true;
+            using EventQueueMutexType = AZStd::mutex;
+            struct PostThreadDispatchInvoker
+            {
+                ~PostThreadDispatchInvoker();
+            };
+
+            template <typename DispatchMutex>
+            struct ThreadDispatchLockGuard
+            {
+                ThreadDispatchLockGuard(DispatchMutex& contextMutex)
+                    : m_lock{ contextMutex }
+                {}
+                ThreadDispatchLockGuard(DispatchMutex& contextMutex, AZStd::adopt_lock_t adopt_lock)
+                    : m_lock{ contextMutex, adopt_lock }
+                {}
+                ThreadDispatchLockGuard(const ThreadDispatchLockGuard&) = delete;
+                ThreadDispatchLockGuard& operator=(const ThreadDispatchLockGuard&) = delete;
+            private:
+                PostThreadDispatchInvoker m_threadPolicyInvoker;
+                using LockType = AZStd::conditional_t<LocklessDispatch, AZ::Internal::NullLockGuard<DispatchMutex>, AZStd::scoped_lock<DispatchMutex>>;
+                LockType m_lock;
+            };
+
+            template <typename DispatchMutex, bool>
+            using DispatchLockGuard = ThreadDispatchLockGuard<DispatchMutex>;
            //////////////////////////////////////////////////////////////////////////

            virtual ~AssetCatalogRequests() = default;
@@ -200,6 +227,17 @@ namespace AZ

        using AssetCatalogRequestBus = AZ::EBus<AssetCatalogRequests>;

+        inline AssetCatalogRequests::PostThreadDispatchInvoker::~PostThreadDispatchInvoker()
+        {
+            if (!AssetCatalogRequestBus::IsInDispatchThisThread())
+            {
+                if (AssetCatalogRequestBus::QueuedEventCount())
+                {
+                    AssetCatalogRequestBus::ExecuteQueuedEvents();
+                }
+            }
+        }
+
        /*
         * Events that AssetManager listens for
         */
@@ -14,6 +14,7 @@
 #include <AzCore/Casting/lossy_cast.h>

 #include <AzCore/Component/ComponentApplication.h>
+#include <AzCore/Component/ComponentApplicationLifecycle.h>
 #include <AzCore/Component/TickBus.h>

 #include <AzCore/Debug/LocalFileEventLogger.h>
@@ -44,8 +45,6 @@
 #include <AzCore/Module/Module.h>
 #include <AzCore/Module/ModuleManager.h>

-#include <AzCore/IO/FileIO.h>
-#include <AzCore/IO/Path/Path_fwd.h>
 #include <AzCore/IO/SystemFile.h>

 #include <AzCore/Driller/Driller.h>
@@ -506,6 +505,16 @@ namespace AZ
        SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(*m_settingsRegistry, m_commandLine, executeRegDumpCommands);
        SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(*m_settingsRegistry);

+        // The /O3DE/Application/LifecycleEvents array contains a valid set of lifecycle events
+        // Those lifecycle events are normally read from the <engine-root>/Registry
+        // which isn't merged until ComponentApplication::Create invokes MergeSettingsToRegistry
+        // So pre-populate the valid lifecycle even entries
+        ComponentApplicationLifecycle::RegisterEvent(*m_settingsRegistry, "SystemAllocatorCreated");
+        ComponentApplicationLifecycle::RegisterEvent(*m_settingsRegistry, "SettingsRegistryAvailable");
+        ComponentApplicationLifecycle::RegisterEvent(*m_settingsRegistry, "ConsoleAvailable");
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "SystemAllocatorCreated", R"({})");
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "SettingsRegistryAvailable", R"({})");
+
        // Create the Module Manager
        m_moduleManager = AZStd::make_unique<ModuleManager>();

@@ -520,6 +529,7 @@ namespace AZ
            m_ownsConsole = true;
            m_console->LinkDeferredFunctors(AZ::ConsoleFunctorBase::GetDeferredHead());
            m_settingsRegistryConsoleFunctors = AZ::SettingsRegistryConsoleUtils::RegisterAzConsoleCommands(*m_settingsRegistry, *m_console);
+            ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "ConsoleAvailable", R"({})");
        }
    }

@@ -551,6 +561,7 @@ namespace AZ
        {
            AZ::Interface<AZ::IConsole>::Unregister(m_console);
            delete m_console;
+            ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "ConsoleUnavailable", R"({})");
        }

        m_moduleManager.reset();
@@ -558,6 +569,8 @@ namespace AZ
        if (AZ::SettingsRegistry::Get() == m_settingsRegistry.get())
        {
            SettingsRegistry::Unregister(m_settingsRegistry.get());
+            ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "SettingsRegistryUnavailable", R"({})");
+            ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "SystemAllocatorPendingDestruction", R"({})");
        }
        m_settingsRegistry.reset();

@@ -672,6 +685,8 @@ namespace AZ
        ReflectionEnvironment::GetReflectionManager()->Reflect(azrtti_typeid(this), [this](ReflectContext* context) {Reflect(context); });

        RegisterCoreComponents();
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "ReflectionManagerAvailable", R"({})");
+
        TickBus::AllowFunctionQueuing(true);
        SystemTickBus::AllowFunctionQueuing(true);

@@ -691,6 +706,7 @@ namespace AZ

        // Load the actual modules
        LoadModules();
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "GemsLoaded", R"({})");

        // Execute user.cfg after modules have been loaded but before processing any command-line overrides
        AZ::IO::FixedMaxPath platformCachePath;
@@ -756,12 +772,14 @@ namespace AZ
        m_entities.rehash(0); // force free all memory

        DestroyReflectionManager();
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "ReflectionManagerUnavailable", R"({})");

        static_cast<SettingsRegistryImpl*>(m_settingsRegistry.get())->ClearNotifiers();
        static_cast<SettingsRegistryImpl*>(m_settingsRegistry.get())->ClearMergeEvents();

        // Uninit and unload any dynamic modules.
        m_moduleManager->UnloadModules();
+        ComponentApplicationLifecycle::SignalEvent(*m_settingsRegistry, "GemsUnloaded", R"({})");

        NameDictionary::Destroy();

@@ -175,6 +175,8 @@ namespace AZ
            bool m_loadDynamicModules = true;
            //! Used by test fixtures to ensure reflection occurs to edit context.
            bool m_createEditContext = false;
+            //! Indicates whether the AssetCatalog.xml should be loaded by default in Application::StartCommon
+            bool m_loadAssetCatalog = true;
        };

        ComponentApplication();
@@ -356,7 +358,7 @@ namespace AZ
        /// Calculates the root directory of the engine.
        void CalculateEngineRoot();

-        /// Calculates the directory where the bootstrap.cfg file resides.
+        /// Deprecated: The term "AppRoot" has no meaning
        void CalculateAppRoot();

        template<typename Iterator>
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Component/ComponentApplicationLifecycle.h>
+#include <AzCore/Settings/SettingsRegistryVisitorUtils.h>
+
+namespace AZ::ComponentApplicationLifecycle
+{
+    bool ValidateEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+        using Type = SettingsRegistryInterface::Type;
+        FixedValueString eventRegistrationKey{ ApplicationLifecycleEventRegistrationKey };
+        eventRegistrationKey += '/';
+        eventRegistrationKey += eventName;
+        return settingsRegistry.GetType(eventRegistrationKey) == Type::Object;
+    }
+
+    bool SignalEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName, AZStd::string_view eventValue)
+    {
+        using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
+        using Format = AZ::SettingsRegistryInterface::Format;
+
+        if (!ValidateEvent(settingsRegistry, eventName))
+        {
+            AZ_Warning("ComponentApplicationLifecycle", false, R"(Cannot signal event %.*s. Name does is not a field of object "%.*s".)"
+                R"( Please make sure the entry exists in the '<engine-root>/Registry/application_lifecycle_events.setreg")"
+                " or in *.setreg within the project", AZ_STRING_ARG(eventName), AZ_STRING_ARG(ApplicationLifecycleEventRegistrationKey));
+            return false;
+        }
+        auto eventRegistrationKey = FixedValueString::format("%.*s/%.*s", AZ_STRING_ARG(ApplicationLifecycleEventRegistrationKey),
+            AZ_STRING_ARG(eventName));
+
+        return settingsRegistry.MergeSettings(eventValue, Format::JsonMergePatch, eventRegistrationKey);
+    }
+
+    bool RegisterEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName)
+    {
+        using FixedValueString = SettingsRegistryInterface::FixedValueString;
+        using Format = AZ::SettingsRegistryInterface::Format;
+
+        if (!ValidateEvent(settingsRegistry, eventName))
+        {
+            FixedValueString eventRegistrationKey{ ApplicationLifecycleEventRegistrationKey };
+            eventRegistrationKey += '/';
+            eventRegistrationKey += eventName;
+            return settingsRegistry.MergeSettings(R"({})", Format::JsonMergePatch, eventRegistrationKey);
+        }
+
+        return true;
+    }
+
+    bool RegisterHandler(AZ::SettingsRegistryInterface& settingsRegistry, AZ::SettingsRegistryInterface::NotifyEventHandler& handler,
+        AZ::SettingsRegistryInterface::NotifyCallback callback, AZStd::string_view eventName)
+    {
+        using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
+        using Type = AZ::SettingsRegistryInterface::Type;
+        using NotifyEventHandler = AZ::SettingsRegistryInterface::NotifyEventHandler;
+
+        if (!ValidateEvent(settingsRegistry, eventName))
+        {
+            AZ_Warning("ComponentApplicationLifecycle", false, R"(Cannot register event %.*s. Name does is not a field of object "%.*s".)"
+                R"( Please make sure the entry exists in the '<engine-root>/Registry/application_lifecycle_events.setreg")"
+                " or in *.setreg within the project", AZ_STRING_ARG(eventName), AZ_STRING_ARG(ApplicationLifecycleEventRegistrationKey));
+            return false;
+        }
+        auto eventNameRegistrationKey = FixedValueString::format("%.*s/%.*s", AZ_STRING_ARG(ApplicationLifecycleEventRegistrationKey),
+            AZ_STRING_ARG(eventName));
+        auto lifecycleCallback = [callback = AZStd::move(callback), eventNameRegistrationKey](AZStd::string_view path, Type type)
+        {
+            if (path == eventNameRegistrationKey)
+            {
+                callback(path, type);
+            }
+        };
+
+        handler = NotifyEventHandler(AZStd::move(lifecycleCallback));
+        settingsRegistry.RegisterNotifier(handler);
+
+        return true;
+    }
+}
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Settings/SettingsRegistry.h>
+#include <AzCore/std/string/string_view.h>
+
+namespace AZ::ComponentApplicationLifecycle
+{
+    //! Root Key where lifecycle events should be registered under
+    inline constexpr AZStd::string_view ApplicationLifecycleEventRegistrationKey = "/O3DE/Runtime/Application/LifecycleEvents";
+
+
+    //! Validates that the event @eventName is stored in the array at ApplicationLifecycleEventRegistrationKey
+    //! @param settingsRegistry registry where @eventName will be searched
+    //! @param eventName name of key that validated that exists as an element in the ApplicationLifecycleEventRegistrationKey array
+    //! @return true if the @eventName was found in the ApplicationLifecycleEventRegistrationKey array
+    bool ValidateEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName);
+
+    //! Wrapper around setting a value underneath the ApplicationLifecycleEventRegistrationKey
+    //! It validates if the @eventName is is part of the ApplicationLifecycleEventRegistrationKey array 
+    //! It then appends the @eventName to the ApplicationLifecycleEventRegistrationKey merges the @eventValue into
+    //! the SettingsRegistry at that key
+    //! NOTE: This function should only be invoked from ComponentApplication and its derived classes
+    //! @param settingsRegistry registry where eventName should be set
+    //! @param eventName name of key underneath the ApplicationLifecycleEventRegistrationKey to signal
+    //! @param eventValue JSON Object that will be merged into the SettingsRegistry at <ApplicationLifecycleEventRootKey>/<eventName>
+    //! @return true if the eventValue was successfully merged at the <ApplicationLifecycleEventRootKey>/<eventName>
+    bool SignalEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName, AZStd::string_view eventValue);
+
+    //! Register that the event @eventName is stored in the array at ApplicationLifecycleEventRegistrationKey
+    //! @param settingsRegistry registry where @eventName will be searched
+    //! @param eventName name of key that will be stored in the ApplicationLifecycleEventRegistrationKey array
+    //! @return true if the event passed validation or the eventName was stored in the ApplicationLifecycleEventRegistrationKey array
+    bool RegisterEvent(AZ::SettingsRegistryInterface& settingsRegistry, AZStd::string_view eventName);
+
+    //! Wrapper around registering the NotifyEventHandler with the SettingsRegistry for the specified event
+    //! It validates if the @eventName is is part of the ApplicationLifecycleEventRegistrationKey array and if
+    //! so moves the @callback into @handler and then registers the handler with the SettingsRegistry NotifyEvent
+    //! @param settingsRegistry registry where handler will be registered
+    //! @param handler handler where callback will be moved into and then registered with the SettingsRegistry
+    //!        if the specified @eventName passes validation
+    //! @param callback will be moved into the handler if the specified @eventName is valid
+    //! @param eventName name of key underneath the ApplicationLifecycleEventRegistrationKey to register
+    //! @return true if the handler was registered with the SettingsRegistry NotifyEvent
+    bool RegisterHandler(AZ::SettingsRegistryInterface& settingsRegistry, AZ::SettingsRegistryInterface::NotifyEventHandler& handler,
+        AZ::SettingsRegistryInterface::NotifyCallback callback, AZStd::string_view eventName);
+}
@@ -262,6 +262,6 @@ static constexpr AZ::ThreadSafety ConsoleThreadSafety<_TYPE, std::enable_if_t<st
 //! @param _FLAGS a set of AzFramework::ConsoleFunctorFlags used to mutate behaviour
 //! @param _DESC a description of the cvar
 #define AZ_CONSOLEFREEFUNC_4(_NAME, _FUNCTION, _FLAGS, _DESC) \
-    inline AZ::ConsoleFunctor<void, false> Functor##_FUNCTION(#_FUNCTION, _DESC, _FLAGS | AZ::ConsoleFunctorFlags::DontDuplicate, AZ::TypeId::CreateNull(), &_FUNCTION)
+    inline AZ::ConsoleFunctor<void, false> Functor##_FUNCTION(_NAME, _DESC, _FLAGS | AZ::ConsoleFunctorFlags::DontDuplicate, AZ::TypeId::CreateNull(), &_FUNCTION)

 #define AZ_CONSOLEFREEFUNC(...) AZ_MACRO_SPECIALIZE(AZ_CONSOLEFREEFUNC_, AZ_VA_NUM_ARGS(__VA_ARGS__), (__VA_ARGS__))
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/DOM/DomVisitor.h>
+
+namespace AZ::DOM
+{
+    const char* VisitorError::CodeToString(VisitorErrorCode code)
+    {
+        switch (code)
+        {
+        case VisitorErrorCode::UnsupportedOperation:
+            return "operation not supported";
+        case VisitorErrorCode::InvalidData:
+            return "invalid data specified";
+        case VisitorErrorCode::InternalError:
+            return "internal error";
+        default:
+            return "unknown error";
+        }
+    }
+
+    VisitorError::VisitorError(VisitorErrorCode code)
+        : m_code(code)
+    {
+    }
+
+    VisitorError::VisitorError(VisitorErrorCode code, AZStd::string additionalInfo)
+        : m_code(code)
+        , m_additionalInfo(AZStd::move(additionalInfo))
+    {
+    }
+
+    VisitorErrorCode VisitorError::GetCode() const
+    {
+        return m_code;
+    }
+
+    const AZStd::string& VisitorError::GetAdditionalInfo() const
+    {
+        return m_additionalInfo;
+    }
+
+    AZStd::string VisitorError::FormatVisitorErrorMessage() const
+    {
+        if (m_additionalInfo.empty())
+        {
+            return AZStd::string::format("VisitorError: %s.", CodeToString(m_code));
+        }
+        return AZStd::string::format("VisitorError: %s. %s.", CodeToString(m_code), m_additionalInfo.c_str());
+    }
+
+    Visitor::Result Visitor::VisitorFailure(VisitorErrorCode code)
+    {
+        return AZ::Failure(VisitorError(code));
+    }
+
+    Visitor::Result Visitor::VisitorFailure(VisitorErrorCode code, AZStd::string additionalInfo)
+    {
+        return AZ::Failure(VisitorError(code, AZStd::move(additionalInfo)));
+    }
+
+    Visitor::Result Visitor::VisitorFailure(VisitorError error)
+    {
+        return AZ::Failure(error);
+    }
+
+    Visitor::Result Visitor::VisitorSuccess()
+    {
+        return AZ::Success();
+    }
+
+    Visitor::Result Visitor::Null()
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::Bool([[maybe_unused]] bool value)
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::Int64([[maybe_unused]] AZ::s64 value)
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::Uint64([[maybe_unused]] AZ::u64 value)
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::Double([[maybe_unused]] double value)
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::String([[maybe_unused]] AZStd::string_view value, [[maybe_unused]] Lifetime lifetime)
+    {
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::OpaqueValue([[maybe_unused]] const OpaqueType& value, [[maybe_unused]] Lifetime lifetime)
+    {
+        if (!SupportsOpaqueValues())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Opaque values are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::RawValue([[maybe_unused]] AZStd::string_view value, [[maybe_unused]] Lifetime lifetime)
+    {
+        if (!SupportsRawValues())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Raw values are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::StartObject()
+    {
+        if (!SupportsObjects())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Objects are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::EndObject([[maybe_unused]] AZ::u64 attributeCount)
+    {
+        if (!SupportsObjects())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Objects are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::Key([[maybe_unused]] AZ::Name key)
+    {
+        if (!SupportsObjects() && !SupportsNodes())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Keys are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::RawKey(AZStd::string_view key, [[maybe_unused]] Lifetime lifetime)
+    {
+        if (!SupportsRawKeys())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Raw keys are not supported by this visitor");
+        }
+        return Key(AZ::Name(key));
+    }
+
+    Visitor::Result Visitor::StartArray()
+    {
+        if (!SupportsArrays())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Arrays are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::EndArray([[maybe_unused]] AZ::u64 elementCount)
+    {
+        if (!SupportsArrays())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Arrays are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::StartNode([[maybe_unused]] AZ::Name name)
+    {
+        if (!SupportsNodes())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Nodes are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    Visitor::Result Visitor::RawStartNode(AZStd::string_view name, [[maybe_unused]] Lifetime lifetime)
+    {
+        return StartNode(AZ::Name(name));
+    }
+
+    Visitor::Result Visitor::EndNode([[maybe_unused]] AZ::u64 attributeCount, [[maybe_unused]] AZ::u64 elementCount)
+    {
+        if (!SupportsNodes())
+        {
+            return VisitorFailure(VisitorErrorCode::UnsupportedOperation, "Nodes are not supported by this visitor");
+        }
+        return VisitorSuccess();
+    }
+
+    VisitorFlags Visitor::GetVisitorFlags() const
+    {
+        // By default support raw keys (promoting them to AZ::Name) and support Array / Object / Node
+        // We leave Opaque type support and Raw Values to more specialized, implementation-specific cases
+        return VisitorFlags::SupportsRawKeys | VisitorFlags::SupportsArrays | VisitorFlags::SupportsObjects | VisitorFlags::SupportsNodes;
+    }
+
+    bool Visitor::SupportsRawValues() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsRawValues) != VisitorFlags::Null;
+    }
+
+    bool Visitor::SupportsRawKeys() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsRawKeys) != VisitorFlags::Null;
+    }
+
+    bool Visitor::SupportsObjects() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsObjects) != VisitorFlags::Null;
+    }
+
+    bool Visitor::SupportsArrays() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsArrays) != VisitorFlags::Null;
+    }
+
+    bool Visitor::SupportsNodes() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsNodes) != VisitorFlags::Null;
+    }
+
+    bool Visitor::SupportsOpaqueValues() const
+    {
+        return (GetVisitorFlags() & VisitorFlags::SupportsOpaqueValues) != VisitorFlags::Null;
+    }
+} // namespace AZ::DOM
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Name/Name.h>
+#include <AzCore/Outcome/Outcome.h>
+#include <AzCore/std/any.h>
+#include <AzCore/std/string/string.h>
+
+namespace AZ::DOM
+{
+    //
+    // Lifetime enum
+    // 
+    //! Specifies the period in which a reference value will still be alive and safe to read.
+    enum class Lifetime
+    {
+        //! Specifies that the value is safe to read and will remain so indefinitely.
+        //! This implies that the value will not be mutated for the duration of this storage.
+        Persistent,
+        //! Specifies that the value may change or be deallocated, and must be copied to be safely stored.
+        Temporary,
+    };
+
+    //
+    // VisitorErrorCode enum
+    // 
+    //! Error code specifying the reason a Visitor operation failed.
+    enum class VisitorErrorCode
+    {
+        //! Set when a Visitor doesn't have an implementation for a given attribute type.
+        //! A pure-JSON serializer might reject a Node attribute, for example, and serialization visitors
+        //! can forbid non-serializable Opaque types.
+        UnsupportedOperation,
+        //! Set when a Visitor has received malformed or invalid data.
+        //! Potential sources include mismatching Begin/End call pairs or invalid attribute or element counts
+        //! being sent to End methods.
+        InvalidData,
+        //! The Visitor failed for some other reason not caused by invalid input.
+        //! If returning a custom error with this code, it's preferrable to also provide supplemental info
+        //! in the form of an explanatory string.
+        InternalError
+    };
+
+    //
+    // VisitorError class
+    //
+    //! Details of the reason for failure within a VisitorInterface operation.
+    class VisitorError final
+    {
+    public:
+        explicit VisitorError(VisitorErrorCode code);
+        VisitorError(VisitorErrorCode code, AZStd::string additionalInfo);
+
+        //! Gets the error code associated with this error.
+        VisitorErrorCode GetCode() const;
+        //! Gets a supplemental error info string from the error.
+        //! Returns an empty string if no additional information was provided to the error.
+        const AZStd::string& GetAdditionalInfo() const;
+        //! Provides a formatted, human-readable error description that can be used for logging purposes.
+        AZStd::string FormatVisitorErrorMessage() const;
+
+        //! Helper method, translates a VisitorErrorCode to a human readable string.
+        static const char* CodeToString(VisitorErrorCode code);
+
+    private:
+        VisitorErrorCode m_code;
+        AZStd::string m_additionalInfo;
+    };
+
+    //! A type alias for opaque DOM types that aren't meant to be serializable.
+    //! /see VisitorInterface::OpaqueValue
+    using OpaqueType = AZStd::any;
+
+    //
+    // VisitorFlags enum
+    //
+    //! Flags representning capabilities of a \ref Visitor.
+    enum class VisitorFlags : AZ::u16
+    {
+        //! No flags are set. This can be used in conjunction with bitwise operators to check a flag.
+        Null = 0,
+        //! If set, this Visitor interface supports raw strings in place of specific value types.
+        //! Visitors with this flag accept RawValue calls in lieu of more specific value calls such as Int64 or String.
+        SupportsRawValues = (1 << 1),
+        //! If set, this Visitor interface supports raw strings in place of Name types for keys and Node names.
+        //! Visitors with this flag accept RawKey and RawStartNode in lieu of Key and StartNode calls.
+        SupportsRawKeys = (1 << 2),
+        //! If set, this Visitor interface supports Object types described via BeginObject and EndObject.
+        SupportsObjects = (1 << 3),
+        //! If set, this Visitor interface supports Array types described via BeginArray and EndArray.
+        SupportsArrays = (1 << 4),
+        //! If set, this Visitor interface supports Node types described BeginNode and EndNode.
+        SupportsNodes = (1 << 4),
+        //! If set, this Visitor interface supports opaque values described via OpaqueValue.
+        SupportsOpaqueValues = (1 << 5),
+    };
+
+    AZ_DEFINE_ENUM_BITWISE_OPERATORS(VisitorFlags);
+
+    //
+    // Visitor class
+    //
+    //! An interface for performing operations on elements of a generic DOM (Document Object Model).
+    //! A Document Object Model is defined here as a tree structure comprised of one of the following values:
+    //! - Primitives: plain data types, including
+    //!     - \ref Int64: 64 bit signed integer
+    //!     - \ref Uint64: 64 bit unsigned integer
+    //!     - \ref Bool: boolean value
+    //!     - \ref Double: 64 bit double precision float
+    //!     - \ref Null: sentinel "empty" type with no value representation
+    //! - \ref String: UTF8 encoded string
+    //! - \ref Object: an ordered container of key/value pairs where keys are  AZ::Names and values may be any DOM type
+    //!   (including Object)
+    //! - \ref Array: an ordered container of values, in which values are any DOM value type (including Array)
+    //! - \ref Node: a container
+    //! - \ref OpaqueValue: An arbitrary value stored in an AZStd::any. This is a non-serializable representation of an
+    //!   entry useful for in-memory options. This is intended to be used as an intermediate value over the course of DOM
+    //!   transformation and as a proxy to pass through types of which the DOM has no knowledge to other systems.
+    //!
+    //!   Opaque values are rejected by the default VisitorInterface implementation.
+    //!
+    //!   Care should be ensured that DOMs representing opaque types are only visited by consumers that understand them.
+    class Visitor
+    {
+    public:
+        virtual ~Visitor() = default;
+
+        //! The result of a Visitor operation.
+        //! A failure indicates a non-recoverable issue and signals that no further visit calls may be made in the
+        //! current state.
+        using Result = AZ::Outcome<void, VisitorError>;
+
+        //! Returns a set of flags representing the operations this Visitor supports.
+        //! The base implementation supports raw keys (\see VisitorFlags::SupportsRawKeys) and
+        //! arrays (\see VisitorFlags::SupportsArrays), objects (\see VisitorFlags::SupportsObjects), and
+        //! nodes (\see VisitorFlags::SupportsNodes).
+        //! Raw (\see VisitorFlags::SupportsRawValues) and opaque values (\see VisitorFlags::SupportsOpaqueValues)
+        //! are disallowed by default, as their handling is intended to be implementation-specific.
+        virtual VisitorFlags GetVisitorFlags() const;
+        //! /see VisitorFlags::SupportsRawValues
+        bool SupportsRawValues() const;
+        //! /see VisitorFlags::SupportsRawKeys
+        bool SupportsRawKeys() const;
+        //! /see VisitorFlags::SupportsObjects
+        bool SupportsObjects() const;
+        //! /see VisitorFlags::SupportsArrays
+        bool SupportsArrays() const;
+        //! /see VisitorFlags::SupportsNodes
+        bool SupportsNodes() const;
+        //! /see VisitorFlags::SupportsOpaqueValues
+        bool SupportsOpaqueValues() const;
+
+        //! Operates on an empty null value.
+        virtual Result Null();
+        //! Operates on a bool value.
+        virtual Result Bool(bool value);
+        //! Operates on a signed, 64 bit integer value.
+        virtual Result Int64(AZ::s64 value);
+        //! Operates on an unsigned, 64 bit integer value.
+        virtual Result Uint64(AZ::u64 value);
+        //! Operates on a double precision, 64 bit floating point value.
+        virtual Result Double(double value);
+        //! Operates on a string value. As strings are a reference type.
+        //! Storage semantics are provided to indicate where the value may be stored persistently or requires a copy.
+        virtual Result String(AZStd::string_view value, Lifetime lifetime);
+        //! Operates on an opaque value. As opaque values are a reference type, storage semantics are provided to
+        //! indicate where the value may be stored persistently or requires a copy.
+        //! The base implementation of OpaqueValue rejects the operation, as opaque values are meant for special
+        //! cases with specific implementations, not generic usage.
+        //! Storage semantics are provided to indicate where the value may be stored persistently or requires a copy.
+        virtual Result OpaqueValue(const OpaqueType& value, Lifetime lifetime);
+        //! Operates on a raw value encoded as a UTF-8 string that hasn't had its type deduced.
+        //! Visitors that support raw values (\see VisitorFlags::SupportsRawValues) may parse the raw value and
+        //! forward it to the corresponding value call or calls of their choice.
+        //! The base implementation of RawValue rejects the operation, as raw values are meant to be handled on
+        //! a per-implementation basis.
+        virtual Result RawValue(AZStd::string_view value, Lifetime lifetime);
+
+        //! Operates on an Object.
+        //! Callers may make any number of Key calls, followed by calls representing a value (including a nested
+        //! StartObject call) and then must call EndObject.
+        virtual Result StartObject();
+        //! Finishes operating on an Object.
+        //! Callers must provide the number of attributes that were provided to the object, i.e. the number of key
+        //! and value calls made within the direct context of this object (but not any nested objects / nodes).
+        virtual Result EndObject(AZ::u64 attributeCount);
+
+        //! Specifies a key for a key/value pair.
+        //! Key must be called subsequent to a call to \ref StartObject or \ref StartNode and immediately followed by
+        //! calls representing the key's associated value.
+        virtual Result Key(AZ::Name key);
+        //! Specifies a key for a key/value pair using a raw string instead of \ref AZ::Name.
+        //! \see Key
+        virtual Result RawKey(AZStd::string_view key, Lifetime lifetime);
+
+        //! Operates on an Array.
+        //! Callers may make any number of subsequent value calls to represent the elements of the array, and then must
+        //! call EndArray.
+        virtual Result StartArray();
+        //! Finishes operating on an Array.
+        //! Callers must provide the number of elements that were provided to the array, i.e. the number of value calls
+        //! made within the direct context of this array (but not any nested arrays / nodes).
+        virtual Result EndArray(AZ::u64 elementCount);
+
+        //! Operates on a Node.
+        //! Callers may make any number of Key calls followed by value calls or value calls not prefixed with a Key
+        //! call, and then must call EndNode. See \ref StartObject and \ref StartArray as Node types combine the
+        //! functionality of both structures into a named Node structure.
+        virtual Result StartNode(AZ::Name name);
+        //! Operates on a Node using a raw string instead of \ref AZ::Name.
+        //! \see StartNode
+        virtual Result RawStartNode(AZStd::string_view name, Lifetime lifetime);
+        //! Finishes operating on a Node.
+        //! Callers must provide both the number of attributes the were provided and the number of elements that were
+        //! provided to the node, attributes being values prefaced by a call to Key.
+        virtual Result EndNode(AZ::u64 attributeCount, AZ::u64 elementCount);
+
+    protected:
+        Visitor() = default;
+
+        //! Helper method, constructs a failure \ref Result with the specified code.
+        static Result VisitorFailure(VisitorErrorCode code);
+        //! Helper method, constructs a failure \ref Result with the specified code and supplemental info.
+        static Result VisitorFailure(VisitorErrorCode code, AZStd::string additionalInfo);
+        //! Helper method, constructs a failure \ref Result with the specified error.
+        static Result VisitorFailure(VisitorError error);
+        //! Helper method, constructs a success \ref Result.
+        static Result VisitorSuccess();
+    };
+} // namespace AZ::DOM
@@ -577,7 +577,9 @@ namespace AZ
                }

                azstrcat(lines[i], AZ_ARRAY_SIZE(lines[i]), "\n");
-                AZ_Printf(window, "%s", lines[i]); // feed back into the trace system so that listeners can get it.
+                // Use Output instead of AZ_Printf to be consistent with the exception output code and avoid
+                // this accidentally being suppressed as a normal message
+                Output(window, lines[i]);
            }
        }
    }
@@ -10,16 +10,13 @@
 #include <AzCore/Module/Internal/ModuleManagerSearchPathTool.h>

 #include <AzCore/Module/Module.h>
-#include <AzCore/RTTI/AttributeReader.h>
-#include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Component/Entity.h>
-#include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Component/ComponentApplication.h>
+#include <AzCore/Component/ComponentApplicationBus.h>
+#include <AzCore/Component/ComponentApplicationLifecycle.h>
 #include <AzCore/NativeUI/NativeUIRequests.h>
-#include <AzCore/Script/ScriptSystemBus.h>
-#include <AzCore/Script/ScriptContext.h>

 #include <AzCore/std/algorithm.h>
 #include <AzCore/std/smart_ptr/make_shared.h>
@@ -221,11 +218,16 @@ namespace AZ
            }
        }

+        AZStd::string componentNamesArray = R"({ "SystemComponents":[)";
+        const char* comma = "";
        // For all system components, deactivate
        for (auto componentIt = m_systemComponents.rbegin(); componentIt != m_systemComponents.rend(); ++componentIt)
        {
            ModuleEntity::DeactivateComponent(**componentIt);
+            componentNamesArray += AZStd::string::format(R"(%s"%s")", comma, (*componentIt)->RTTI_GetTypeName());
+            comma = ", ";
        }
+        componentNamesArray += R"(]})";

        // For all modules that we created an entity for, set them to "Init" (meaning not Activated)
        for (auto& moduleData : m_ownedModules)
@@ -239,6 +241,13 @@ namespace AZ

        // Since the system components have been deactivated clear out the vector.
        m_systemComponents.clear();
+
+        // Signal that the System Components have deactivated
+        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
+        {
+            AZ::ComponentApplicationLifecycle::SignalEvent(*settingsRegistry, "SystemComponentsDeactivated", componentNamesArray);
+        }
+
    }

    //=========================================================================
@@ -284,7 +293,11 @@ namespace AZ
    {
        // Split the tag list
        AZStd::vector<AZStd::string_view> tagList;
-        AZStd::tokenize<AZStd::string_view>(tags, ",", tagList);
+        auto TokenizeTags = [&tagList](AZStd::string_view token)
+        {
+            tagList.push_back(token);
+        };
+        AZ::StringFunc::TokenizeVisitor(tags, TokenizeTags, ',');

        m_systemComponentTags.resize(tagList.size());
        AZStd::transform(tagList.begin(), tagList.end(), m_systemComponentTags.begin(), [](const AZStd::string_view& tag)
@@ -737,11 +750,17 @@ namespace AZ
            }
        }

+        AZStd::string componentNamesArray = R"({ "SystemComponents":[)";
+        const char* comma = "";
        // Activate the entities in the appropriate order
        for (Component* component : componentsToActivate)
        {
            ModuleEntity::ActivateComponent(*component);
+
+            componentNamesArray += AZStd::string::format(R"(%s"%s")", comma, component->RTTI_GetTypeName());
+            comma = ", ";
        }
+        componentNamesArray += R"(]})";

        // Done activating; set state to active
        for (auto& moduleData : modulesToInit)
@@ -755,5 +774,12 @@ namespace AZ

        // Save the activated components for deactivation later
        m_systemComponents.insert(m_systemComponents.end(), componentsToActivate.begin(), componentsToActivate.end());
+
+        // Signal that the System Components are activated
+        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
+        {
+            AZ::ComponentApplicationLifecycle::SignalEvent(*settingsRegistry, "SystemComponentsActivated",
+                componentNamesArray);
+        }
    }
 } // namespace AZ
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Serialization/Json/JsonImporter.h>
+#include <AzCore/Serialization/Json/JsonUtils.h>
+#include <AzCore/Serialization/Json/JsonSerialization.h>
+
+namespace AZ
+{
+    JsonSerializationResult::ResultCode JsonImportResolver::ResolveNestedImports(rapidjson::Value& jsonDoc,
+        rapidjson::Document::AllocatorType& allocator, ImportPathStack& importPathStack,
+        JsonImportSettings& settings, const AZ::IO::FixedMaxPath& importPath, StackedString& element)
+    {
+        using namespace JsonSerializationResult;
+
+        for (auto& path : importPathStack)
+        {
+            if (importPath == path)
+            {
+                return settings.m_reporting(
+                    AZStd::string::format("'%s' was already imported in this chain. This indicates a cyclic dependency.", importPath.c_str()),
+                    ResultCode(Tasks::Import, Outcomes::Catastrophic), element);
+            }
+        }
+
+        importPathStack.push_back(importPath);
+        AZ::StackedString importElement(AZ::StackedString::Format::JsonPointer);
+        JsonImportSettings nestedImportSettings;
+        nestedImportSettings.m_importer = settings.m_importer;
+        nestedImportSettings.m_reporting = settings.m_reporting;
+        nestedImportSettings.m_resolveFlags = ImportTracking::Dependencies;
+        ResultCode result = ResolveImports(jsonDoc, allocator, importPathStack, nestedImportSettings, importElement);
+        importPathStack.pop_back();
+
+        if (result.GetOutcome() == Outcomes::Catastrophic)
+        {
+            return result;
+        }
+        
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode JsonImportResolver::ResolveImports(rapidjson::Value& jsonDoc,
+        rapidjson::Document::AllocatorType& allocator, ImportPathStack& importPathStack,
+        JsonImportSettings& settings, StackedString& element)
+    {
+        using namespace JsonSerializationResult;
+        
+        if (jsonDoc.IsObject())
+        {
+            for (auto& field : jsonDoc.GetObject())
+            {
+                if(strncmp(field.name.GetString(), JsonSerialization::ImportDirectiveIdentifier, field.name.GetStringLength()) == 0)
+                {
+                    const rapidjson::Value& importDirective = field.value;
+                    AZ::IO::FixedMaxPath importAbsPath = importPathStack.back();
+                    importAbsPath.RemoveFilename();
+                    AZStd::string importName;
+                    if (importDirective.IsObject())
+                    {
+                        auto filenameField = importDirective.FindMember("filename");
+                        if (filenameField != importDirective.MemberEnd())
+                        {
+                            importName = AZStd::string(filenameField->value.GetString(), filenameField->value.GetStringLength());
+                        }
+                    }
+                    else
+                    {
+                        importName = AZStd::string(importDirective.GetString(), importDirective.GetStringLength());
+                    }
+                    importAbsPath.Append(importName);
+
+                    rapidjson::Value patch;
+                    ResultCode resolveResult = settings.m_importer->ResolveImport(&jsonDoc, patch, importDirective, importAbsPath, allocator);
+                    if (resolveResult.GetOutcome() == Outcomes::Catastrophic)
+                    {
+                        return resolveResult;
+                    }
+
+                    if ((settings.m_resolveFlags & ImportTracking::Imports) == ImportTracking::Imports)
+                    {
+                        rapidjson::Pointer path(element.Get().data(), element.Get().size());
+                        settings.m_importer->AddImportDirective(path, importName);
+                    }
+                    if ((settings.m_resolveFlags & ImportTracking::Dependencies) == ImportTracking::Dependencies)
+                    {
+                        settings.m_importer->AddImportedFile(importAbsPath.String());
+                    }
+
+                    ResultCode result = ResolveNestedImports(jsonDoc, allocator, importPathStack, settings, importAbsPath, element);
+                    if (result.GetOutcome() == Outcomes::Catastrophic)
+                    {
+                        return result;
+                    }
+                    settings.m_importer->ApplyPatch(jsonDoc, patch, allocator);
+                }
+                else if (field.value.IsObject() || field.value.IsArray())
+                {
+                    ScopedStackedString entryName(element, AZStd::string_view(field.name.GetString(), field.name.GetStringLength()));
+                    ResultCode result = ResolveImports(field.value, allocator, importPathStack, settings, element);
+                    if (result.GetOutcome() == Outcomes::Catastrophic)
+                    {
+                        return result;
+                    }
+                }
+            }
+        }
+        else if(jsonDoc.IsArray())
+        {
+            int index = 0;
+            for (rapidjson::Value::ValueIterator elem = jsonDoc.Begin(); elem != jsonDoc.End(); ++elem, ++index)
+            {
+                if (!elem->IsObject() && !elem->IsArray())
+                {
+                    continue;
+                }
+                ScopedStackedString entryName(element, index);
+                ResultCode result = ResolveImports(*elem, allocator, importPathStack, settings, element);
+                if (result.GetOutcome() == Outcomes::Catastrophic)
+                {
+                    return result;
+                }
+            }
+        }
+
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode JsonImportResolver::RestoreImports(rapidjson::Value& jsonDoc,
+        rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings)
+    {
+        using namespace JsonSerializationResult;
+
+        if (jsonDoc.IsObject() || jsonDoc.IsArray())
+        {
+            const BaseJsonImporter::ImportDirectivesList& importDirectives = settings.m_importer->GetImportDirectives();
+            for (auto& import : importDirectives)
+            {
+                rapidjson::Pointer importPtr = import.first;
+                rapidjson::Value* currentValue = importPtr.Get(jsonDoc);
+                
+                rapidjson::Value importedValue(rapidjson::kObjectType);
+                importedValue.AddMember(rapidjson::StringRef(JsonSerialization::ImportDirectiveIdentifier), rapidjson::StringRef(import.second.c_str()), allocator);
+                ResultCode resolveResult = JsonSerialization::ResolveImports(importedValue, allocator, settings);
+                if (resolveResult.GetOutcome() == Outcomes::Catastrophic)
+                {
+                    return resolveResult;
+                }
+
+                rapidjson::Value patch;
+                settings.m_importer->CreatePatch(patch, importedValue, *currentValue, allocator);
+                settings.m_importer->RestoreImport(currentValue, patch, allocator, import.second);
+            }
+        }
+
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode BaseJsonImporter::ResolveImport(rapidjson::Value* importPtr,
+        rapidjson::Value& patch, const rapidjson::Value& importDirective,
+        const AZ::IO::FixedMaxPath& importedFilePath, rapidjson::Document::AllocatorType& allocator)
+    {
+        using namespace JsonSerializationResult;
+
+        auto importedObject = JsonSerializationUtils::ReadJsonFile(importedFilePath.Native());
+        if (importedObject.IsSuccess())
+        {
+            rapidjson::Value& importedDoc = importedObject.GetValue();
+
+            if (importDirective.IsObject())
+            {
+                auto patchField = importDirective.FindMember("patch");
+                if (patchField != importDirective.MemberEnd())
+                {
+                    patch.CopyFrom(patchField->value, allocator);
+                }
+            }
+
+            importPtr->CopyFrom(importedDoc, allocator);
+        }
+        else
+        {
+            return ResultCode(Tasks::Import, Outcomes::Catastrophic);
+        }
+
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode BaseJsonImporter::RestoreImport(rapidjson::Value* importPtr,
+        rapidjson::Value& patch, rapidjson::Document::AllocatorType& allocator, const AZStd::string& importFilename)
+    {
+        using namespace JsonSerializationResult;
+        
+        importPtr->SetObject();
+        if ((patch.IsObject() && patch.MemberCount() > 0) || (patch.IsArray() && !patch.Empty()))
+        {
+            rapidjson::Value importDirective(rapidjson::kObjectType);
+            importDirective.AddMember(rapidjson::StringRef("filename"), rapidjson::StringRef(importFilename.c_str()), allocator);
+            importDirective.AddMember(rapidjson::StringRef("patch"), patch, allocator);
+            importPtr->AddMember(rapidjson::StringRef(JsonSerialization::ImportDirectiveIdentifier), importDirective, allocator);
+        }
+        else
+        {
+            importPtr->AddMember(rapidjson::StringRef(JsonSerialization::ImportDirectiveIdentifier), rapidjson::StringRef(importFilename.c_str()), allocator);
+        }
+
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode BaseJsonImporter::ApplyPatch(rapidjson::Value& target,
+        const rapidjson::Value& patch, rapidjson::Document::AllocatorType& allocator)
+    {
+        using namespace JsonSerializationResult;
+
+        if ((patch.IsObject() && patch.MemberCount() > 0) || (patch.IsArray() && !patch.Empty()))
+        {
+            return AZ::JsonSerialization::ApplyPatch(target, allocator, patch, JsonMergeApproach::JsonMergePatch);
+        }
+
+        return ResultCode(Tasks::Import, Outcomes::Success);
+    }
+
+    JsonSerializationResult::ResultCode BaseJsonImporter::CreatePatch(rapidjson::Value& patch,
+        const rapidjson::Value& source, const rapidjson::Value& target,
+        rapidjson::Document::AllocatorType& allocator)
+    {
+        return JsonSerialization::CreatePatch(patch, allocator, source, target, JsonMergeApproach::JsonMergePatch);
+    }
+
+    void BaseJsonImporter::AddImportDirective(const rapidjson::Pointer& jsonPtr, AZStd::string importFile)
+    {
+        m_importDirectives.emplace_back(jsonPtr, AZStd::move(importFile));
+    }
+
+    void BaseJsonImporter::AddImportedFile(AZStd::string importedFile)
+    {
+        m_importedFiles.insert(AZStd::move(importedFile));
+    }
+
+    const BaseJsonImporter::ImportDirectivesList& BaseJsonImporter::GetImportDirectives()
+    {
+        return m_importDirectives;
+    }
+
+    const BaseJsonImporter::ImportedFilesList& BaseJsonImporter::GetImportedFiles()
+    {
+        return m_importedFiles;
+    }
+} // namespace AZ
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include<AzCore/IO/Path/Path.h>
+#include <AzCore/JSON/document.h>
+#include <AzCore/JSON/pointer.h>
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/std/containers/unordered_set.h>
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/Serialization/Json/JsonSerializationResult.h>
+#include <AzCore/Serialization/Json/StackedString.h>
+
+namespace AZ
+{
+    struct JsonImportSettings;
+
+    class BaseJsonImporter
+    {
+    public:
+        AZ_RTTI(BaseJsonImporter, "{7B225807-7B43-430F-8B11-C794DCF5ACA5}");
+
+        using ImportDirectivesList = AZStd::vector<AZStd::pair<rapidjson::Pointer, AZStd::string>>;
+        using ImportedFilesList = AZStd::unordered_set<AZStd::string>;
+
+        virtual JsonSerializationResult::ResultCode ResolveImport(rapidjson::Value* importPtr,
+            rapidjson::Value& patch, const rapidjson::Value& importDirective,
+            const AZ::IO::FixedMaxPath& importedFilePath, rapidjson::Document::AllocatorType& allocator);
+
+        virtual JsonSerializationResult::ResultCode RestoreImport(rapidjson::Value* importPtr,
+            rapidjson::Value& patch, rapidjson::Document::AllocatorType& allocator,
+            const AZStd::string& importFilename);
+
+        virtual JsonSerializationResult::ResultCode ApplyPatch(rapidjson::Value& target,
+            const rapidjson::Value& patch, rapidjson::Document::AllocatorType& allocator);
+
+        virtual JsonSerializationResult::ResultCode CreatePatch(rapidjson::Value& patch,
+            const rapidjson::Value& source, const rapidjson::Value& target,
+            rapidjson::Document::AllocatorType& allocator);
+
+        void AddImportDirective(const rapidjson::Pointer& jsonPtr, AZStd::string importFile);
+        const ImportDirectivesList& GetImportDirectives();
+
+        void AddImportedFile(AZStd::string importedFile);
+        const ImportedFilesList& GetImportedFiles();
+
+        virtual ~BaseJsonImporter() = default;
+
+    protected:
+
+        ImportDirectivesList m_importDirectives;
+        ImportedFilesList m_importedFiles;
+    };
+
+    enum class ImportTracking : AZ::u8
+    {
+        None = 0,
+        Dependencies = (1<<0),
+        Imports = (1<<1),
+        All = (Dependencies | Imports)
+    };
+    AZ_DEFINE_ENUM_BITWISE_OPERATORS(ImportTracking);
+
+    class JsonImportResolver final
+    {
+    public:
+
+        using ImportPathStack = AZStd::vector<AZ::IO::FixedMaxPath>;
+
+        JsonImportResolver() = delete;
+        JsonImportResolver& operator=(const JsonImportResolver& rhs) = delete;
+        JsonImportResolver& operator=(JsonImportResolver&& rhs) = delete;
+        JsonImportResolver(const JsonImportResolver& rhs) = delete;
+        JsonImportResolver(JsonImportResolver&& rhs) = delete;
+        ~JsonImportResolver() = delete;
+
+        static JsonSerializationResult::ResultCode ResolveImports(rapidjson::Value& jsonDoc,
+            rapidjson::Document::AllocatorType& allocator, ImportPathStack& importPathStack,
+            JsonImportSettings& settings, StackedString& element);
+
+        static JsonSerializationResult::ResultCode RestoreImports(rapidjson::Value& jsonDoc,
+            rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings);
+        
+    private:
+
+        static JsonSerializationResult::ResultCode ResolveNestedImports(rapidjson::Value& jsonDoc,
+            rapidjson::Document::AllocatorType& allocator, ImportPathStack& importPathStack,
+            JsonImportSettings& settings, const AZ::IO::FixedMaxPath& importPath, StackedString& element);
+    };
+
+
+    struct JsonImportSettings final
+    {
+        JsonSerializationResult::JsonIssueCallback m_reporting;
+        
+        BaseJsonImporter* m_importer = nullptr;
+
+        ImportTracking m_resolveFlags = ImportTracking::All;
+
+        AZ::IO::FixedMaxPath m_loadedJsonPath;
+    };
+} // namespace AZ
@@ -706,7 +706,7 @@ namespace AZ
                            rapidjson::Value(rapidjson::kNullType), field.value, element, settings);
                    }

-                    if (result.GetOutcome() == Outcomes::Success)
+                    if (result.GetOutcome() == Outcomes::Success || result.GetOutcome() == Outcomes::PartialDefaults)
                    {
                        rapidjson::Value name;
                        name.CopyFrom(field.name, allocator, true);
@@ -717,6 +717,10 @@ namespace AZ
                    {
                        return result;
                    }
+                    else
+                    {
+                        resultCode.Combine(result);
+                    }
                }

                // Do an extra pass to find all the fields that are removed.
@@ -751,7 +755,7 @@ namespace AZ
                    rapidjson::Value value;
                    ResultCode result = CreateMergePatchInternal(value, allocator,
                        rapidjson::Value(rapidjson::kNullType), field.value, element, settings);
-                    if (result.GetOutcome() == Outcomes::Success)
+                    if (result.GetOutcome() == Outcomes::Success || result.GetOutcome() == Outcomes::PartialDefaults)
                    {
                        rapidjson::Value name;
                        name.CopyFrom(field.name, allocator, true);
@@ -762,11 +766,20 @@ namespace AZ
                    {
                        return result;
                    }
+                    else
+                    {
+                        resultCode.Combine(result);
+                    }
+                }
+                
+                if (target.MemberCount() == 0)
+                {
+                    resultCode.Combine(settings.m_reporting("Added empty object to JSON Merge Patch.",
+                        ResultCode(Tasks::CreatePatch, Outcomes::Success), element));
                }
            }

            patch = AZStd::move(resultValue);
-            resultCode.Combine(ResultCode(Tasks::CreatePatch, Outcomes::Success));
            return resultCode;
        }
        else
@@ -10,6 +10,7 @@
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Serialization/Json/BaseJsonSerializer.h>
 #include <AzCore/Serialization/Json/JsonDeserializer.h>
+#include <AzCore/Serialization/Json/JsonImporter.h>
 #include <AzCore/Serialization/Json/JsonMerger.h>
 #include <AzCore/Serialization/Json/JsonSerialization.h>
 #include <AzCore/Serialization/Json/JsonSerializer.h>
@@ -19,11 +20,6 @@

 namespace AZ
 {
-    const char* JsonSerialization::TypeIdFieldIdentifier = "$type";
-    const char* JsonSerialization::DefaultStringIdentifier = "{}";
-    const char* JsonSerialization::KeyFieldIdentifier = "Key";
-    const char* JsonSerialization::ValueFieldIdentifier = "Value";
-
    namespace JsonSerializationInternal
    {
        template<typename T>
@@ -394,6 +390,60 @@ namespace AZ
        }
    }

+    JsonSerializationResult::ResultCode JsonSerialization::ResolveImports(
+        rapidjson::Value& jsonDoc, rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings)
+    {
+        using namespace JsonSerializationResult;
+
+        if (settings.m_importer == nullptr)
+        {
+            AZ_Assert(false, "Importer object needs to be provided");
+            return ResultCode(Tasks::Import, Outcomes::Catastrophic);
+        }
+
+        AZStd::string scratchBuffer;
+        auto issueReportingCallback = [&scratchBuffer](AZStd::string_view message, ResultCode result, AZStd::string_view target) -> ResultCode
+        {
+            return JsonSerialization::DefaultIssueReporter(scratchBuffer, message, result, target);
+        };
+        if (!settings.m_reporting)
+        {
+            settings.m_reporting = issueReportingCallback;
+        }
+
+        JsonImportResolver::ImportPathStack importPathStack;
+        importPathStack.push_back(settings.m_loadedJsonPath);
+        StackedString element(StackedString::Format::JsonPointer);
+
+        return JsonImportResolver::ResolveImports(jsonDoc, allocator, importPathStack, settings, element);
+    }
+
+    JsonSerializationResult::ResultCode JsonSerialization::RestoreImports(
+        rapidjson::Value& jsonDoc, rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings)
+    {
+        using namespace JsonSerializationResult;
+
+        if (settings.m_importer == nullptr)
+        {
+            AZ_Assert(false, "Importer object needs to be provided");
+            return ResultCode(Tasks::Import, Outcomes::Catastrophic);
+        }
+
+        AZStd::string scratchBuffer;
+        auto issueReportingCallback = [&scratchBuffer](AZStd::string_view message, ResultCode result, AZStd::string_view target) -> ResultCode
+        {
+            return JsonSerialization::DefaultIssueReporter(scratchBuffer, message, result, target);
+        };
+        if (!settings.m_reporting)
+        {
+            settings.m_reporting = issueReportingCallback;
+        }
+
+        settings.m_resolveFlags = ImportTracking::None;
+
+        return JsonImportResolver::RestoreImports(jsonDoc, allocator, settings);
+    }
+
    JsonSerializationResult::ResultCode JsonSerialization::DefaultIssueReporter(AZStd::string& scratchBuffer,
        AZStd::string_view message, JsonSerializationResult::ResultCode result, AZStd::string_view path)
    {
@@ -18,6 +18,8 @@
 namespace AZ
 {
    class BaseJsonSerializer;
+
+    struct JsonImportSettings;
    
    enum class JsonMergeApproach
    {
@@ -51,10 +53,11 @@ namespace AZ
    class JsonSerialization final
    {
    public:
-        static const char* TypeIdFieldIdentifier;
-        static const char* DefaultStringIdentifier;
-        static const char* KeyFieldIdentifier;
-        static const char* ValueFieldIdentifier;
+        static constexpr const char* TypeIdFieldIdentifier = "$type";
+        static constexpr const char* DefaultStringIdentifier = "{}";
+        static constexpr const char* KeyFieldIdentifier = "Key";
+        static constexpr const char* ValueFieldIdentifier = "Value";
+        static constexpr const char* ImportDirectiveIdentifier = "$import";

        //! Merges two json values together by applying "patch" to "target" using the selected merge algorithm.
        //! This version of ApplyPatch is destructive to "target". If the patch can't be correctly applied it will
@@ -284,6 +287,22 @@ namespace AZ
        //! @return An enum containing less, equal or greater. In case of an error, the value for the enum will "error".
        static JsonSerializerCompareResult Compare(const rapidjson::Value& lhs, const rapidjson::Value& rhs);

+        //! Resolves all import directives, including nested imports, in the given document. An importer object needs to be passed
+        //! in through the settings.
+        //! @param jsonDoc The json document in which to resolve imports.
+        //! @param allocator The allocator associated with the json document.
+        //! @param settings Additional settings that control the way the imports are resolved.
+        static JsonSerializationResult::ResultCode ResolveImports(
+            rapidjson::Value& jsonDoc, rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings);
+        
+        //! Restores all import directives that were present in the json document. The same importer object that was
+        //! passed into ResolveImports through the settings needs to be passed here through settings as well.
+        //! @param jsonDoc The json document in which to restore imports.
+        //! @param allocator The allocator associated with the json document.
+        //! @param settings Additional settings that control the way the imports are restored.
+        static JsonSerializationResult::ResultCode RestoreImports(
+            rapidjson::Value& jsonDoc, rapidjson::Document::AllocatorType& allocator, JsonImportSettings& settings);
+
    private:
        JsonSerialization() = delete;
        ~JsonSerialization() = delete;
@@ -69,6 +69,9 @@ namespace AZ
                case Tasks::CreatePatch:
                    target.append("a create patch operation ");
                    break;
+                case Tasks::Import:
+                    target.append("an import operation");
+                    break;
                default:
                    target.append("an unknown operation ");
                    break;
@@ -32,7 +32,8 @@ namespace AZ
            ReadField,          //!< Task to read a field from JSON to a value.
            WriteValue,         //!< Task to write a value to a JSON field.
            Merge,              //!< Task to merge two JSON values/documents together.
-            CreatePatch         //!< Task to create a patch to transform one value/document to another.
+            CreatePatch,        //!< Task to create a patch to transform one value/document to another.
+            Import              //!< Task to import a JSON document.
        };

        //! Describes how the task was processed.
@@ -15,20 +15,20 @@

 namespace AZ::SettingsRegistryScriptUtils::Internal
 {
-    static void RegisterScriptProxyForNotify(SettingsRegistryScriptProxy& settingsRegistryProxy)
+    static void RegisterScriptProxyForNotify(SettingsRegistryInterface* settingsRegistry,
+        SettingsRegistryScriptProxy::NotifyEventProxy* notifyEventProxy)
    {
-        if (settingsRegistryProxy.IsValid())
+        if (settingsRegistry != nullptr)
        {
-            auto ForwardSettingsUpdateToProxyEvent = [&settingsRegistryProxy](AZStd::string_view path, AZ::SettingsRegistryInterface::Type)
+            auto ForwardSettingsUpdateToProxyEvent = [notifyEventProxy](AZStd::string_view path, AZ::SettingsRegistryInterface::Type)
            {
-                if (settingsRegistryProxy.m_notifyEventProxy)
+                if (notifyEventProxy)
                {
-                    settingsRegistryProxy.m_notifyEventProxy->m_scriptNotifyEvent.Signal(path);
+                    notifyEventProxy->m_scriptNotifyEvent.Signal(path);
                }
            };
            // Register the forwarding function with the BehaviorContext
-            settingsRegistryProxy.m_notifyEventProxy->m_settingsUpdatedHandler =
-                settingsRegistryProxy.m_settingsRegistry->RegisterNotifier(ForwardSettingsUpdateToProxyEvent);
+            notifyEventProxy->m_settingsUpdatedHandler = settingsRegistry->RegisterNotifier(ForwardSettingsUpdateToProxyEvent);
        }
    }

@@ -37,7 +37,7 @@ namespace AZ::SettingsRegistryScriptUtils::Internal
        : m_settingsRegistry(AZStd::move(settingsRegistry))
        , m_notifyEventProxy(AZStd::make_shared<NotifyEventProxy>())
    {
-        RegisterScriptProxyForNotify(*this);
+        RegisterScriptProxyForNotify(m_settingsRegistry.get(), m_notifyEventProxy.get());
    }

    // Raw AZ::SettingsRegistryInterface pointer is not owned by the proxy, so it's deleter is a no-op
@@ -45,7 +45,7 @@ namespace AZ::SettingsRegistryScriptUtils::Internal
        : m_settingsRegistry(settingsRegistry, [](AZ::SettingsRegistryInterface*) {})
        , m_notifyEventProxy(AZStd::make_shared<NotifyEventProxy>())
    {
-        RegisterScriptProxyForNotify(*this);
+        RegisterScriptProxyForNotify(m_settingsRegistry.get(), m_notifyEventProxy.get());
    }

    // SettingsRegistryScriptProxy function that determines if the SettingsRegistry object is valid
@@ -120,7 +120,7 @@ namespace AZ::Utils
    AZ::Outcome<void, AZStd::string> WriteFile(AZStd::string_view content, AZStd::string_view filePath)
    {
        AZ::IO::FixedMaxPath filePathFixed = filePath; // Because FileIOStream requires a null-terminated string
-        AZ::IO::FileIOStream stream(filePathFixed.c_str(), AZ::IO::OpenMode::ModeWrite);
+        AZ::IO::FileIOStream stream(filePathFixed.c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeCreatePath);

        bool success = false;

@@ -41,6 +41,8 @@ set(FILES
    Component/ComponentApplication.cpp
    Component/ComponentApplication.h
    Component/ComponentApplicationBus.h
+    Component/ComponentApplicationLifecycle.cpp
+    Component/ComponentApplicationLifecycle.h
    Component/ComponentBus.cpp
    Component/ComponentBus.h
    Component/ComponentExport.h
@@ -121,6 +123,8 @@ set(FILES
    Debug/TraceMessagesDrillerBus.h
    Debug/TraceReflection.cpp
    Debug/TraceReflection.h
+    DOM/DomVisitor.cpp
+    DOM/DomVisitor.h
    Driller/DefaultStringPool.h
    Driller/Driller.cpp
    Driller/Driller.h
@@ -522,6 +526,8 @@ set(FILES
    Serialization/Json/IntSerializer.cpp
    Serialization/Json/JsonDeserializer.h
    Serialization/Json/JsonDeserializer.cpp
+    Serialization/Json/JsonImporter.cpp
+    Serialization/Json/JsonImporter.h
    Serialization/Json/JsonMerger.h
    Serialization/Json/JsonMerger.cpp
    Serialization/Json/JsonSerialization.h
@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Serialization/Json/JsonImporter.h>
+#include <AzCore/Serialization/Json/JsonUtils.h>
+#include <Tests/Serialization/Json/JsonSerializationTests.h>
+
+namespace JsonSerializationTests
+{
+    class JsonImportingTests;
+
+    class JsonImporterCustom
+        : public AZ::BaseJsonImporter
+    {
+    public:
+        AZ_RTTI(JsonImporterCustom, "{003F5896-71E0-4A50-A14F-08C319B06AD0}");
+
+
+        AZ::JsonSerializationResult::ResultCode ResolveImport(rapidjson::Value* importPtr,
+            rapidjson::Value& patch, const rapidjson::Value& importDirective,
+            const AZ::IO::FixedMaxPath& importedFilePath, rapidjson::Document::AllocatorType& allocator) override;
+        
+        JsonImporterCustom(JsonImportingTests* tests)
+        {
+            testClass = tests;
+        }
+
+    private:
+        JsonImportingTests* testClass;
+    };
+
+    class JsonImportingTests
+        : public BaseJsonSerializerFixture
+    {
+    public:
+        void SetUp() override
+        {
+            BaseJsonSerializerFixture::SetUp();
+        }
+
+        void TearDown() override
+        {
+            BaseJsonSerializerFixture::TearDown();
+        }
+
+        void GetTestDocument(const AZStd::string& docName, rapidjson::Document& out)
+        {
+            const char *objectJson = R"({
+                "field_1" : "value_1",
+                "field_2" : "value_2",
+                "field_3" : "value_3"
+            })";
+
+            const char *arrayJson = R"([
+                { "element_1" : "value_1" },
+                { "element_2" : "value_2" },
+                { "element_3" : "value_3" }
+            ])";
+
+            const char *nestedImportJson = R"({
+                "desc" : "Nested Import",
+                "obj" : {"$import" : "object.json"}
+            })";
+            
+            const char *nestedImportCycle1Json = R"({
+                "desc" : "Nested Import Cycle 1",
+                "obj" : {"$import" : "nested_import_c2.json"}
+            })";
+
+            const char *nestedImportCycle2Json = R"({
+                "desc" : "Nested Import Cycle 2",
+                "obj" : {"$import" : "nested_import_c1.json"}
+            })";
+
+            if (docName.compare("object.json") == 0)
+            {
+                out.Parse(objectJson);
+                ASSERT_FALSE(out.HasParseError());
+            }
+            else if (docName.compare("array.json") == 0)
+            {
+                out.Parse(arrayJson);
+                ASSERT_FALSE(out.HasParseError());
+            }
+            else if (docName.compare("nested_import.json") == 0)
+            {
+                out.Parse(nestedImportJson);
+                ASSERT_FALSE(out.HasParseError());
+            }
+            else if (docName.compare("nested_import_c1.json") == 0)
+            {
+                out.Parse(nestedImportCycle1Json);
+                ASSERT_FALSE(out.HasParseError());
+            }
+            else if (docName.compare("nested_import_c2.json") == 0)
+            {
+                out.Parse(nestedImportCycle2Json);
+                ASSERT_FALSE(out.HasParseError());
+            }
+        }
+
+    protected:
+        void TestImportLoadStore(const char* input, const char* expectedImportedValue)
+        {
+            m_jsonDocument->Parse(input);
+            ASSERT_FALSE(m_jsonDocument->HasParseError());
+
+            JsonImporterCustom* importerObj = new JsonImporterCustom(this);
+
+            rapidjson::Document expectedOutcome;
+            expectedOutcome.Parse(expectedImportedValue);
+            ASSERT_FALSE(expectedOutcome.HasParseError());
+
+            TestResolveImports(importerObj);
+
+            Expect_DocStrEq(m_jsonDocument->GetObject(), expectedOutcome.GetObject());
+
+            rapidjson::Document originalInput;
+            originalInput.Parse(input);
+            ASSERT_FALSE(originalInput.HasParseError());
+
+            TestRestoreImports(importerObj);
+
+            Expect_DocStrEq(m_jsonDocument->GetObject(), originalInput.GetObject());
+            
+            m_jsonDocument->SetObject();
+            delete importerObj;
+        }
+
+        void TestImportCycle(const char* input)
+        {
+            m_jsonDocument->Parse(input);
+            ASSERT_FALSE(m_jsonDocument->HasParseError());
+
+            JsonImporterCustom* importerObj = new JsonImporterCustom(this);
+
+            AZ::JsonSerializationResult::ResultCode result = TestResolveImports(importerObj);
+
+            EXPECT_EQ(result.GetOutcome(), AZ::JsonSerializationResult::Outcomes::Catastrophic);
+
+            m_jsonDocument->SetObject();
+            delete importerObj;
+        }
+
+        void TestInsertNewImport(const char* input, const char* expectedRestoredValue)
+        {
+            m_jsonDocument->Parse(input);
+            ASSERT_FALSE(m_jsonDocument->HasParseError());
+
+            JsonImporterCustom* importerObj = new JsonImporterCustom(this);
+
+            TestResolveImports(importerObj);
+
+            importerObj->AddImportDirective(rapidjson::Pointer("/object_2"), "object.json");
+
+            rapidjson::Document expectedOutput;
+            expectedOutput.Parse(expectedRestoredValue);
+            ASSERT_FALSE(expectedOutput.HasParseError());
+
+            TestRestoreImports(importerObj);
+
+            Expect_DocStrEq(m_jsonDocument->GetObject(), expectedOutput.GetObject());
+            
+            m_jsonDocument->SetObject();
+            delete importerObj;
+        }
+
+        AZ::JsonSerializationResult::ResultCode TestResolveImports(JsonImporterCustom* importerObj)
+        {
+            AZ::JsonImportSettings settings;
+            settings.m_importer = importerObj;
+
+            return AZ::JsonSerialization::ResolveImports(m_jsonDocument->GetObject(), m_jsonDocument->GetAllocator(), settings);
+        }
+
+        AZ::JsonSerializationResult::ResultCode TestRestoreImports(JsonImporterCustom* importerObj)
+        {
+            AZ::JsonImportSettings settings;
+            settings.m_importer = importerObj;
+
+            return AZ::JsonSerialization::RestoreImports(m_jsonDocument->GetObject(), m_jsonDocument->GetAllocator(), settings);
+        }
+    };
+
+    AZ::JsonSerializationResult::ResultCode JsonImporterCustom::ResolveImport(rapidjson::Value* importPtr,
+        rapidjson::Value& patch, const rapidjson::Value& importDirective, const AZ::IO::FixedMaxPath& importedFilePath,
+        rapidjson::Document::AllocatorType& allocator)
+    {
+        AZ::JsonSerializationResult::ResultCode resultCode(AZ::JsonSerializationResult::Tasks::Import);
+        
+        rapidjson::Document importedDoc;
+        testClass->GetTestDocument(importedFilePath.String(), importedDoc);
+
+        if (importDirective.IsObject())
+        {
+            auto patchField = importDirective.FindMember("patch");
+            if (patchField != importDirective.MemberEnd())
+            {
+                patch.CopyFrom(patchField->value, allocator);
+            }
+        }
+
+        importPtr->CopyFrom(importedDoc, allocator);
+
+        return resultCode;
+    }
+
+    // Test Cases
+
+    TEST_F(JsonImportingTests, ImportSimpleObjectTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "simple_object_import",
+                "object": {"$import" : "object.json"}
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "simple_object_import",
+                "object": {
+                    "field_1" : "value_1",
+                    "field_2" : "value_2",
+                    "field_3" : "value_3"
+                }
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, ImportSimpleObjectPatchTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "simple_object_import",
+                "object": {
+                    "$import" : { 
+                        "filename" : "object.json",
+                        "patch" : { "field_2" : "patched_value" }
+                    }
+                }
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "simple_object_import",
+                "object": {
+                    "field_1" : "value_1",
+                    "field_2" : "patched_value",
+                    "field_3" : "value_3"
+                }
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, ImportSimpleArrayTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "simple_array_import",
+                "object": {"$import" : "array.json"}
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "simple_array_import",
+                "object": [
+                    { "element_1" : "value_1" },
+                    { "element_2" : "value_2" },
+                    { "element_3" : "value_3" }
+                ]
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, ImportSimpleArrayPatchTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "simple_array_import",
+                "object": {
+                    "$import" : {
+                        "filename" : "array.json",
+                        "patch" : [ { "element_1" : "patched_value" } ]
+                    }
+                }
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "simple_array_import",
+                "object": [
+                    { "element_1" : "patched_value" }
+                ]
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, NestedImportTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "nested_import",
+                "object": {"$import" : "nested_import.json"}
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "nested_import",
+                "object": {
+                    "desc" : "Nested Import",
+                    "obj" : {
+                        "field_1" : "value_1",
+                        "field_2" : "value_2",
+                        "field_3" : "value_3"
+                    }
+                }
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, NestedImportPatchTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "nested_import",
+                "object": {
+                    "$import" : { 
+                        "filename" : "nested_import.json",
+                        "patch" : { "obj" : { "field_3" : "patched_value" } }
+                    }
+                }
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "nested_import",
+                "object": {
+                    "desc" : "Nested Import",
+                    "obj" : {
+                        "field_1" : "value_1",
+                        "field_2" : "value_2",
+                        "field_3" : "patched_value"
+                    }
+                }
+            }
+        )";
+
+        TestImportLoadStore(inputFile, expectedOutput);
+    }
+
+    TEST_F(JsonImportingTests, NestedImportCycleTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "nested_import_cycle",
+                "object": {"$import" : "nested_import_c1.json"}
+            }
+        )";
+
+        TestImportCycle(inputFile);
+    }
+
+    TEST_F(JsonImportingTests, InsertNewImportTest)
+    {
+        const char* inputFile = R"(
+            {
+                "name" : "simple_object_import",
+                "object_1": {"$import" : "object.json"},
+                "object_2": {
+                    "field_1" : "other_value",
+                    "field_2" : "value_2",
+                    "field_3" : "value_3"
+                }
+            }
+        )";
+
+        const char* expectedOutput = R"(
+            {
+                "name" : "simple_object_import",
+                "object_1": {"$import" : "object.json"},
+                "object_2": {
+                    "$import" : { 
+                        "filename" : "object.json",
+                        "patch" : { "field_1" : "other_value" }
+                    }
+                }
+            }
+        )";
+
+        TestInsertNewImport(inputFile, expectedOutput);
+    }
+}
@@ -121,6 +121,7 @@ set(FILES
    Serialization/Json/TestCases_Classes.cpp
    Serialization/Json/TestCases_Compare.cpp
    Serialization/Json/TestCases_Enum.cpp
+    Serialization/Json/TestCases_Importing.cpp
    Serialization/Json/TestCases_Patching.cpp
    Serialization/Json/TestCases_Pointers.h
    Serialization/Json/TestCases_Pointers.cpp