initial scriptcanvas source handle

Signed-off-by: chcurran <82187351+carlitosan@users.noreply.github.com>
2021-10-14 09:06:54 -07:00
parent 6613030fe6
commit 31c627defc
21 changed files with 579 additions and 283 deletions
@@ -165,13 +165,12 @@ namespace AZ::Utils
        }

        Container fileContent;
-        fileContent.resize(length);
+        fileContent.resize_no_construct(length);
        AZ::IO::SizeType bytesRead = file.Read(length, fileContent.data());
        file.Close();

        // Resize again just in case bytesRead is less than length for some reason
-        fileContent.resize(bytesRead);
-
+        fileContent.resize_no_construct(bytesRead);
        return AZ::Success(AZStd::move(fileContent));
    }

@@ -16,9 +16,11 @@
 #include <AzFramework/Script/ScriptComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 #include <Builder/ScriptCanvasBuilderWorker.h>
+#include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.h>
 #include <ScriptCanvas/Asset/RuntimeAssetHandler.h>
 #include <ScriptCanvas/Asset/SubgraphInterfaceAssetHandler.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
+#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>
 #include <ScriptCanvas/Components/EditorGraph.h>
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
 #include <ScriptCanvas/Core/Connection.h>
@@ -44,54 +46,73 @@ namespace ScriptCanvasBuilder
        AzFramework::StringFunc::Path::ConstructFull(request.m_watchFolder.data(), request.m_sourceFile.data(), fullPath, false);
        AzFramework::StringFunc::Path::Normalize(fullPath);

-        if (!m_editorAssetHandler)
+        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset> asset;
+        const ScriptCanvasEditor::Graph* sourceGraph = nullptr;
+        const ScriptCanvas::GraphData* graphData = nullptr;
+
+        ScriptCanvasEditor::SourceHandle sourceHandle;
+
+        auto sourceOutcome = ScriptCanvasEditor::LoadFromFile(fullPath);
+        if (sourceOutcome.IsSuccess())
        {
-            AZ_Error(s_scriptCanvasBuilder, false, R"(CreateJobs for %s failed because the ScriptCanvas Editor Asset handler is missing.)", fullPath.data());
+            sourceHandle = sourceOutcome.TakeValue();
+            sourceGraph = sourceHandle.Get();
+            graphData = sourceGraph->GetGraphDataConst();
        }
-
-        AZStd::shared_ptr<AZ::Data::AssetDataStream> assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
-
-        AZ::IO::FileIOStream stream(fullPath.c_str(), AZ::IO::OpenMode::ModeRead);
-        if (!AZ::IO::RetryOpenStream(stream))
+        
+#if defined(EDITOR_ASSET_SUPPORT_ENABLED) 
+        if (graphData == nullptr)
        {
-            AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the source file could not be opened.", fullPath.data());
-            return;
-        }
+            if (!m_editorAssetHandler)
+            {
+                AZ_Error(s_scriptCanvasBuilder, false, R"(CreateJobs for %s failed because the ScriptCanvas Editor Asset handler is missing.)", fullPath.data());
+            }

-        // Read the asset into a memory buffer, then hand ownership of the buffer to assetDataStream
-        {
-            AZ::IO::FileIOStream ioStream;
-            if (!ioStream.Open(fullPath.data(), AZ::IO::OpenMode::ModeRead))
+            AZStd::shared_ptr<AZ::Data::AssetDataStream> assetDataStream = AZStd::make_shared<AZ::Data::AssetDataStream>();
+
+            AZ::IO::FileIOStream stream(fullPath.c_str(), AZ::IO::OpenMode::ModeRead);
+            if (!AZ::IO::RetryOpenStream(stream))
            {
                AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the source file could not be opened.", fullPath.data());
                return;
            }

-            AZStd::vector<AZ::u8> fileBuffer(ioStream.GetLength());
-            size_t bytesRead = ioStream.Read(fileBuffer.size(), fileBuffer.data());
-            if (bytesRead != ioStream.GetLength())
+            // Read the asset into a memory buffer, then hand ownership of the buffer to assetDataStream
            {
-                AZ_Warning(s_scriptCanvasBuilder, false, AZStd::string::format("File failed to read completely: %s", fullPath.data()).c_str());
+                AZ::IO::FileIOStream ioStream;
+                if (!ioStream.Open(fullPath.data(), AZ::IO::OpenMode::ModeRead))
+                {
+                    AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the source file could not be opened.", fullPath.data());
+                    return;
+                }
+
+                AZStd::vector<AZ::u8> fileBuffer(ioStream.GetLength());
+                size_t bytesRead = ioStream.Read(fileBuffer.size(), fileBuffer.data());
+                if (bytesRead != ioStream.GetLength())
+                {
+                    AZ_Warning(s_scriptCanvasBuilder, false, AZStd::string::format("File failed to read completely: %s", fullPath.data()).c_str());
+                    return;
+                }
+
+                assetDataStream->Open(AZStd::move(fileBuffer));
+            }
+
+            m_processEditorAssetDependencies.clear();
+
+            asset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
+            if (m_editorAssetHandler->LoadAssetDataFromStream(asset, assetDataStream, {}) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
+            {
+                AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the asset data could not be loaded from the file", fullPath.data());
                return;
            }

-            assetDataStream->Open(AZStd::move(fileBuffer));
+            sourceGraph = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(asset.Get()->GetScriptCanvasEntity());
+            graphData = sourceGraph->GetGraphDataConst();
        }
+#endif

-        m_processEditorAssetDependencies.clear();
-
-        AZ::Data::Asset<ScriptCanvasEditor::ScriptCanvasAsset> asset;
-        asset.Create(AZ::Data::AssetId(AZ::Uuid::CreateRandom()));
-        if (m_editorAssetHandler->LoadAssetDataFromStream(asset, assetDataStream, {}) != AZ::Data::AssetHandler::LoadResult::LoadComplete)
-        {
-            AZ_Warning(s_scriptCanvasBuilder, false, "CreateJobs for \"%s\" failed because the asset data could not be loaded from the file", fullPath.data());
-            return;
-        }
-
-        auto* scriptCanvasEntity = asset.Get()->GetScriptCanvasEntity();
-        auto* sourceGraph = AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(scriptCanvasEntity);
        AZ_Assert(sourceGraph, "Graph component is missing from entity.");
-        AZ_Assert(sourceGraph->GetGraphData(), "GraphData is missing from entity");
+        AZ_Assert(graphData, "GraphData is missing from entity");

        struct EntityIdComparer
        {
@@ -102,7 +123,7 @@ namespace ScriptCanvasBuilder
                return lhsEntityId < rhsEntityId;
            }
        };
-        const AZStd::set<AZ::Entity*, EntityIdComparer> sortedEntities(sourceGraph->GetGraphData()->m_nodes.begin(), sourceGraph->GetGraphData()->m_nodes.end());
+        const AZStd::set<AZ::Entity*, EntityIdComparer> sortedEntities(graphData->m_nodes.begin(), graphData->m_nodes.end());

        size_t fingerprint = 0;
        for (const auto& nodeEntity : sortedEntities)
@@ -155,7 +176,7 @@ namespace ScriptCanvasBuilder
        };

        AZ_Verify(serializeContext->EnumerateInstanceConst
-            ( sourceGraph->GetGraphData()
+            ( graphData
            , azrtti_typeid<ScriptCanvas::GraphData>()
            , assetFilter
            , {}
@@ -168,17 +189,6 @@ namespace ScriptCanvasBuilder

        for (const AssetBuilderSDK::PlatformInfo& info : request.m_enabledPlatforms)
        {
-            if (info.HasTag("tools"))
-            {
-                AssetBuilderSDK::JobDescriptor copyDescriptor;
-                copyDescriptor.m_priority = 2;
-                copyDescriptor.m_critical = true;
-                copyDescriptor.m_jobKey = s_scriptCanvasCopyJobKey;
-                copyDescriptor.SetPlatformIdentifier(info.m_identifier.c_str());
-                copyDescriptor.m_additionalFingerprintInfo = AZStd::string(GetFingerprintString()).append("|").append(AZStd::to_string(static_cast<AZ::u64>(fingerprint)));
-                response.m_createJobOutputs.push_back(copyDescriptor);
-            }
-
            AssetBuilderSDK::JobDescriptor jobDescriptor;
            jobDescriptor.m_priority = 2;
            jobDescriptor.m_critical = true;
@@ -299,23 +309,9 @@ namespace ScriptCanvasBuilder
        AzFramework::StringFunc::Path::Join(request.m_tempDirPath.c_str(), fileNameOnly.c_str(), runtimeScriptCanvasOutputPath, true, true);
        AzFramework::StringFunc::Path::ReplaceExtension(runtimeScriptCanvasOutputPath, ScriptCanvas::RuntimeAsset::GetFileExtension());

-        if (request.m_jobDescription.m_jobKey == s_scriptCanvasCopyJobKey)
-        {
-            // ScriptCanvas Editor Asset Copy job
-            // The SubID is zero as this represents the main asset
-            AssetBuilderSDK::JobProduct jobProduct;
-            jobProduct.m_productFileName = fullPath;
-            jobProduct.m_productAssetType = azrtti_typeid<ScriptCanvasEditor::ScriptCanvasAsset>();
-            jobProduct.m_productSubID = 0;
-            jobProduct.m_dependenciesHandled = true;
-            jobProduct.m_dependencies.clear();
-            response.m_outputProducts.push_back(AZStd::move(jobProduct));
-            response.m_resultCode = AssetBuilderSDK::ProcessJobResult_Success;
-        }
-        else
+        if (request.m_jobDescription.m_jobKey == s_scriptCanvasProcessJobKey)
        {
            AZ::Entity* buildEntity = asset.Get()->GetScriptCanvasEntity();
-
            ProcessTranslationJobInput input;
            input.assetID = AZ::Data::AssetId(request.m_sourceFileUUID, AZ_CRC("RuntimeData", 0x163310ae));
            input.request = &request;
@@ -42,7 +42,6 @@ namespace ScriptCanvasEditor
 namespace ScriptCanvasBuilder
 {
    constexpr const char* s_scriptCanvasBuilder = "ScriptCanvasBuilder";
-    constexpr const char* s_scriptCanvasCopyJobKey = "Script Canvas Copy Job";
    constexpr const char* s_scriptCanvasProcessJobKey = "Script Canvas Process Job";
    constexpr const char* s_unitTestParseErrorPrefix = "LY_SC_UnitTest";

@@ -59,6 +58,10 @@ namespace ScriptCanvasBuilder
        PrefabIntegration,
        CorrectGraphVariableVersion,
        ReflectEntityIdNodes,
+
+        ForceBuildForDevTest0,
+        ForceBuildForDevTest1,
+
        // add new entries above
        Current,
    };
@@ -23,6 +23,7 @@
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
 #include <ScriptCanvas/Assets/ScriptCanvasAssetHandler.h>
+#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>
 #include <ScriptCanvas/Bus/ScriptCanvasBus.h>
 #include <ScriptCanvas/Components/EditorGraph.h>
 #include <ScriptCanvas/Components/EditorGraphVariableManagerComponent.h>
@@ -93,49 +94,6 @@ namespace ScriptCanvasEditor
        }
    }

-    AZ::Outcome<void, AZStd::string> LoadScriptCanvasDataFromJson
-        ( ScriptCanvas::ScriptCanvasData& dataTarget
-        , AZStd::string_view source
-        , AZ::SerializeContext& serializeContext)
-    {
-        namespace JSRU = AZ::JsonSerializationUtils;
-        using namespace ScriptCanvas;
-
-        AZ::JsonDeserializerSettings settings;
-        settings.m_serializeContext = &serializeContext;
-        settings.m_metadata.Create<SerializationListeners>();
-
-        auto loadResult = JSRU::LoadObjectFromStringByType
-            ( &dataTarget
-            , azrtti_typeid<ScriptCanvasData>()
-            , source
-            , &settings);
-
-        if (!loadResult.IsSuccess())
-        {
-            return loadResult;
-        }
-                    
-        if (auto graphData = dataTarget.ModGraph())
-        {
-            auto listeners = settings.m_metadata.Find<SerializationListeners>();
-            AZ_Assert(listeners, "Failed to find SerializationListeners");
-
-            ScriptCanvasAssetHandlerCpp::CollectNodes(graphData->GetGraphData()->m_nodes, *listeners);
-
-            for (auto listener : *listeners)
-            {
-                listener->OnDeserialize();
-            }
-        }
-        else
-        {
-            return AZ::Failure(AZStd::string("Failed to find graph data after loading source"));
-        }
-
-        return AZ::Success();
-    }
-
    AZ::Data::AssetHandler::LoadResult ScriptCanvasAssetHandler::LoadAssetData
        ( const AZ::Data::Asset<AZ::Data::AssetData>& assetTarget
        , AZStd::shared_ptr<AZ::Data::AssetDataStream> streamSource
@@ -167,7 +125,7 @@ namespace ScriptCanvasEditor
                settings.m_serializeContext = m_serializeContext;
                settings.m_metadata.Create<SerializationListeners>();
                // attempt JSON deserialization...
-                auto jsonResult = LoadScriptCanvasDataFromJson
+                auto jsonResult = LoadDataFromJson
                    ( scriptCanvasDataTarget
                    , AZStd::string_view{ byteBuffer.begin(), byteBuffer.size() }
                    , *m_serializeContext);
@@ -0,0 +1,129 @@
+/*
+ * 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/ComponentApplicationBus.h>
+#include <AzCore/IO/FileIO.h>
+#include <AzCore/IO/GenericStreams.h>
+#include <AzCore/Serialization/Json/JsonSerialization.h>
+#include <AzCore/Serialization/Json/JsonSerializationResult.h>
+#include <AzCore/Serialization/Json/JsonUtils.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/Utils.h>
+#include <AzCore/Utils/Utils.h>
+#include <AzCore/std/string/string_view.h>
+#include <AzFramework/StringFunc/StringFunc.h>
+#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
+#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>
+#include <ScriptCanvas/Bus/ScriptCanvasBus.h>
+#include <ScriptCanvas/Components/EditorGraph.h>
+#include <ScriptCanvas/Core/SerializationListener.h>
+
+namespace ScriptCanvasFileHandlingCpp
+{
+    using namespace ScriptCanvas;
+
+    void CollectNodes(const GraphData::NodeContainer& container, SerializationListeners& listeners)
+    {
+        for (auto& nodeEntity : container)
+        {
+            if (nodeEntity)
+            {
+                if (auto listener = azrtti_cast<SerializationListener*>(AZ::EntityUtils::FindFirstDerivedComponent<Node>(nodeEntity)))
+                {
+                    listeners.push_back(listener);
+                }
+            }
+        }
+    }
+}
+
+namespace ScriptCanvasEditor
+{
+    AZ::Outcome<void, AZStd::string> LoadDataFromJson
+        ( ScriptCanvas::ScriptCanvasData& dataTarget
+        , AZStd::string_view source
+        , AZ::SerializeContext& serializeContext)
+    {
+        namespace JSRU = AZ::JsonSerializationUtils;
+        using namespace ScriptCanvas;
+
+        AZ::JsonDeserializerSettings settings;
+        settings.m_serializeContext = &serializeContext;
+        settings.m_metadata.Create<SerializationListeners>();
+
+        auto loadResult = JSRU::LoadObjectFromStringByType
+            ( &dataTarget
+            , azrtti_typeid<ScriptCanvasData>()
+            , source
+            , &settings);
+
+        if (!loadResult.IsSuccess())
+        {
+            return loadResult;
+        }
+                    
+        if (auto graphData = dataTarget.ModGraph())
+        {
+            auto listeners = settings.m_metadata.Find<SerializationListeners>();
+            AZ_Assert(listeners, "Failed to find SerializationListeners");
+
+            ScriptCanvasFileHandlingCpp::CollectNodes(graphData->GetGraphData()->m_nodes, *listeners);
+
+            for (auto listener : *listeners)
+            {
+                listener->OnDeserialize();
+            }
+        }
+        else
+        {
+            return AZ::Failure(AZStd::string("Failed to find graph data after loading source"));
+        }
+
+        return AZ::Success();
+    }
+
+    AZ::Outcome<ScriptCanvasEditor::SourceHandle, AZStd::string> LoadFromFile(AZStd::string_view path)
+    {
+        namespace JSRU = AZ::JsonSerializationUtils;
+        using namespace ScriptCanvas;
+
+        auto fileStringOutcome = AZ::Utils::ReadFile<AZStd::string>(path);
+        if (!fileStringOutcome)
+        {
+            return AZ::Failure(fileStringOutcome.TakeError());
+        }
+
+        const auto& asString = fileStringOutcome.GetValue();
+        DataPtr scriptCanvasData = Graph::Create();
+        
+        AZ::SerializeContext* serializeContext = nullptr;
+        AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationRequests::GetSerializeContext);
+        if (!serializeContext)
+        {
+            return AZ::Failure(AZStd::string("no serialize context available to properly parse source file"));
+        }
+
+        // attempt JSON deserialization...
+        auto jsonResult = LoadDataFromJson(*scriptCanvasData, AZStd::string_view{ asString.begin(), asString.size() }, *serializeContext);
+        if (!jsonResult.IsSuccess())
+        {
+            // ...try legacy xml as a failsafe
+            AZ::IO::ByteContainerStream byteStream(&asString);
+            if (!AZ::Utils::LoadObjectFromStreamInPlace
+                ( byteStream
+                , *scriptCanvasData
+                , serializeContext
+                , AZ::ObjectStream::FilterDescriptor(nullptr, AZ::ObjectStream::FILTERFLAG_IGNORE_UNKNOWN_CLASSES)))
+            {
+                return AZ::Failure(AZStd::string::format("XML and JSON load attempts failed: %s", jsonResult.GetError().c_str()));
+            }
+        }
+
+        return AZ::Success(ScriptCanvasEditor::SourceHandle(scriptCanvasData, {}, path));
+    }
+}
@@ -172,7 +172,6 @@ namespace ScriptCanvasEditor

        bool IsSourceInError() const;

-        void OnSourceAssetFinalized(const AZStd::string& fullPath, AZ::Uuid sourceAssetId);
        void SavingComplete(const AZStd::string& fullPath, AZ::Uuid sourceAssetId);

        AZ::Data::AssetId GetSourceUuid() const { return m_sourceUuid; }
@@ -77,6 +77,7 @@ AZ_POP_DISABLE_WARNING
 #include <Libraries/Core/EBusEventHandler.h>
 #include <Libraries/Core/ReceiveScriptEvent.h>
 #include <Libraries/Core/ScriptEventBase.h>
+#include <ScriptCanvas/Assets/ScriptCanvasBaseAssetData.h>
 #include <Libraries/Core/SendScriptEvent.h>
 #include <ScriptCanvas/Asset/RuntimeAsset.h>
 #include <ScriptCanvas/Core/Connection.h>
@@ -1041,6 +1042,24 @@ namespace ScriptCanvasEditor
        }
    }

+    ScriptCanvas::DataPtr Graph::Create()
+    {
+        if (AZ::Entity* entity = aznew AZ::Entity("Script Canvas Graph"))
+        {
+            auto graph = entity->CreateComponent<ScriptCanvasEditor::Graph>();
+            graph->SetAssetType(azrtti_typeid<ScriptCanvasAsset>());
+            entity->CreateComponent<EditorGraphVariableManagerComponent>(graph->GetScriptCanvasId());
+
+            if (ScriptCanvas::DataPtr data = AZStd::make_shared<ScriptCanvas::ScriptCanvasData>())
+            {
+                data->m_scriptCanvasEntity.reset(entity);
+                return data;
+            }
+        }
+
+        return nullptr;
+    }
+
    bool Graph::CreateConnection(const GraphCanvas::ConnectionId& connectionId, const GraphCanvas::Endpoint& sourcePoint, const GraphCanvas::Endpoint& targetPoint)
    {
        if (!sourcePoint.IsValid() || !targetPoint.IsValid())
@@ -20,11 +20,6 @@ namespace AZ

 namespace ScriptCanvasEditor
 {
-    AZ::Outcome<void, AZStd::string> LoadScriptCanvasDataFromJson
-        ( ScriptCanvas::ScriptCanvasData& dataTarget
-        , AZStd::string_view source
-        , AZ::SerializeContext& serializeContext);
-
    /**
    * Manages editor Script Canvas graph assets.
    */
@@ -11,13 +11,23 @@

 namespace ScriptCanvas
 {
+    const Graph* ScriptCanvasData::GetGraph() const
+    {
+        return AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Graph>(m_scriptCanvasEntity.get());
+    }
+
+    const ScriptCanvasEditor::Graph* ScriptCanvasData::GetEditorGraph() const
+    {
+        return AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(m_scriptCanvasEntity.get());
+    }
+
    Graph* ScriptCanvasData::ModGraph()
    {
        return AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Graph>(m_scriptCanvasEntity.get());
    }

-    const Graph* ScriptCanvasData::GetGraph() const
+    ScriptCanvasEditor::Graph* ScriptCanvasData::ModEditorGraph()
    {
-        return AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvas::Graph>(m_scriptCanvasEntity.get());
+        return AZ::EntityUtils::FindFirstDerivedComponent<ScriptCanvasEditor::Graph>(m_scriptCanvasEntity.get());
    }
 }
@@ -28,9 +28,13 @@ namespace ScriptCanvas

        AZ::Entity* GetScriptCanvasEntity() const { return m_scriptCanvasEntity.get(); }

+        const Graph* GetGraph() const;
+
+        const ScriptCanvasEditor::Graph* GetEditorGraph() const;
+
        Graph* ModGraph();

-        const Graph* GetGraph() const;
+        ScriptCanvasEditor::Graph* ModEditorGraph();

        AZStd::unique_ptr<AZ::Entity> m_scriptCanvasEntity;
    private:
@@ -0,0 +1,35 @@
+/*
+ * 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/Asset/AssetManager.h>
+#include <AzCore/Asset/AssetTypeInfoBus.h>
+#include <AzCore/Serialization/ObjectStream.h>
+#include <ScriptCanvas/Assets/ScriptCanvasAsset.h>
+#include <ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.h>
+
+namespace AZ
+{
+    class SerializeContext;
+}
+
+namespace ScriptCanvas
+{
+    class ScriptCanvasData;
+}
+
+namespace ScriptCanvasEditor
+{
+    AZ::Outcome<ScriptCanvasEditor::SourceHandle, AZStd::string> LoadFromFile(AZStd::string_view path);
+
+    AZ::Outcome<void, AZStd::string> LoadDataFromJson
+        ( ScriptCanvas::ScriptCanvasData& dataTarget
+        , AZStd::string_view source
+        , AZ::SerializeContext& serializeContext);
+ }
@@ -0,0 +1,61 @@
+/*
+ * 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 <Editor/Include/ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.h>
+#include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasBaseAssetData.h>
+
+namespace ScriptCanvasEditor
+{
+    SourceHandle::SourceHandle(ScriptCanvas::DataPtr graph, const AZ::Uuid& id, AZStd::string_view path)
+        : m_data(graph)
+        , m_id(id)
+        , m_path(path)
+    {}
+
+    void SourceHandle::Clear()
+    {
+        m_data = nullptr;
+        m_id = AZ::Uuid::CreateNull();
+        m_path.clear();
+    }
+
+    GraphPtrConst SourceHandle::Get() const
+    {
+        return m_data ? m_data->GetEditorGraph() : nullptr;
+    }
+
+    const AZ::Uuid& SourceHandle::Id() const
+    {
+        return m_id;
+    }
+
+    bool SourceHandle::IsValid() const
+    {
+        return *this;
+    }
+
+    GraphPtr SourceHandle::Mod() const
+    {
+        return m_data ? m_data->ModEditorGraph() : nullptr;
+    }
+
+    SourceHandle::operator bool() const
+    {
+        return m_data != nullptr;
+    }
+
+    bool SourceHandle::operator!() const
+    {
+        return m_data == nullptr;
+    }
+
+    const AZStd::string& SourceHandle::Path() const
+    {
+        return m_path;
+    }
+}
@@ -0,0 +1,47 @@
+/*
+ * 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/Math/Uuid.h>
+#include <ScriptCanvas/Core/Core.h>
+
+namespace ScriptCanvasEditor
+{
+    class SourceHandle
+    {
+    public:
+        AZ_TYPE_INFO(SourceHandle, "{65855A98-AE2F-427F-BFC8-69D45265E312}");
+        AZ_CLASS_ALLOCATOR(SourceHandle, AZ::SystemAllocator, 0);
+
+        SourceHandle() = default;
+
+        SourceHandle(ScriptCanvas::DataPtr graph, const AZ::Uuid& id, AZStd::string_view path);
+
+        void Clear();
+
+        GraphPtrConst Get() const;
+
+        const AZ::Uuid& Id() const;
+
+        bool IsValid() const;
+
+        GraphPtr Mod() const;
+
+        operator bool() const;
+
+        bool operator!() const;
+
+        const AZStd::string& Path() const;
+                
+    private:
+        ScriptCanvas::DataPtr m_data;
+        AZ::Uuid m_id = AZ::Uuid::CreateNull();
+        AZStd::string m_path;
+    };
+} 
@@ -126,7 +126,7 @@ namespace ScriptCanvasEditor
        virtual void DisconnectEndpoints(const AZ::EntityId& /*sceneId*/, const AZStd::vector<GraphCanvas::Endpoint>& /*endpoints*/) {}

        virtual void PostUndoPoint(ScriptCanvas::ScriptCanvasId) = 0;
-        virtual void SignalSceneDirty(AZ::Data::AssetId) = 0;
+        virtual void SignalSceneDirty(SourceHandle) = 0;

        // Increment the value of the ignore undo point tracker
        virtual void PushPreventUndoStateUpdate() = 0;
@@ -101,6 +101,8 @@ namespace ScriptCanvasEditor
    public:
        AZ_COMPONENT(Graph, "{4D755CA9-AB92-462C-B24F-0B3376F19967}", ScriptCanvas::Graph);

+        static ScriptCanvas::DataPtr Create();
+
        static void Reflect(AZ::ReflectContext* context);

        Graph(const ScriptCanvas::ScriptCanvasId& scriptCanvasId = AZ::Entity::MakeId())
@@ -135,6 +135,7 @@
 #include <Editor/View/Widgets/NodePalette/CreateNodeMimeEvent.h>
 #include <Editor/View/Widgets/NodePalette/EBusNodePaletteTreeItemTypes.h>
 #include <Editor/View/Windows/Tools/UpgradeTool/UpgradeHelper.h>
+#include <ScriptCanvas/Assets/ScriptCanvasFileHandling.h>

 #include <Editor/View/Widgets/VariablePanel/SlotTypeSelectorWidget.h>

@@ -235,7 +236,7 @@ namespace ScriptCanvasEditor
            Widget::GraphTabBar* tabBar = m_mainWindow->m_tabBar;

            AZStd::vector<EditorSettings::EditorWorkspace::WorkspaceAssetSaveData> activeAssets;
-            AZ::Data::AssetId focusedAssetId = tabBar->FindAssetId(tabBar->currentIndex());
+            ScriptCanvasEditor::SourceHandle focusedAssetId = tabBar->FindAssetId(tabBar->currentIndex());

            if (m_rememberOpenCanvases)
            {
@@ -243,13 +244,13 @@ namespace ScriptCanvasEditor

                for (int i = 0; i < tabBar->count(); ++i)
                {
-                    AZ::Data::AssetId assetId = tabBar->FindAssetId(i);
+                    ScriptCanvasEditor::SourceHandle assetId = tabBar->FindAssetId(i);

                    const Tracker::ScriptCanvasFileState& fileState = m_mainWindow->GetAssetFileState(assetId);

                    if (fileState == Tracker::ScriptCanvasFileState::MODIFIED || fileState == Tracker::ScriptCanvasFileState::UNMODIFIED)
                    {
-                        AZ::Data::AssetId sourceId = GetSourceAssetId(assetId);
+                        ScriptCanvasEditor::SourceHandle sourceId = GetSourceAssetId(assetId);
                        if (sourceId.IsValid())
                        {
                            EditorSettings::EditorWorkspace::WorkspaceAssetSaveData assetSaveData;
@@ -316,7 +317,7 @@ namespace ScriptCanvasEditor

                if (m_loadingAssets.empty())
                {
-                    m_mainWindow->OnWorkspaceRestoreEnd(AZ::Data::AssetId());
+                    m_mainWindow->OnWorkspaceRestoreEnd(ScriptCanvasEditor::SourceHandle());
                }
                else
                {
@@ -336,7 +337,7 @@ namespace ScriptCanvasEditor
                        {
                            if (assetSaveData.m_assetId == m_queuedAssetFocus)
                            {
-                                m_queuedAssetFocus = AZ::Data::AssetId();
+                                m_queuedAssetFocus = ScriptCanvasEditor::SourceHandle();
                            }

                            SignalAssetComplete(asset.GetFileAssetId());
@@ -350,7 +351,7 @@ namespace ScriptCanvasEditor
                    {
                        if (assetSaveData.m_assetId == m_queuedAssetFocus)
                        {
-                            m_queuedAssetFocus = AZ::Data::AssetId();
+                            m_queuedAssetFocus = ScriptCanvasEditor::SourceHandle();
                        }

                        SignalAssetComplete(assetSaveData.m_assetId);
@@ -359,14 +360,14 @@ namespace ScriptCanvasEditor
            }
            else
            {
-                m_mainWindow->OnWorkspaceRestoreEnd(AZ::Data::AssetId());
+                m_mainWindow->OnWorkspaceRestoreEnd(ScriptCanvasEditor::SourceHandle());
            }
        }
    }

    void Workspace::OnAssetReady(const ScriptCanvasMemoryAsset::pointer memoryAsset)
    {
-        const AZ::Data::AssetId& fileAssetId = memoryAsset->GetFileAssetId();
+        const ScriptCanvasEditor::SourceHandle& fileAssetId = memoryAsset->GetFileAssetId();

        if (AssetTrackerNotificationBus::MultiHandler::BusIsConnectedId(fileAssetId))
        {
@@ -378,7 +379,7 @@ namespace ScriptCanvasEditor
        }
    }

-    void Workspace::SignalAssetComplete(const AZ::Data::AssetId& fileAssetId)
+    void Workspace::SignalAssetComplete(const ScriptCanvasEditor::SourceHandle& fileAssetId)
    {
        auto it = AZStd::find(m_loadingAssets.begin(), m_loadingAssets.end(), fileAssetId);
        if (it != m_loadingAssets.end())
@@ -394,7 +395,7 @@ namespace ScriptCanvasEditor
        }
    }

-    AZ::Data::AssetId Workspace::GetSourceAssetId(const AZ::Data::AssetId& memoryAssetId) const
+    ScriptCanvasEditor::SourceHandle Workspace::GetSourceAssetId(const ScriptCanvasEditor::SourceHandle& memoryAssetId) const
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, memoryAssetId);
@@ -404,7 +405,7 @@ namespace ScriptCanvasEditor
            return memoryAsset->GetFileAssetId();
        }

-        return AZ::Data::AssetId();
+        return ScriptCanvasEditor::SourceHandle();
    }

    ////////////////
@@ -655,9 +656,9 @@ namespace ScriptCanvasEditor
        QTimer::singleShot(0, [this]() {
            SetDefaultLayout();

-            if (m_activeAssetId.IsValid())
+            if (m_activeGraph.IsValid())
            {
-                m_queuedFocusOverride = m_activeAssetId;
+                m_queuedFocusOverride = m_activeGraph;
            }

            m_workspace->Restore();
@@ -831,7 +832,7 @@ namespace ScriptCanvasEditor
        connect(ui->action_ViewRestoreDefaultLayout, &QAction::triggered, this, &MainWindow::OnRestoreDefaultLayout);
    }

-    void MainWindow::SignalActiveSceneChanged(AZ::Data::AssetId assetId)
+    void MainWindow::SignalActiveSceneChanged(ScriptCanvasEditor::SourceHandle assetId)
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, assetId);
@@ -927,7 +928,7 @@ namespace ScriptCanvasEditor

        for (int tabCounter = 0; tabCounter < m_tabBar->count(); ++tabCounter)
        {
-            AZ::Data::AssetId assetId = m_tabBar->FindAssetId(tabCounter);
+            ScriptCanvasEditor::SourceHandle assetId = m_tabBar->FindAssetId(tabCounter);

            auto resultIterator = m_processedClosedAssetIds.insert(assetId);
            if (!resultIterator.second)
@@ -950,7 +951,7 @@ namespace ScriptCanvasEditor

            if (shouldSaveResults == UnsavedChangesOptions::SAVE)
            {
-                Callbacks::OnSave saveCB = [this](bool isSuccessful, AZ::Data::AssetPtr, AZ::Data::AssetId)
+                Callbacks::OnSave saveCB = [this](bool isSuccessful, AZ::Data::AssetPtr, ScriptCanvasEditor::SourceHandle)
                {
                    if (isSuccessful)
                    {
@@ -992,7 +993,7 @@ namespace ScriptCanvasEditor

        for (auto trackedAsset : allAssets)
        {
-            const AZ::Data::AssetId& assetId = trackedAsset->GetAsset().GetId();
+            const ScriptCanvasEditor::SourceHandle& assetId = trackedAsset->GetAsset().GetId();
            CloseScriptCanvasAsset(assetId);
        }

@@ -1032,7 +1033,7 @@ namespace ScriptCanvasEditor
        DequeuePropertyGridUpdate();

        UndoRequestBus::Event(GetActiveScriptCanvasId(), &UndoRequests::Undo);
-        SignalSceneDirty(m_activeAssetId);
+        SignalSceneDirty(m_activeGraph);

        m_propertyGrid->ClearSelection();
        GeneralEditorNotificationBus::Event(GetActiveScriptCanvasId(), &GeneralEditorNotifications::OnUndoRedoEnd);
@@ -1044,7 +1045,7 @@ namespace ScriptCanvasEditor
        DequeuePropertyGridUpdate();

        UndoRequestBus::Event(GetActiveScriptCanvasId(), &UndoRequests::Redo);
-        SignalSceneDirty(m_activeAssetId);
+        SignalSceneDirty(m_activeGraph);

        m_propertyGrid->ClearSelection();
        GeneralEditorNotificationBus::Event(GetActiveScriptCanvasId(), &GeneralEditorNotifications::OnUndoRedoEnd);
@@ -1117,14 +1118,14 @@ namespace ScriptCanvasEditor
        {
            ScopedUndoBatch scopedUndoBatch("Modify Graph Canvas Scene");
            UndoRequestBus::Event(scriptCanvasId, &UndoRequests::AddGraphItemChangeUndo, "Graph Change");
-            MarkAssetModified(m_activeAssetId);
+            MarkAssetModified(m_activeGraph);
        }

        const bool forceTimer = true;
        RestartAutoTimerSave(forceTimer);
    }

-    void MainWindow::SignalSceneDirty(AZ::Data::AssetId assetId)
+    void MainWindow::SignalSceneDirty(ScriptCanvasEditor::SourceHandle assetId)
    {
        MarkAssetModified(assetId);
    }
@@ -1147,7 +1148,7 @@ namespace ScriptCanvasEditor
        m_preventUndoStateUpdateCount = 0;
    }

-    void MainWindow::MarkAssetModified(const AZ::Data::AssetId& assetId)
+    void MainWindow::MarkAssetModified(const ScriptCanvasEditor::SourceHandle& assetId)
    {
        if (!assetId.IsValid())
        {
@@ -1200,7 +1201,7 @@ namespace ScriptCanvasEditor
        }
    }

-    AZ::Outcome<int, AZStd::string> MainWindow::OpenScriptCanvasAssetId(const AZ::Data::AssetId& fileAssetId)
+    AZ::Outcome<int, AZStd::string> MainWindow::OpenScriptCanvasAssetId(const ScriptCanvasEditor::SourceHandle& fileAssetId)
    {
        if (!fileAssetId.IsValid())
        {
@@ -1264,7 +1265,7 @@ namespace ScriptCanvasEditor

    AZ::Outcome<int, AZStd::string> MainWindow::OpenScriptCanvasAsset(const ScriptCanvasMemoryAsset& scriptCanvasAsset, int tabIndex /*= -1*/)
    {
-        const AZ::Data::AssetId& fileAssetId = scriptCanvasAsset.GetFileAssetId();
+        const ScriptCanvasEditor::SourceHandle& fileAssetId = scriptCanvasAsset.GetFileAssetId();
        if (!fileAssetId.IsValid())
        {
            return AZ::Failure(AZStd::string("Unable to open asset with invalid asset id"));
@@ -1337,7 +1338,7 @@ namespace ScriptCanvasEditor
        return AZ::Success(outTabIndex);
    }

-    AZ::Outcome<int, AZStd::string> MainWindow::OpenScriptCanvasAsset(AZ::Data::AssetId scriptCanvasAssetId, int tabIndex /*= -1*/)
+    AZ::Outcome<int, AZStd::string> MainWindow::OpenScriptCanvasAsset(ScriptCanvasEditor::SourceHandle scriptCanvasAssetId, int tabIndex /*= -1*/)
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, scriptCanvasAssetId);
@@ -1353,7 +1354,7 @@ namespace ScriptCanvasEditor
        }
    }

-    int MainWindow::CreateAssetTab(const AZ::Data::AssetId& assetId, int tabIndex)
+    int MainWindow::CreateAssetTab(const ScriptCanvasEditor::SourceHandle& assetId, int tabIndex)
    {
        return m_tabBar->InsertGraphTab(tabIndex, assetId);
    }
@@ -1378,7 +1379,7 @@ namespace ScriptCanvasEditor
        return AZ::Success(outTabIndex);
    }

-    void MainWindow::RemoveScriptCanvasAsset(const AZ::Data::AssetId& assetId)
+    void MainWindow::RemoveScriptCanvasAsset(const ScriptCanvasEditor::SourceHandle& assetId)
    {
        AssetHelpers::PrintInfo("RemoveScriptCanvasAsset : %s", AssetHelpers::AssetIdToString(assetId).c_str());

@@ -1404,13 +1405,13 @@ namespace ScriptCanvasEditor
        QVariant tabdata = m_tabBar->tabData(tabIndex);
        if (tabdata.isValid())
        {
-            auto tabAssetId = tabdata.value<AZ::Data::AssetId>();
+            auto tabAssetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();
            SetActiveAsset(tabAssetId);
        }

    }

-    int MainWindow::CloseScriptCanvasAsset(const AZ::Data::AssetId& assetId)
+    int MainWindow::CloseScriptCanvasAsset(const ScriptCanvasEditor::SourceHandle& assetId)
    {
        int tabIndex = -1;
        if (IsTabOpen(assetId, tabIndex))
@@ -1431,26 +1432,26 @@ namespace ScriptCanvasEditor
            }
        }

-        AZ::Data::AssetId previousAssetId = m_activeAssetId;
+        ScriptCanvasEditor::SourceHandle previousAssetId = m_activeGraph;

        OnFileNew();

-        bool createdNewAsset = m_activeAssetId != previousAssetId;
+        bool createdNewAsset = m_activeGraph != previousAssetId;

        if (createdNewAsset)
        {
-            m_assetCreationRequests[m_activeAssetId] = requestingEntityId;
+            m_assetCreationRequests[m_activeGraph] = requestingEntityId;
        }

        if (m_isRestoringWorkspace)
        {
-            m_queuedFocusOverride = m_activeAssetId;
+            m_queuedFocusOverride = m_activeGraph;
        }

        return createdNewAsset;
    }

-    bool MainWindow::IsScriptCanvasAssetOpen(const AZ::Data::AssetId& assetId) const
+    bool MainWindow::IsScriptCanvasAssetOpen(const ScriptCanvasEditor::SourceHandle& assetId) const
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, assetId);
@@ -1468,7 +1469,7 @@ namespace ScriptCanvasEditor
        return m_nodePaletteModel.FindNodePaletteInformation(nodeType);
    }

-    void MainWindow::GetSuggestedFullFilenameToSaveAs(const AZ::Data::AssetId& assetId, AZStd::string& filePath, AZStd::string& fileFilter)
+    void MainWindow::GetSuggestedFullFilenameToSaveAs(const ScriptCanvasEditor::SourceHandle& assetId, AZStd::string& filePath, AZStd::string& fileFilter)
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, assetId);
@@ -1514,6 +1515,21 @@ namespace ScriptCanvasEditor

    void MainWindow::OpenFile(const char* fullPath)
    {
+        AZ::Outcome<ScriptCanvasEditor::SourceHandle, AZStd::string> outcome = LoadFromFile(fullPath);
+
+        if (!outcome.IsSuccess())
+        {
+            m_errorFilePath = fullPath;
+            AZ_Warning("ScriptCanvas", false, "Unable to open file as a ScriptCanvas graph: %s", fullPath);
+        }
+        else
+        {
+            m_errorFilePath.clear();
+            m_activeGraph = outcome.TakeValue();
+            return;
+        }
+
+#if defined(EDITOR_ASSET_SUPPORT_ENABLED) 
        m_errorFilePath = fullPath;

        // Let's find the source file on disk
@@ -1566,6 +1582,7 @@ namespace ScriptCanvasEditor
        {
            QMessageBox::warning(this, "Invalid Source Asset", QString("'%1' is not a valid asset path.").arg(fullPath), QMessageBox::Ok);
        }
+#endif
    }

    GraphCanvas::Endpoint MainWindow::HandleProposedConnection(const GraphCanvas::GraphId&, const GraphCanvas::ConnectionId&, const GraphCanvas::Endpoint& endpoint, const GraphCanvas::NodeId& nodeId, const QPoint& screenPoint)
@@ -1676,7 +1693,7 @@ namespace ScriptCanvasEditor
        MakeNewFile<ScriptCanvasAsset, ScriptCanvasAssetHandler>();
    }

-    int MainWindow::InsertTabForAsset(AZStd::string_view assetPath, AZ::Data::AssetId assetId, int tabIndex)
+    int MainWindow::InsertTabForAsset(AZStd::string_view assetPath, ScriptCanvasEditor::SourceHandle assetId, int tabIndex)
    {
        int outTabIndex = -1;

@@ -1698,7 +1715,7 @@ namespace ScriptCanvasEditor
        return outTabIndex;
    }

-    void MainWindow::UpdateUndoCache(AZ::Data::AssetId)
+    void MainWindow::UpdateUndoCache(ScriptCanvasEditor::SourceHandle)
    {
        UndoCache* undoCache = nullptr;
        UndoRequestBus::EventResult(undoCache, GetActiveScriptCanvasId(), &UndoRequests::GetSceneUndoCache);
@@ -1712,10 +1729,10 @@ namespace ScriptCanvasEditor
    {
        int outTabIndex = -1;

-        AZ::Data::AssetId newAssetId;
+        ScriptCanvasEditor::SourceHandle newAssetId;
        auto onAssetCreated = [this, assetPath, tabIndex, &outTabIndex](ScriptCanvasMemoryAsset& asset)
        {
-            const AZ::Data::AssetId& assetId = asset.GetId();
+            const ScriptCanvasEditor::SourceHandle& assetId = asset.GetId();

            outTabIndex = InsertTabForAsset(assetPath, assetId, tabIndex);

@@ -1737,15 +1754,15 @@ namespace ScriptCanvasEditor

    bool MainWindow::OnFileSave(const Callbacks::OnSave& saveCB)
    {
-        return SaveAssetImpl(m_activeAssetId, saveCB);
+        return SaveAssetImpl(m_activeGraph, saveCB);
    }

    bool MainWindow::OnFileSaveAs(const Callbacks::OnSave& saveCB)
    {
-        return SaveAssetAsImpl(m_activeAssetId, saveCB);
+        return SaveAssetAsImpl(m_activeGraph, saveCB);
    }

-    bool MainWindow::SaveAssetImpl(const AZ::Data::AssetId& assetId, const Callbacks::OnSave& saveCB)
+    bool MainWindow::SaveAssetImpl(const ScriptCanvasEditor::SourceHandle& assetId, const Callbacks::OnSave& saveCB)
    {
        if (!assetId.IsValid())
        {
@@ -1772,14 +1789,14 @@ namespace ScriptCanvasEditor
        return saveSuccessful;
    }

-    bool MainWindow::SaveAssetAsImpl(const AZ::Data::AssetId& inMemoryAssetId, const Callbacks::OnSave& saveCB)
+    bool MainWindow::SaveAssetAsImpl(const ScriptCanvasEditor::SourceHandle& inMemoryAssetId, const Callbacks::OnSave& saveCB)
    {
        if (!inMemoryAssetId.IsValid())
        {
            return false;
        }

-        if (m_activeAssetId != inMemoryAssetId)
+        if (m_activeGraph != inMemoryAssetId)
        {
            OnChangeActiveGraphTab(inMemoryAssetId);
        }
@@ -1858,7 +1875,7 @@ namespace ScriptCanvasEditor
        return false;
    }

-    void MainWindow::OnSaveCallback(bool saveSuccess, AZ::Data::AssetPtr fileAsset, AZ::Data::AssetId previousFileAssetId)
+    void MainWindow::OnSaveCallback(bool saveSuccess, AZ::Data::AssetPtr fileAsset, ScriptCanvasEditor::SourceHandle previousFileAssetId)
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AZStd::string tabName = m_tabBar->tabText(m_tabBar->currentIndex()).toUtf8().data();
@@ -1871,7 +1888,7 @@ namespace ScriptCanvasEditor
            AZ_Assert(memoryAsset, "At this point we must have a MemoryAsset");

            // Update the editor with the new information about this asset.
-            const AZ::Data::AssetId& fileAssetId = memoryAsset->GetFileAssetId();
+            const ScriptCanvasEditor::SourceHandle& fileAssetId = memoryAsset->GetFileAssetId();

            saveTabIndex = m_tabBar->FindTab(fileAssetId);

@@ -1879,7 +1896,7 @@ namespace ScriptCanvasEditor
            if (saveTabIndex != m_tabBar->currentIndex())
            {
                // Invalidate the file asset id so we don't delete trigger the asset flow.
-                m_tabBar->setTabData(saveTabIndex, QVariant::fromValue(AZ::Data::AssetId()));
+                m_tabBar->setTabData(saveTabIndex, QVariant::fromValue(ScriptCanvasEditor::SourceHandle()));

                m_tabBar->CloseTab(saveTabIndex);
                saveTabIndex = -1;
@@ -1935,12 +1952,12 @@ namespace ScriptCanvasEditor
            }

            // Soft switch the asset id here. We'll do a double scene switch down below to actually switch the active assetid
-            m_activeAssetId = fileAssetId;
+            m_activeGraph = fileAssetId;
        }
        else
        {
            // Use the previous memory asset to find what we had setup as our display
-            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeAssetId);
+            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeGraph);

            // Drop off our file modifier status for our display name when we fail to save.
            if (tabName.at(tabName.size() -1) == '*')
@@ -1956,9 +1973,9 @@ namespace ScriptCanvasEditor
        else
        {
            // Something weird happens with our saving. Where we are relying on these scene changes being called.
-            AZ::Data::AssetId previousAssetId = m_activeAssetId;
+            ScriptCanvasEditor::SourceHandle previousAssetId = m_activeGraph;

-            OnChangeActiveGraphTab(AZ::Data::AssetId());
+            OnChangeActiveGraphTab(ScriptCanvasEditor::SourceHandle());
            OnChangeActiveGraphTab(previousAssetId);
        }

@@ -1984,17 +2001,17 @@ namespace ScriptCanvasEditor
        UnblockCloseRequests();
    }

-    bool MainWindow::ActivateAndSaveAsset(const AZ::Data::AssetId& unsavedAssetId, const Callbacks::OnSave& saveCB)
+    bool MainWindow::ActivateAndSaveAsset(const ScriptCanvasEditor::SourceHandle& unsavedAssetId, const Callbacks::OnSave& saveCB)
    {
        SetActiveAsset(unsavedAssetId);
        return OnFileSave(saveCB);
    }

-    void MainWindow::SaveAsset(AZ::Data::AssetId assetId, const Callbacks::OnSave& onSave)
+    void MainWindow::SaveAsset(ScriptCanvasEditor::SourceHandle assetId, const Callbacks::OnSave& onSave)
    {
        PrepareAssetForSave(assetId);

-        auto onSaveCallback = [this, onSave](bool saveSuccess, AZ::Data::AssetPtr asset, AZ::Data::AssetId previousAssetId)
+        auto onSaveCallback = [this, onSave](bool saveSuccess, AZ::Data::AssetPtr asset, ScriptCanvasEditor::SourceHandle previousAssetId)
        {
            OnSaveCallback(saveSuccess, asset, previousAssetId);
            if (onSave)
@@ -2007,7 +2024,7 @@ namespace ScriptCanvasEditor
        UpdateSaveState();

        ScriptCanvasMemoryAsset::pointer memoryAsset;
-        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeAssetId);
+        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeGraph);

        // Disable the current view if we are saving.
        if (memoryAsset)
@@ -2018,11 +2035,11 @@ namespace ScriptCanvasEditor
        BlockCloseRequests();
    }

-    void MainWindow::SaveNewAsset(AZStd::string_view path, AZ::Data::AssetId inMemoryAssetId, const Callbacks::OnSave& onSave)
+    void MainWindow::SaveNewAsset(AZStd::string_view path, ScriptCanvasEditor::SourceHandle inMemoryAssetId, const Callbacks::OnSave& onSave)
    {
        PrepareAssetForSave(inMemoryAssetId);

-        auto onSaveCallback = [this, onSave](bool saveSuccess, AZ::Data::AssetPtr asset, AZ::Data::AssetId previousAssetId)
+        auto onSaveCallback = [this, onSave](bool saveSuccess, AZ::Data::AssetPtr asset, ScriptCanvasEditor::SourceHandle previousAssetId)
        {
            OnSaveCallback(saveSuccess, asset, previousAssetId);
            if (onSave)
@@ -2052,7 +2069,7 @@ namespace ScriptCanvasEditor
        EBUS_EVENT_RESULT(serializeContext, AZ::ComponentApplicationBus, GetSerializeContext);
        AZ_Assert(serializeContext, "Failed to acquire application serialize context.");

-        AZ::Data::AssetId openId = ReadRecentAssetId();
+        ScriptCanvasEditor::SourceHandle openId = ReadRecentAssetId();

        AZStd::string assetRoot;
        {
@@ -2456,7 +2473,7 @@ namespace ScriptCanvasEditor

    void MainWindow::UpdateWorkspaceStatus(const ScriptCanvasMemoryAsset& memoryAsset)
    {
-        AZ::Data::AssetId fileAssetId = memoryAsset.GetFileAssetId();
+        ScriptCanvasEditor::SourceHandle fileAssetId = memoryAsset.GetFileAssetId();

        size_t eraseCount = m_loadingAssets.erase(fileAssetId);

@@ -2519,7 +2536,7 @@ namespace ScriptCanvasEditor
    {
        if (m_allowAutoSave)
        {
-            const Tracker::ScriptCanvasFileState& fileState = GetAssetFileState(m_activeAssetId);
+            const Tracker::ScriptCanvasFileState& fileState = GetAssetFileState(m_activeGraph);
            if (fileState != Tracker::ScriptCanvasFileState::INVALID && fileState != Tracker::ScriptCanvasFileState::NEW)
            {
                OnFileSaveCaller();
@@ -2528,7 +2545,7 @@ namespace ScriptCanvasEditor
    }

    //! GeneralRequestBus
-    void MainWindow::OnChangeActiveGraphTab(AZ::Data::AssetId assetId)
+    void MainWindow::OnChangeActiveGraphTab(ScriptCanvasEditor::SourceHandle assetId)
    {
        SetActiveAsset(assetId);
    }
@@ -2536,14 +2553,14 @@ namespace ScriptCanvasEditor
    AZ::EntityId MainWindow::GetActiveGraphCanvasGraphId() const
    {
        AZ::EntityId graphId;
-        AssetTrackerRequestBus::BroadcastResult(graphId, &AssetTrackerRequests::GetGraphId, m_activeAssetId);
+        AssetTrackerRequestBus::BroadcastResult(graphId, &AssetTrackerRequests::GetGraphId, m_activeGraph);
        return graphId;
    }

    ScriptCanvas::ScriptCanvasId MainWindow::GetActiveScriptCanvasId() const
    {
        ScriptCanvas::ScriptCanvasId sceneId;
-        AssetTrackerRequestBus::BroadcastResult(sceneId, &AssetTrackerRequests::GetScriptCanvasId, m_activeAssetId);
+        AssetTrackerRequestBus::BroadcastResult(sceneId, &AssetTrackerRequests::GetScriptCanvasId, m_activeGraph);
        return sceneId;
    }

@@ -2555,14 +2572,14 @@ namespace ScriptCanvasEditor
        return graphCanvasId;
    }

-    GraphCanvas::GraphId MainWindow::FindGraphCanvasGraphIdByAssetId(const AZ::Data::AssetId& assetId) const
+    GraphCanvas::GraphId MainWindow::FindGraphCanvasGraphIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const
    {
        AZ::EntityId graphId;
        AssetTrackerRequestBus::BroadcastResult(graphId, &AssetTrackerRequests::GetGraphId, assetId);
        return graphId;
    }

-    ScriptCanvas::ScriptCanvasId MainWindow::FindScriptCanvasIdByAssetId(const AZ::Data::AssetId& assetId) const
+    ScriptCanvas::ScriptCanvasId MainWindow::FindScriptCanvasIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const
    {
        ScriptCanvas::ScriptCanvasId scriptCanvasId;
        AssetTrackerRequestBus::BroadcastResult(scriptCanvasId, &AssetTrackerRequests::GetScriptCanvasId, assetId);
@@ -2602,14 +2619,14 @@ namespace ScriptCanvasEditor
        return isActive;
    }

-    QVariant MainWindow::GetTabData(const AZ::Data::AssetId& assetId)
+    QVariant MainWindow::GetTabData(const ScriptCanvasEditor::SourceHandle& assetId)
    {
        for (int tabIndex = 0; tabIndex < m_tabBar->count(); ++tabIndex)
        {
            QVariant tabdata = m_tabBar->tabData(tabIndex);
            if (tabdata.isValid())
            {
-                auto tabAssetId = tabdata.value<AZ::Data::AssetId>();
+                auto tabAssetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();
                if (tabAssetId == assetId)
                {
                    return tabdata;
@@ -2619,7 +2636,7 @@ namespace ScriptCanvasEditor
        return QVariant();
    }

-    bool MainWindow::IsTabOpen(const AZ::Data::AssetId& fileAssetId, int& outTabIndex) const
+    bool MainWindow::IsTabOpen(const ScriptCanvasEditor::SourceHandle& fileAssetId, int& outTabIndex) const
    {
        int tabIndex = m_tabBar->FindTab(fileAssetId);
        if (-1 != tabIndex)
@@ -2630,7 +2647,7 @@ namespace ScriptCanvasEditor
        return false;
    }

-    void MainWindow::ReconnectSceneBuses(AZ::Data::AssetId previousAssetId, AZ::Data::AssetId nextAssetId)
+    void MainWindow::ReconnectSceneBuses(ScriptCanvasEditor::SourceHandle previousAssetId, ScriptCanvasEditor::SourceHandle nextAssetId)
    {
        ScriptCanvasMemoryAsset::pointer previousAsset;
        AssetTrackerRequestBus::BroadcastResult(previousAsset, &AssetTrackerRequests::GetAsset, previousAssetId);
@@ -2666,14 +2683,14 @@ namespace ScriptCanvasEditor

    }

-    void MainWindow::SetActiveAsset(const AZ::Data::AssetId& fileAssetId)
+    void MainWindow::SetActiveAsset(const ScriptCanvasEditor::SourceHandle& fileAssetId)
    {
-        if (m_activeAssetId == fileAssetId)
+        if (m_activeGraph == fileAssetId)
        {
            return;
        }

-        AssetHelpers::PrintInfo("SetActiveAsset : from: %s to %s", AssetHelpers::AssetIdToString(m_activeAssetId).c_str(), AssetHelpers::AssetIdToString(fileAssetId).c_str());
+        AssetHelpers::PrintInfo("SetActiveAsset : from: %s to %s", AssetHelpers::AssetIdToString(m_activeGraph).c_str(), AssetHelpers::AssetIdToString(fileAssetId).c_str());

        if (fileAssetId.IsValid())
        {
@@ -2688,10 +2705,10 @@ namespace ScriptCanvasEditor
            }
        }

-        if (m_activeAssetId.IsValid())
+        if (m_activeGraph.IsValid())
        {
            ScriptCanvasMemoryAsset::pointer memoryAsset;
-            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeAssetId);
+            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeGraph);

            // If we are saving the asset, the Id may have changed from the in-memory to the file asset Id, in that case,
            // there's no need to hide the view or remove the widget
@@ -2704,23 +2721,23 @@ namespace ScriptCanvasEditor

        if (fileAssetId.IsValid())
        {
-            AZ::Data::AssetId previousAssetId = m_activeAssetId;
+            ScriptCanvasEditor::SourceHandle previousAssetId = m_activeGraph;

-            m_activeAssetId = fileAssetId;
+            m_activeGraph = fileAssetId;
            RefreshActiveAsset();

-            ReconnectSceneBuses(previousAssetId, m_activeAssetId);
+            ReconnectSceneBuses(previousAssetId, m_activeGraph);
        }
        else
        {
-            AZ::Data::AssetId previousAssetId = m_activeAssetId;
+            ScriptCanvasEditor::SourceHandle previousAssetId = m_activeGraph;

-            m_activeAssetId.SetInvalid();
+            m_activeGraph.SetInvalid();
            m_emptyCanvas->show();

-            ReconnectSceneBuses(previousAssetId, m_activeAssetId);
+            ReconnectSceneBuses(previousAssetId, m_activeGraph);

-            SignalActiveSceneChanged(AZ::Data::AssetId());
+            SignalActiveSceneChanged(ScriptCanvasEditor::SourceHandle());
        }

        UpdateUndoCache(fileAssetId);
@@ -2730,12 +2747,12 @@ namespace ScriptCanvasEditor

    void MainWindow::RefreshActiveAsset()
    {
-        if (m_activeAssetId.IsValid())
+        if (m_activeGraph.IsValid())
        {
-            AssetHelpers::PrintInfo("RefreshActiveAsset : m_activeAssetId (%s)", AssetHelpers::AssetIdToString(m_activeAssetId).c_str());
+            AssetHelpers::PrintInfo("RefreshActiveAsset : m_activeGraph (%s)", AssetHelpers::AssetIdToString(m_activeGraph).c_str());

            ScriptCanvasMemoryAsset::pointer memoryAsset;
-            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeAssetId);
+            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeGraph);

            if (memoryAsset)
            {
@@ -2754,7 +2771,7 @@ namespace ScriptCanvasEditor
                    AZ_Assert(view, "Asset should have a view");
                    if (view)
                    {
-                        AssetHelpers::PrintInfo("RefreshActiveAsset : m_activeAssetId (%s)", AssetHelpers::AssetIdToString(m_activeAssetId).c_str());
+                        AssetHelpers::PrintInfo("RefreshActiveAsset : m_activeGraph (%s)", AssetHelpers::AssetIdToString(m_activeGraph).c_str());

                        view->ShowScene(sceneEntityId);
                        m_layout->addWidget(view);
@@ -2763,7 +2780,7 @@ namespace ScriptCanvasEditor
                        m_emptyCanvas->hide();
                    }

-                    SignalActiveSceneChanged(m_activeAssetId);
+                    SignalActiveSceneChanged(m_activeGraph);
                }
            }
            else
@@ -2794,7 +2811,7 @@ namespace ScriptCanvasEditor
        QVariant tabdata = m_tabBar->tabData(index);
        if (tabdata.isValid())
        {
-            auto fileAssetId = tabdata.value<AZ::Data::AssetId>();
+            auto fileAssetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();

            Tracker::ScriptCanvasFileState fileState;
            AssetTrackerRequestBus::BroadcastResult(fileState, &AssetTrackerRequests::GetFileState, fileAssetId);
@@ -2821,7 +2838,7 @@ namespace ScriptCanvasEditor

            if (saveDialogResults == UnsavedChangesOptions::SAVE)
            {
-                auto saveCB = [this](bool isSuccessful, AZ::Data::AssetPtr asset, AZ::Data::AssetId)
+                auto saveCB = [this](bool isSuccessful, AZ::Data::AssetPtr asset, ScriptCanvasEditor::SourceHandle)
                {
                    if (isSuccessful)
                    {
@@ -2862,7 +2879,7 @@ namespace ScriptCanvasEditor
        QVariant tabdata = m_tabBar->tabData(index);
        if (tabdata.isValid())
        {
-            auto assetId = tabdata.value<AZ::Data::AssetId>();
+            auto assetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();
            SaveAssetImpl(assetId, nullptr);
        }

@@ -2881,7 +2898,7 @@ namespace ScriptCanvasEditor
        QVariant tabdata = m_tabBar->tabData(index);
        if (tabdata.isValid())
        {
-            auto assetId = tabdata.value<AZ::Data::AssetId>();
+            auto assetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();

            m_isClosingTabs = true;
            m_skipTabOnClose = assetId;
@@ -2897,7 +2914,7 @@ namespace ScriptCanvasEditor
        {
            QClipboard* clipBoard = QGuiApplication::clipboard();

-            auto assetId = tabdata.value<AZ::Data::AssetId>();
+            auto assetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();

            ScriptCanvasMemoryAsset::pointer memoryAsset;
            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, assetId);
@@ -2938,7 +2955,7 @@ namespace ScriptCanvasEditor
                QVariant tabdata = m_tabBar->tabData(tab);
                if (tabdata.isValid())
                {
-                    auto assetId = tabdata.value<AZ::Data::AssetId>();
+                    auto assetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();

                    if (assetId != m_skipTabOnClose)
                    {
@@ -2958,9 +2975,9 @@ namespace ScriptCanvasEditor
        QVariant tabdata = m_tabBar->tabData(index);
        if (tabdata.isValid())
        {
-            auto tabAssetId = tabdata.value<AZ::Data::AssetId>();
+            auto tabAssetId = tabdata.value<ScriptCanvasEditor::SourceHandle>();

-            if (tabAssetId == m_activeAssetId)
+            if (tabAssetId == m_activeGraph)
            {
                SetActiveAsset({});
            }
@@ -3164,7 +3181,7 @@ namespace ScriptCanvasEditor
        bool hasCopiableSelection = false;
        bool hasSelection = false;

-        if (m_activeAssetId.IsValid())
+        if (m_activeGraph.IsValid())
        {
            if (graphCanvasGraphId.IsValid())
            {
@@ -3552,7 +3569,7 @@ namespace ScriptCanvasEditor
        m_isRestoringWorkspace = true;
    }

-    void MainWindow::OnWorkspaceRestoreEnd(AZ::Data::AssetId lastFocusAsset)
+    void MainWindow::OnWorkspaceRestoreEnd(ScriptCanvasEditor::SourceHandle lastFocusAsset)
    {
        if (m_isRestoringWorkspace)
        {
@@ -3568,7 +3585,7 @@ namespace ScriptCanvasEditor
                SetActiveAsset(lastFocusAsset);
            }

-            if (!m_activeAssetId.IsValid())
+            if (!m_activeGraph.IsValid())
            {
                if (m_tabBar->count() > 0)
                {
@@ -3591,11 +3608,11 @@ namespace ScriptCanvasEditor

    void MainWindow::UpdateAssignToSelectionState()
    {
-        bool buttonEnabled = m_activeAssetId.IsValid();
+        bool buttonEnabled = m_activeGraph.IsValid();

        if (buttonEnabled)
        {
-            const Tracker::ScriptCanvasFileState& fileState = GetAssetFileState(m_activeAssetId);
+            const Tracker::ScriptCanvasFileState& fileState = GetAssetFileState(m_activeGraph);
            if (fileState == Tracker::ScriptCanvasFileState::INVALID || fileState == Tracker::ScriptCanvasFileState::NEW || fileState == Tracker::ScriptCanvasFileState::SOURCE_REMOVED)
            {
                buttonEnabled = false;
@@ -3624,18 +3641,18 @@ namespace ScriptCanvasEditor

    void MainWindow::UpdateSaveState()
    {
-        bool enabled = m_activeAssetId.IsValid();
+        bool enabled = m_activeGraph.IsValid();
        bool isSaving = false;
        bool hasModifications = false;

        if (enabled)
        {
-            Tracker::ScriptCanvasFileState fileState = GetAssetFileState(m_activeAssetId);
+            Tracker::ScriptCanvasFileState fileState = GetAssetFileState(m_activeGraph);
            hasModifications = (    fileState == Tracker::ScriptCanvasFileState::MODIFIED
                                || fileState == Tracker::ScriptCanvasFileState::NEW
                                || fileState == Tracker::ScriptCanvasFileState::SOURCE_REMOVED);

-            AssetTrackerRequestBus::BroadcastResult(isSaving, &AssetTrackerRequests::IsSaving, m_activeAssetId);
+            AssetTrackerRequestBus::BroadcastResult(isSaving, &AssetTrackerRequests::IsSaving, m_activeGraph);
        }

        ui->action_Save->setEnabled(enabled && !isSaving && hasModifications);
@@ -3837,14 +3854,14 @@ namespace ScriptCanvasEditor
        return findChild<QObject*>(elementName);
    }

-    AZ::EntityId MainWindow::FindEditorNodeIdByAssetNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId assetNodeId) const
+    AZ::EntityId MainWindow::FindEditorNodeIdByAssetNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId assetNodeId) const
    {
        AZ::EntityId editorEntityId;
        AssetTrackerRequestBus::BroadcastResult(editorEntityId, &AssetTrackerRequests::GetEditorEntityIdFromSceneEntityId, assetId, assetNodeId);
        return editorEntityId;
    }

-    AZ::EntityId MainWindow::FindAssetNodeIdByEditorNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId editorNodeId) const
+    AZ::EntityId MainWindow::FindAssetNodeIdByEditorNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId editorNodeId) const
    {
        AZ::EntityId sceneEntityId;
        AssetTrackerRequestBus::BroadcastResult(sceneEntityId, &AssetTrackerRequests::GetSceneEntityIdFromEditorEntityId, assetId, editorNodeId);
@@ -3961,7 +3978,7 @@ namespace ScriptCanvasEditor

        OnFileNew();

-        if (m_activeAssetId.IsValid())
+        if (m_activeGraph.IsValid())
        {
            graphId = GetActiveGraphCanvasGraphId();
        }
@@ -4265,10 +4282,10 @@ namespace ScriptCanvasEditor

    void MainWindow::PrepareActiveAssetForSave()
    {
-        PrepareAssetForSave(m_activeAssetId);
+        PrepareAssetForSave(m_activeGraph);
    }

-    void MainWindow::PrepareAssetForSave(const AZ::Data::AssetId& assetId)
+    void MainWindow::PrepareAssetForSave(const ScriptCanvasEditor::SourceHandle& assetId)
    {
        ScriptCanvasMemoryAsset::pointer memoryAsset;
        AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, assetId);
@@ -4337,7 +4354,7 @@ namespace ScriptCanvasEditor
    void MainWindow::OnAssignToSelectedEntities()
    {
        Tracker::ScriptCanvasFileState fileState;
-        AssetTrackerRequestBus::BroadcastResult(fileState, &AssetTrackerRequests::GetFileState, m_activeAssetId);
+        AssetTrackerRequestBus::BroadcastResult(fileState, &AssetTrackerRequests::GetFileState, m_activeGraph);

        bool isDocumentOpen = false;
        AzToolsFramework::EditorRequests::Bus::BroadcastResult(isDocumentOpen, &AzToolsFramework::EditorRequests::IsLevelDocumentOpen);
@@ -4398,7 +4415,7 @@ namespace ScriptCanvasEditor

    void MainWindow::OnAssignToEntity(const AZ::EntityId& entityId)
    {
-        Tracker::ScriptCanvasFileState fileState = GetAssetFileState(m_activeAssetId);
+        Tracker::ScriptCanvasFileState fileState = GetAssetFileState(m_activeGraph);

        if (fileState == Tracker::ScriptCanvasFileState::MODIFIED
            || fileState == Tracker::ScriptCanvasFileState::UNMODIFIED)
@@ -4407,7 +4424,7 @@ namespace ScriptCanvasEditor
        }
    }

-    ScriptCanvasEditor::Tracker::ScriptCanvasFileState MainWindow::GetAssetFileState(AZ::Data::AssetId assetId) const
+    ScriptCanvasEditor::Tracker::ScriptCanvasFileState MainWindow::GetAssetFileState(ScriptCanvasEditor::SourceHandle assetId) const
    {
        Tracker::ScriptCanvasFileState fileState = Tracker::ScriptCanvasFileState::INVALID;
        AssetTrackerRequestBus::BroadcastResult(fileState, &AssetTrackerRequests::GetFileState, assetId);
@@ -4460,7 +4477,7 @@ namespace ScriptCanvasEditor
        if (usableRequestBus)
        {
            ScriptCanvasMemoryAsset::pointer memoryAsset;
-            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeAssetId);
+            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, m_activeGraph);

            if (memoryAsset)
            {
@@ -43,7 +43,7 @@
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 #include <ScriptCanvas/Core/ScriptCanvasBus.h>
 #include <ScriptCanvas/Debugger/ClientTransceiver.h>
-
+#include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.h>
 #include <Editor/Assets/ScriptCanvasAssetHolder.h>
 #include <Editor/Undo/ScriptCanvasGraphCommand.h>
 #include <Editor/Utilities/RecentFiles.h>
@@ -175,9 +175,9 @@ namespace ScriptCanvasEditor
    private:

        void OnAssetReady(const ScriptCanvasMemoryAsset::pointer asset) override;
-        void SignalAssetComplete(const AZ::Data::AssetId& fileAssetId);
+        void SignalAssetComplete(const ScriptCanvasEditor::SourceHandle& fileAssetId);

-        AZ::Data::AssetId GetSourceAssetId(const AZ::Data::AssetId& memoryAssetId) const;
+        ScriptCanvasEditor::SourceHandle GetSourceAssetId(const ScriptCanvasEditor::SourceHandle& memoryAssetId) const;

        bool m_rememberOpenCanvases;
        MainWindow* m_mainWindow;
@@ -185,10 +185,10 @@ namespace ScriptCanvasEditor
        //! Setting focus is problematic unless it is done until after all currently loading graphs have finished loading
        //! This vector is used to track the list of graphs being opened to restore the workspace and as assets are fully
        //! ready and activated they are removed from this list.
-        AZStd::vector<AZ::Data::AssetId> m_loadingAssets;
+        AZStd::vector<ScriptCanvasEditor::SourceHandle> m_loadingAssets;

        //! During restore we queue the asset Id to focus in order to do it last
-        AZ::Data::AssetId m_queuedAssetFocus;
+        ScriptCanvasEditor::SourceHandle m_queuedAssetFocus;
    };

    enum class UnsavedChangesOptions;
@@ -269,7 +269,7 @@ namespace ScriptCanvasEditor

        // Undo Handlers
        void PostUndoPoint(ScriptCanvas::ScriptCanvasId scriptCanvasId) override;
-        void SignalSceneDirty(AZ::Data::AssetId assetId) override;
+        void SignalSceneDirty(ScriptCanvasEditor::SourceHandle assetId) override;

        void PushPreventUndoStateUpdate() override;
        void PopPreventUndoStateUpdate() override;
@@ -329,8 +329,8 @@ namespace ScriptCanvasEditor
        bool OnFileSaveAs(const Callbacks::OnSave& saveCB);
        bool OnFileSaveCaller(){return OnFileSave(nullptr);};
        bool OnFileSaveAsCaller(){return OnFileSaveAs(nullptr);};        
-        bool SaveAssetImpl(const AZ::Data::AssetId& assetId, const Callbacks::OnSave& saveCB);
-        bool SaveAssetAsImpl(const AZ::Data::AssetId& assetId, const Callbacks::OnSave& saveCB);
+        bool SaveAssetImpl(const ScriptCanvasEditor::SourceHandle& assetId, const Callbacks::OnSave& saveCB);
+        bool SaveAssetAsImpl(const ScriptCanvasEditor::SourceHandle& assetId, const Callbacks::OnSave& saveCB);
        void OnFileOpen();        

        // Edit menu
@@ -415,17 +415,17 @@ namespace ScriptCanvasEditor

        void CloseNextTab();

-        bool IsTabOpen(const AZ::Data::AssetId& assetId, int& outTabIndex) const;
-        QVariant GetTabData(const AZ::Data::AssetId& assetId);
+        bool IsTabOpen(const ScriptCanvasEditor::SourceHandle& assetId, int& outTabIndex) const;
+        QVariant GetTabData(const ScriptCanvasEditor::SourceHandle& assetId);

        //! GeneralRequestBus
-        AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetId(const AZ::Data::AssetId& assetId) override;
-        AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(AZ::Data::AssetId scriptCanvasAssetId, int tabIndex = -1) override;
+        AZ::Outcome<int, AZStd::string> OpenScriptCanvasAssetId(const ScriptCanvasEditor::SourceHandle& assetId) override;
+        AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(ScriptCanvasEditor::SourceHandle scriptCanvasAssetId, int tabIndex = -1) override;
        AZ::Outcome<int, AZStd::string> OpenScriptCanvasAsset(const ScriptCanvasMemoryAsset& scriptCanvasAsset, int tabIndex = -1);
-        int CloseScriptCanvasAsset(const AZ::Data::AssetId& assetId) override;
+        int CloseScriptCanvasAsset(const ScriptCanvasEditor::SourceHandle& assetId) override;
        bool CreateScriptCanvasAssetFor(const TypeDefs::EntityComponentId& requestingEntityId) override;

-        bool IsScriptCanvasAssetOpen(const AZ::Data::AssetId& assetId) const override;
+        bool IsScriptCanvasAssetOpen(const ScriptCanvasEditor::SourceHandle& assetId) const override;

        const CategoryInformation* FindNodePaletteCategoryInformation(AZStd::string_view categoryPath) const override;
        const NodePaletteModelInformation* FindNodePaletteModelInformation(const ScriptCanvas::NodeTypeIdentifier& nodeType) const override;
@@ -437,8 +437,8 @@ namespace ScriptCanvasEditor
        void RefreshScriptCanvasAsset(const AZ::Data::Asset<ScriptCanvas::ScriptCanvasAssetBase>& scriptCanvasAsset);

        //! Removes the assetId -> ScriptCanvasAsset mapping and disconnects from the asset tracker
-        void RemoveScriptCanvasAsset(const AZ::Data::AssetId& assetId);
-        void OnChangeActiveGraphTab(AZ::Data::AssetId) override;
+        void RemoveScriptCanvasAsset(const ScriptCanvasEditor::SourceHandle& assetId);
+        void OnChangeActiveGraphTab(ScriptCanvasEditor::SourceHandle) override;

        void CreateNewRuntimeAsset() override { OnFileNew(); }

@@ -448,8 +448,8 @@ namespace ScriptCanvasEditor

        GraphCanvas::GraphId GetGraphCanvasGraphId(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const override;

-        GraphCanvas::GraphId FindGraphCanvasGraphIdByAssetId(const AZ::Data::AssetId& assetId) const override;
-        ScriptCanvas::ScriptCanvasId FindScriptCanvasIdByAssetId(const AZ::Data::AssetId& assetId) const override;
+        GraphCanvas::GraphId FindGraphCanvasGraphIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const override;
+        ScriptCanvas::ScriptCanvasId FindScriptCanvasIdByAssetId(const ScriptCanvasEditor::SourceHandle& assetId) const override;

        bool IsInUndoRedo(const AZ::EntityId& graphCanvasGraphId) const override;
        bool IsScriptCanvasInUndoRedo(const ScriptCanvas::ScriptCanvasId& scriptCanvasId) const override;
@@ -517,8 +517,8 @@ namespace ScriptCanvasEditor
        QObject* FindElementByName(QString elementName) override;
        ////

-        AZ::EntityId FindEditorNodeIdByAssetNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId assetNodeId) const override;
-        AZ::EntityId FindAssetNodeIdByEditorNodeId(const AZ::Data::AssetId& assetId, AZ::EntityId editorNodeId) const override;
+        AZ::EntityId FindEditorNodeIdByAssetNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId assetNodeId) const override;
+        AZ::EntityId FindAssetNodeIdByEditorNodeId(const ScriptCanvasEditor::SourceHandle& assetId, AZ::EntityId editorNodeId) const override;
        
    private:
        void DeleteNodes(const AZ::EntityId& sceneId, const AZStd::vector<AZ::EntityId>& nodes) override;
@@ -546,26 +546,23 @@ namespace ScriptCanvasEditor
        //! Helper function which serializes a file to disk
        //! \param filename name of file to serialize the Entity
        //! \param asset asset to save
-        void GetSuggestedFullFilenameToSaveAs(const AZ::Data::AssetId& assetId, AZStd::string& filePath, AZStd::string& fileFilter);
+        void GetSuggestedFullFilenameToSaveAs(const ScriptCanvasEditor::SourceHandle& assetId, AZStd::string& filePath, AZStd::string& fileFilter);

-        void MarkAssetModified(const AZ::Data::AssetId& assetId);
+        void MarkAssetModified(const ScriptCanvasEditor::SourceHandle& assetId);

        // QMainWindow
        void closeEvent(QCloseEvent *event) override;
        UnsavedChangesOptions ShowSaveDialog(const QString& filename);
        
-        bool ActivateAndSaveAsset(const AZ::Data::AssetId& unsavedAssetId, const Callbacks::OnSave& onSave);
+        bool ActivateAndSaveAsset(const ScriptCanvasEditor::SourceHandle& unsavedAssetId, const Callbacks::OnSave& onSave);

-        void SaveNewAsset(AZStd::string_view path, AZ::Data::AssetId assetId, const Callbacks::OnSave& onSave);
-        void SaveAsset(AZ::Data::AssetId assetId, const Callbacks::OnSave& onSave);
+        void SaveNewAsset(AZStd::string_view path, ScriptCanvasEditor::SourceHandle assetId, const Callbacks::OnSave& onSave);
+        void SaveAsset(ScriptCanvasEditor::SourceHandle assetId, const Callbacks::OnSave& onSave);

        void OpenFile(const char* fullPath);
        void CreateMenus();

-        void SignalActiveSceneChanged(const AZ::Data::AssetId assetId);
-
-        void SaveWorkspace(bool updateAssetList = true);
-        void RestoreWorkspace();
+        void SignalActiveSceneChanged(const ScriptCanvasEditor::SourceHandle assetId);

        void RunUpgradeTool();

@@ -593,7 +590,7 @@ namespace ScriptCanvasEditor
        void UpdateMenuState(bool enabledState);

        void OnWorkspaceRestoreStart();
-        void OnWorkspaceRestoreEnd(AZ::Data::AssetId lastFocusAsset);
+        void OnWorkspaceRestoreEnd(ScriptCanvasEditor::SourceHandle lastFocusAsset);

        void UpdateAssignToSelectionState();
        void UpdateUndoRedoState();
@@ -604,18 +601,16 @@ namespace ScriptCanvasEditor

        void CreateFunctionDefinitionNode(int positionOffset);

-        int CreateAssetTab(const AZ::Data::AssetId& assetId, int tabIndex = -1);
+        int CreateAssetTab(const ScriptCanvasEditor::SourceHandle& assetId, int tabIndex = -1);

        //! \param asset The AssetId of the ScriptCanvas Asset.
-        void SetActiveAsset(const AZ::Data::AssetId& assetId);
+        void SetActiveAsset(const ScriptCanvasEditor::SourceHandle& assetId);
        void RefreshActiveAsset();

-        void ReconnectSceneBuses(AZ::Data::AssetId previousAssetId, AZ::Data::AssetId nextAssetId);
-
-        void SignalBatchOperationComplete(BatchOperatorTool* batchTool);
+        void ReconnectSceneBuses(ScriptCanvasEditor::SourceHandle previousAssetId, ScriptCanvasEditor::SourceHandle nextAssetId);

        void PrepareActiveAssetForSave();
-        void PrepareAssetForSave(const AZ::Data::AssetId& asssetId);
+        void PrepareAssetForSave(const ScriptCanvasEditor::SourceHandle& asssetId);

        void RestartAutoTimerSave(bool forceTimer = false);

@@ -626,9 +621,9 @@ namespace ScriptCanvasEditor
        void AssignGraphToEntityImpl(const AZ::EntityId& entityId);
        ////

-        Tracker::ScriptCanvasFileState GetAssetFileState(AZ::Data::AssetId assetId) const;
+        Tracker::ScriptCanvasFileState GetAssetFileState(ScriptCanvasEditor::SourceHandle assetId) const;

-        AZ::Data::AssetId GetSourceAssetId(const AZ::Data::AssetId& memoryAssetId) const
+        ScriptCanvasEditor::SourceHandle GetSourceAssetId(const ScriptCanvasEditor::SourceHandle& memoryAssetId) const
        {
            ScriptCanvasMemoryAsset::pointer memoryAsset;
            AssetTrackerRequestBus::BroadcastResult(memoryAsset, &AssetTrackerRequests::GetAsset, memoryAssetId);
@@ -638,12 +633,12 @@ namespace ScriptCanvasEditor
                return memoryAsset->GetFileAssetId();
            }

-            return AZ::Data::AssetId();
+            return ScriptCanvasEditor::SourceHandle();
        }

-        int InsertTabForAsset(AZStd::string_view assetPath, AZ::Data::AssetId assetId, int tabIndex = -1);
+        int InsertTabForAsset(AZStd::string_view assetPath, ScriptCanvasEditor::SourceHandle assetId, int tabIndex = -1);

-        void UpdateUndoCache(AZ::Data::AssetId assetId);
+        void UpdateUndoCache(ScriptCanvasEditor::SourceHandle assetId);


        bool HasSystemTickAction(SystemTickActionFlag action);
@@ -741,22 +736,22 @@ namespace ScriptCanvasEditor
        GraphCanvas::GraphCanvasEditorEmptyDockWidget* m_emptyCanvas; // Displayed when there is no open graph
        QVBoxLayout* m_layout;

-        AZ::Data::AssetId m_activeAssetId;
-
+        ScriptCanvasEditor::SourceHandle m_activeGraph;
+        
        bool                  m_loadingNewlySavedFile;
        AZStd::string         m_newlySavedFile;

        AZStd::string         m_errorFilePath;

        bool m_isClosingTabs;
-        AZ::Data::AssetId m_skipTabOnClose;
+        ScriptCanvasEditor::SourceHandle m_skipTabOnClose;

        bool m_enterState;
        bool m_ignoreSelection;
        AZ::s32 m_preventUndoStateUpdateCount;

        bool m_isRestoringWorkspace;
-        AZ::Data::AssetId m_queuedFocusOverride;
+        ScriptCanvasEditor::SourceHandle m_queuedFocusOverride;

        Ui::MainWindow* ui;
        AZStd::array<AZStd::pair<QAction*, QMetaObject::Connection>, c_scriptCanvasEditorSettingsRecentFilesCountMax> m_recentActions;
@@ -778,17 +773,17 @@ namespace ScriptCanvasEditor
        AZStd::vector<AZ::EntityId> m_selectedVariableIds;

        AZ::u32                                   m_systemTickActions;
-        AZStd::unordered_set< AZ::Data::AssetId > m_processedClosedAssetIds;
+        AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_processedClosedAssetIds;

-        AZStd::unordered_set< AZ::Data::AssetId > m_loadingWorkspaceAssets;
-        AZStd::unordered_set< AZ::Data::AssetId > m_loadingAssets;
+        AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_loadingWorkspaceAssets;
+        AZStd::unordered_set< ScriptCanvasEditor::SourceHandle > m_loadingAssets;
        AZStd::unordered_set< AZ::Uuid > m_variablePaletteTypes;

        AZStd::unordered_map< AZ::Crc32, QObject* > m_automationLookUpMap;

        bool m_closeCurrentGraphAfterSave;

-        AZStd::unordered_map< AZ::Data::AssetId, TypeDefs::EntityComponentId > m_assetCreationRequests;
+        AZStd::unordered_map< ScriptCanvasEditor::SourceHandle, TypeDefs::EntityComponentId > m_assetCreationRequests;

        ScriptCanvas::Debugger::ClientTransceiver m_clientTRX;
        GraphCanvas::StyleManager m_styleManager;
@@ -797,6 +792,6 @@ namespace ScriptCanvasEditor
        //! this object manages the Save/Restore operations
        Workspace* m_workspace;

-        void OnSaveCallback(bool saveSuccess, AZ::Data::AssetPtr, AZ::Data::AssetId previousFileAssetId);
+        void OnSaveCallback(bool saveSuccess, AZ::Data::AssetPtr, ScriptCanvasEditor::SourceHandle previousFileAssetId);
    };
 }
@@ -8,16 +8,17 @@

 #pragma once

+#include <AzCore/std/smart_ptr/enable_shared_from_this.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetBus.h>
 #include <Editor/Include/ScriptCanvas/Assets/ScriptCanvasBaseAssetData.h>
-
 #include <ScriptCanvas/Asset/AssetDescription.h>

 namespace ScriptCanvas
 {
    class ScriptCanvasAssetBase
        : public AZ::Data::AssetData
+        , public AZStd::enable_shared_from_this<ScriptCanvasAssetBase>
        , ScriptCanvas::ScriptCanvasAssetBusRequestBus::Handler
    {

@@ -26,6 +26,8 @@

 #define OBJECT_STREAM_EDITOR_ASSET_LOADING_SUPPORT_ENABLED

+#define EDITOR_ASSET_SUPPORT_ENABLED
+
 namespace AZ
 {
    class Entity;
@@ -61,6 +63,10 @@ namespace ScriptCanvas

    class Node;
    class Edge;
+    class Graph;
+
+    using GraphPtr = Graph*;
+    using GraphPtrConst = const Graph*;

    using ID = AZ::EntityId;

@@ -297,6 +303,24 @@ namespace ScriptCanvas
    void ReflectEventTypeOnDemand(const AZ::TypeId& typeId, AZStd::string_view name, AZ::IRttiHelper* rttiHelper = nullptr);
 }

+namespace ScriptCanvas
+{
+    class ScriptCanvasData;
+
+    using DataPtr = AZStd::shared_ptr<ScriptCanvasData>;
+    using DataPtrConst = AZStd::shared_ptr<const ScriptCanvasData>;
+}
+
+namespace ScriptCanvasEditor
+{
+    class Graph;
+    
+    using GraphPtr = Graph*;
+    using GraphPtrConst = const Graph*;
+
+    class SourceHandle;
+}
+
 namespace AZStd
 {
    template<>
@@ -14,14 +14,12 @@
 #include <AzCore/std/containers/stack.h>
 #include <AzCore/std/containers/unordered_map.h>
 #include <AzCore/std/parallel/mutex.h>
-
 #include <ScriptCanvas/Core/GraphBus.h>
 #include <ScriptCanvas/Core/GraphData.h>
 #include <ScriptCanvas/Debugger/Bus.h>
 #include <ScriptCanvas/Execution/ErrorBus.h>
 #include <ScriptCanvas/Execution/ExecutionContext.h>
 #include <ScriptCanvas/Debugger/StatusBus.h>
-
 #include <ScriptCanvas/Debugger/ValidationEvents/ValidationEvent.h>

 namespace ScriptCanvas
@@ -209,7 +207,7 @@ namespace ScriptCanvas
        GraphVariableManagerRequests* m_variableRequests = nullptr;

        // Keeps a mapping of the Node EntityId -> NodeComponent.
-        // Saves looking up the NodeComponent everytime we need the Node.
+        // Saves looking up the NodeComponent every time we need the Node.
        AZStd::unordered_map<AZ::EntityId, Node* > m_nodeMapping;
        
        bool m_isObserved;
@@ -27,7 +27,11 @@ set(FILES
    Editor/Assets/ScriptCanvasAsset.cpp
    Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetBus.h
    Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetTypes.h
+    Editor/Include/ScriptCanvas/Assets/ScriptCanvasFileHandling.h
+    Editor/Include/ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.h
+    Editor/Include/ScriptCanvas/Assets/ScriptCanvasSourceFileHandle.cpp
    Editor/Include/ScriptCanvas/Assets/ScriptCanvasAssetHandler.h
+    Editor/Assets/ScriptCanvasFileHandling.cpp
    Editor/Assets/ScriptCanvasAssetHandler.cpp
    Editor/Assets/ScriptCanvasAssetHolder.h
    Editor/Assets/ScriptCanvasAssetHolder.cpp