diff --git a/src/ZoneCommon/Zone/ZoneMemory.cpp b/src/ZoneCommon/Zone/ZoneMemory.cpp
index 72394d52..4ef3f33f 100644
--- a/src/ZoneCommon/Zone/ZoneMemory.cpp
+++ b/src/ZoneCommon/Zone/ZoneMemory.cpp
@@ -6,3 +6,13 @@ void ZoneMemory::AddBlock(std::unique_ptr<XBlock> block)
 {
     m_blocks.emplace_back(std::move(block));
 }
+
+size_t ZoneMemory::GetBlockCount() const
+{
+    return m_blocks.size();
+}
+
+XBlock* ZoneMemory::GetBlock(const size_t index) const
+{
+    return m_blocks.at(index).get();
+}
diff --git a/src/ZoneCommon/Zone/ZoneMemory.h b/src/ZoneCommon/Zone/ZoneMemory.h
index 1344eef4..cd867722 100644
--- a/src/ZoneCommon/Zone/ZoneMemory.h
+++ b/src/ZoneCommon/Zone/ZoneMemory.h
@@ -8,10 +8,13 @@
 
 class ZoneMemory : public MemoryManager
 {
-    std::vector<std::unique_ptr<XBlock>> m_blocks;
-
 public:
     ZoneMemory();
 
     void AddBlock(std::unique_ptr<XBlock> block);
+    [[nodiscard]] size_t GetBlockCount() const;
+    [[nodiscard]] XBlock* GetBlock(size_t index) const;
+
+private:
+    std::vector<std::unique_ptr<XBlock>> m_blocks;
 };
diff --git a/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp b/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
index a3e770b7..dd68de71 100644
--- a/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
+++ b/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
@@ -35,19 +35,19 @@ namespace fs = std::filesystem;
 
 namespace
 {
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -185,7 +185,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
@@ -199,7 +199,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     {
         // Start of the XFile struct
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
 
         // Start of the zone content
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
@@ -210,7 +210,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
             32u,
             ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
             ZoneConstants::INSERT_BLOCK,
-            zonePtr->Memory(),
+            zonePtr,
             std::move(progressCallback)));
     }
     else
diff --git a/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp b/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
index 202b6a8d..557f38ee 100644
--- a/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
+++ b/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
@@ -138,18 +138,18 @@ namespace
         return std::nullopt;
     }
 
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -192,7 +192,7 @@ namespace
         }
     }
 
-    void AddAuthHeaderSteps(const ZoneLoaderInspectionResultIW4& inspectResult, ZoneLoader& zoneLoader, const std::string& fileName)
+    void AddAuthHeaderSteps(const ZoneLoaderInspectionResultIW4& inspectResult, ZoneReader& zoneReader, const std::string& fileName)
     {
         // Unsigned zones do not have an auth header
         if (!inspectResult.m_generic_result.m_is_signed)
@@ -201,38 +201,38 @@ namespace
         // If file is signed setup a RSA instance.
         auto rsa = SetupRsa(inspectResult.m_generic_result.m_is_official, inspectResult.m_generic_result.m_variant_id);
 
-        zoneLoader.AddLoadingStep(step::CreateStepVerifyMagic(ZoneConstants::MAGIC_AUTH_HEADER));
-        zoneLoader.AddLoadingStep(step::CreateStepSkipBytes(4)); // Skip reserved
+        zoneReader.AddLoadingStep(step::CreateStepVerifyMagic(ZoneConstants::MAGIC_AUTH_HEADER));
+        zoneReader.AddLoadingStep(step::CreateStepSkipBytes(4)); // Skip reserved
 
         auto subHeaderHash = step::CreateStepLoadHash(sizeof(DB_AuthHash::bytes), 1);
         auto* subHeaderHashPtr = subHeaderHash.get();
-        zoneLoader.AddLoadingStep(std::move(subHeaderHash));
+        zoneReader.AddLoadingStep(std::move(subHeaderHash));
 
         auto subHeaderHashSignature = step::CreateStepLoadSignature(sizeof(DB_AuthSignature::bytes));
         auto* subHeaderHashSignaturePtr = subHeaderHashSignature.get();
-        zoneLoader.AddLoadingStep(std::move(subHeaderHashSignature));
+        zoneReader.AddLoadingStep(std::move(subHeaderHashSignature));
 
-        zoneLoader.AddLoadingStep(step::CreateStepVerifySignature(std::move(rsa), subHeaderHashSignaturePtr, subHeaderHashPtr));
+        zoneReader.AddLoadingStep(step::CreateStepVerifySignature(std::move(rsa), subHeaderHashSignaturePtr, subHeaderHashPtr));
 
         auto subHeaderCapture = processor::CreateProcessorCaptureData(sizeof(DB_AuthSubHeader));
         auto* subHeaderCapturePtr = subHeaderCapture.get();
-        zoneLoader.AddLoadingStep(step::CreateStepAddProcessor(std::move(subHeaderCapture)));
+        zoneReader.AddLoadingStep(step::CreateStepAddProcessor(std::move(subHeaderCapture)));
 
-        zoneLoader.AddLoadingStep(step::CreateStepVerifyFileName(fileName, sizeof(DB_AuthSubHeader::fastfileName)));
-        zoneLoader.AddLoadingStep(step::CreateStepSkipBytes(4)); // Skip reserved
+        zoneReader.AddLoadingStep(step::CreateStepVerifyFileName(fileName, sizeof(DB_AuthSubHeader::fastfileName)));
+        zoneReader.AddLoadingStep(step::CreateStepSkipBytes(4)); // Skip reserved
 
         auto masterBlockHashes =
             step::CreateStepLoadHash(sizeof(DB_AuthHash::bytes), static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>));
         auto* masterBlockHashesPtr = masterBlockHashes.get();
-        zoneLoader.AddLoadingStep(std::move(masterBlockHashes));
+        zoneReader.AddLoadingStep(std::move(masterBlockHashes));
 
-        zoneLoader.AddLoadingStep(step::CreateStepVerifyHash(cryptography::CreateSha256(), 0, subHeaderHashPtr, subHeaderCapturePtr));
-        zoneLoader.AddLoadingStep(step::CreateStepRemoveProcessor(subHeaderCapturePtr));
+        zoneReader.AddLoadingStep(step::CreateStepVerifyHash(cryptography::CreateSha256(), 0, subHeaderHashPtr, subHeaderCapturePtr));
+        zoneReader.AddLoadingStep(step::CreateStepRemoveProcessor(subHeaderCapturePtr));
 
         // Skip the rest of the first chunk
-        zoneLoader.AddLoadingStep(step::CreateStepSkipBytes(ZoneConstants::AUTHED_CHUNK_SIZE - sizeof(DB_AuthHeader)));
+        zoneReader.AddLoadingStep(step::CreateStepSkipBytes(ZoneConstants::AUTHED_CHUNK_SIZE - sizeof(DB_AuthHeader)));
 
-        zoneLoader.AddLoadingStep(step::CreateStepAddProcessor(
+        zoneReader.AddLoadingStep(step::CreateStepAddProcessor(
             processor::CreateProcessorAuthedBlocks(ZoneConstants::AUTHED_CHUNK_COUNT_PER_GROUP,
                                                    ZoneConstants::AUTHED_CHUNK_SIZE,
                                                    static_cast<unsigned>(std::extent_v<decltype(DB_AuthSubHeader::masterBlockHashes)>),
@@ -266,7 +266,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
@@ -296,7 +296,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     {
         // Start of the XFile struct
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
 
         // Start of the zone content
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
@@ -307,7 +307,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
             32u,
             ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
             ZoneConstants::INSERT_BLOCK,
-            zonePtr->Memory(),
+            zonePtr,
             std::move(progressCallback)));
     }
     else
diff --git a/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp b/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
index 4ebe6de8..4c1b84cb 100644
--- a/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
+++ b/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
@@ -32,19 +32,19 @@ using namespace IW5;
 
 namespace
 {
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -170,7 +170,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
@@ -188,7 +188,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
 
     // Start of the XFile struct
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
 
     // Start of the zone content
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
@@ -199,7 +199,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
         ZoneConstants::INSERT_BLOCK,
-        zonePtr->Memory(),
+        zonePtr,
         std::move(progressCallback)));
 
     return zoneLoader;
diff --git a/src/ZoneLoading/Game/QOS/ZoneLoaderFactoryQOS.cpp b/src/ZoneLoading/Game/QOS/ZoneLoaderFactoryQOS.cpp
index 8a3e20b7..f376fefb 100644
--- a/src/ZoneLoading/Game/QOS/ZoneLoaderFactoryQOS.cpp
+++ b/src/ZoneLoading/Game/QOS/ZoneLoaderFactoryQOS.cpp
@@ -21,15 +21,15 @@ namespace
 
     static_assert(REMAINING_FILE_HEADER_SIZE == sizeof(uint32_t) * 4u);
 
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(QOS::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -66,7 +66,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     zone->m_language = GameLanguage::LANGUAGE_NONE;
 
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeaderQos)));
@@ -74,7 +74,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // Maybe external data size?
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(4));
 
-    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
     zoneLoader->AddLoadingStep(step::CreateStepAddProcessor(processor::CreateProcessorInflate(ZoneConstants::AUTHED_CHUNK_SIZE)));
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
         [zonePtr](ZoneInputStream& stream)
@@ -84,7 +84,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
         ZoneConstants::INSERT_BLOCK,
-        zonePtr->Memory(),
+        zonePtr,
         std::move(progressCallback)));
 
     return zoneLoader;
diff --git a/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp
index 98f27c5f..877209c4 100644
--- a/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp
+++ b/src/ZoneLoading/Game/T4/ZoneLoaderFactoryT4.cpp
@@ -20,17 +20,17 @@ using namespace T4;
 
 namespace
 {
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -71,14 +71,14 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
 
     zoneLoader->AddLoadingStep(step::CreateStepAddProcessor(processor::CreateProcessorInflate(ZoneConstants::AUTHED_CHUNK_SIZE)));
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
         [zonePtr](ZoneInputStream& stream)
         {
@@ -87,7 +87,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
         ZoneConstants::INSERT_BLOCK,
-        zonePtr->Memory(),
+        zonePtr,
         std::move(progressCallback)));
 
     return zoneLoader;
diff --git a/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp b/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
index 80dc9a66..40456815 100644
--- a/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
+++ b/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
@@ -20,17 +20,17 @@ using namespace T5;
 
 namespace
 {
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -73,7 +73,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
@@ -82,7 +82,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
 
     // Start of the XFile struct
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+    zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
 
     // Start of the zone content
     zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
@@ -93,7 +93,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
         ZoneConstants::INSERT_BLOCK,
-        zonePtr->Memory(),
+        zonePtr,
         std::move(progressCallback)));
 
     return zoneLoader;
diff --git a/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp b/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
index 2e0a8869..fb5933c6 100644
--- a/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
+++ b/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
@@ -201,18 +201,18 @@ namespace
         return GameLanguage::LANGUAGE_NONE;
     }
 
-    void SetupBlock(ZoneLoader& zoneLoader)
+    void SetupBlock(ZoneMemory& zoneMemory)
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneMemory.AddBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -321,7 +321,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     // File is supported. Now setup all required steps for loading this file.
     auto zoneLoader = std::make_unique<ZoneLoader>(std::move(zone));
 
-    SetupBlock(*zoneLoader);
+    SetupBlock(zonePtr->Memory());
 
     // Skip the initial header that we peeked at before
     zoneLoader->AddLoadingStep(step::CreateStepSkipBytes(sizeof(ZoneHeader)));
@@ -339,7 +339,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
     {
         // Start of the XFile struct
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneSizes());
-        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks());
+        zoneLoader->AddLoadingStep(step::CreateStepAllocXBlocks(zonePtr));
 
         // Start of the zone content
         zoneLoader->AddLoadingStep(step::CreateStepLoadZoneContent(
@@ -350,7 +350,7 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneDataPee
             32u,
             ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
             ZoneConstants::INSERT_BLOCK,
-            zonePtr->Memory(),
+            zonePtr,
             std::move(progressCallback)));
 
         if (inspectResult->m_generic_result.m_is_signed)
diff --git a/src/ZoneLoading/Loading/ILoadingStep.h b/src/ZoneLoading/Loading/ILoadingStep.h
index dc2f402f..61ff12cd 100644
--- a/src/ZoneLoading/Loading/ILoadingStep.h
+++ b/src/ZoneLoading/Loading/ILoadingStep.h
@@ -3,7 +3,7 @@
 #include "ILoadingStream.h"
 #include "Loading/ZoneLoader.h"
 
-class ZoneLoader;
+class ZoneReader;
 
 class ILoadingStep
 {
@@ -15,5 +15,5 @@ public:
     ILoadingStep& operator=(const ILoadingStep& other) = default;
     ILoadingStep& operator=(ILoadingStep&& other) noexcept = default;
 
-    virtual void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) = 0;
+    virtual void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) = 0;
 };
diff --git a/src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp b/src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp
index 42483dcc..78d547e5 100644
--- a/src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp
@@ -12,11 +12,11 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             assert(m_stream_processor != nullptr);
 
-            zoneLoader.AddStreamProcessor(std::move(m_stream_processor));
+            zoneReader.AddStreamProcessor(std::move(m_stream_processor));
             m_stream_processor = nullptr;
         }
 
diff --git a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
index d2111d04..fe3e07a1 100644
--- a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
@@ -9,9 +9,15 @@ namespace
     class StepAllocXBlocks final : public ILoadingStep
     {
     public:
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        explicit StepAllocXBlocks(Zone* zone)
+            : m_zone(zone)
         {
-            const auto blockCount = static_cast<unsigned>(zoneLoader.m_blocks.size());
+        }
+
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
+        {
+            const auto& zoneMemory = m_zone->Memory();
+            const auto blockCount = static_cast<unsigned>(zoneMemory.GetBlockCount());
 
             std::vector<xblock_size_t> blockSizes(blockCount);
             stream.Load(blockSizes.data(), sizeof(xblock_size_t) * blockCount);
@@ -29,16 +35,19 @@ namespace
 
             for (unsigned int block = 0; block < blockCount; block++)
             {
-                zoneLoader.m_blocks[block]->Alloc(blockSizes[block]);
+                zoneMemory.GetBlock(block)->Alloc(blockSizes[block]);
             }
         }
+
+    private:
+        Zone* m_zone;
     };
 } // namespace
 
 namespace step
 {
-    std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks()
+    std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks(Zone* zone)
     {
-        return std::make_unique<StepAllocXBlocks>();
+        return std::make_unique<StepAllocXBlocks>(zone);
     }
 } // namespace step
diff --git a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h
index 0b280d2f..91ad420d 100644
--- a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h
+++ b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h
@@ -6,5 +6,5 @@
 
 namespace step
 {
-    std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks();
+    std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks(Zone* zone);
 }
diff --git a/src/ZoneLoading/Loading/Steps/StepDumpData.cpp b/src/ZoneLoading/Loading/Steps/StepDumpData.cpp
index 906fce4b..d482d28a 100644
--- a/src/ZoneLoading/Loading/Steps/StepDumpData.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepDumpData.cpp
@@ -13,7 +13,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             uint8_t tempBuffer[0x1000];
             auto dumpedBytes = 0uz;
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadHash.cpp b/src/ZoneLoading/Loading/Steps/StepLoadHash.cpp
index 750f6cac..079399b7 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadHash.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepLoadHash.cpp
@@ -16,7 +16,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             if (stream.Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
                 throw UnexpectedEndOfFileException();
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp b/src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp
index 789c61ac..c252ce62 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp
@@ -15,7 +15,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             if (stream.Load(m_signature.get(), m_signature_size) != m_signature_size)
                 throw UnexpectedEndOfFileException();
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
index b4cbfb82..c82a35af 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
@@ -11,21 +11,28 @@ namespace
                             const unsigned pointerBitCount,
                             const unsigned offsetBlockBitCount,
                             const block_t insertBlock,
-                            MemoryManager& memory,
+                            Zone* zone,
                             std::optional<std::unique_ptr<ProgressCallback>> progressCallback)
             : m_entry_point_factory(std::move(entryPointFactory)),
               m_pointer_bit_count(pointerBitCount),
               m_offset_block_bit_count(offsetBlockBitCount),
               m_insert_block(insertBlock),
-              m_memory(memory),
+              m_zone(zone),
               m_progress_callback(std::move(progressCallback))
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
+            const auto& zoneMemory = m_zone->Memory();
+            const auto blockCount = zoneMemory.GetBlockCount();
+            m_blocks = std::vector<XBlock*>();
+            m_blocks.reserve(blockCount);
+            for (size_t i = 0; i < blockCount; ++i)
+                m_blocks.emplace_back(zoneMemory.GetBlock(i));
+
             const auto inputStream = ZoneInputStream::Create(
-                m_pointer_bit_count, m_offset_block_bit_count, zoneLoader.m_blocks, m_insert_block, stream, m_memory, std::move(m_progress_callback));
+                m_pointer_bit_count, m_offset_block_bit_count, m_blocks, m_insert_block, stream, m_zone->Memory(), std::move(m_progress_callback));
 
             const auto entryPoint = m_entry_point_factory(*inputStream);
             assert(entryPoint);
@@ -38,7 +45,8 @@ namespace
         unsigned m_pointer_bit_count;
         unsigned m_offset_block_bit_count;
         block_t m_insert_block;
-        MemoryManager& m_memory;
+        Zone* m_zone;
+        std::vector<XBlock*> m_blocks;
         std::optional<std::unique_ptr<ProgressCallback>> m_progress_callback;
     };
 } // namespace
@@ -49,10 +57,10 @@ namespace step
                                                             const unsigned pointerBitCount,
                                                             const unsigned offsetBlockBitCount,
                                                             const block_t insertBlock,
-                                                            MemoryManager& memory,
+                                                            Zone* zone,
                                                             std::optional<std::unique_ptr<ProgressCallback>> progressCallback)
     {
         return std::make_unique<StepLoadZoneContent>(
-            std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock, memory, std::move(progressCallback));
+            std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock, zone, std::move(progressCallback));
     }
 } // namespace step
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
index f832f1dd..52bc6ee9 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
+++ b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
@@ -13,6 +13,6 @@ namespace step
                                                             unsigned pointerBitCount,
                                                             unsigned offsetBlockBitCount,
                                                             block_t insertBlock,
-                                                            MemoryManager& memory,
+                                                            Zone* zone,
                                                             std::optional<std::unique_ptr<ProgressCallback>> progressCallback);
 }
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp b/src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp
index 6cd9abec..ab8935e7 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp
@@ -11,7 +11,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             stream.Load(&m_size, sizeof(m_size));
             stream.Load(&m_external_size, sizeof(m_external_size));
diff --git a/src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp b/src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp
index dee13b8b..3966a2aa 100644
--- a/src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp
@@ -12,11 +12,11 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             assert(m_stream_processor != nullptr);
 
-            zoneLoader.RemoveStreamProcessor(m_stream_processor);
+            zoneReader.RemoveStreamProcessor(m_stream_processor);
         }
 
     private:
diff --git a/src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp b/src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp
index b2874f54..0be59998 100644
--- a/src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp
@@ -10,7 +10,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             uint8_t tempBuffer[128];
             auto skippedBytes = 0uz;
diff --git a/src/ZoneLoading/Loading/Steps/StepSkipZoneImageHeaders.cpp b/src/ZoneLoading/Loading/Steps/StepSkipZoneImageHeaders.cpp
index 89d002d9..dccf3fec 100644
--- a/src/ZoneLoading/Loading/Steps/StepSkipZoneImageHeaders.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepSkipZoneImageHeaders.cpp
@@ -11,9 +11,8 @@ namespace
     class StepSkipZoneImageHeaders final : public ILoadingStep
     {
     public:
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
-
             // Xbox fastfiles have additional header data before the auth header:
             // - 4 bytes: language flags bitmask
             // - 4 bytes: image count
diff --git a/src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp b/src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp
index 98962132..a851b668 100644
--- a/src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp
@@ -17,7 +17,7 @@ namespace
                 m_expected_file_name.erase(m_file_name_buffer_size - 1);
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             std::stringstream originalFilenameStream;
             unsigned bufferOffset = 0;
diff --git a/src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp b/src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp
index 41887c8b..ee7d78d7 100644
--- a/src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp
@@ -21,7 +21,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             const uint8_t* dataToHash = nullptr;
             size_t dataToHashSize = 0;
diff --git a/src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp b/src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp
index 4827db28..dade9a89 100644
--- a/src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp
@@ -15,7 +15,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             char currentCharacter;
 
diff --git a/src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp b/src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp
index 6fb7780f..3f5ca8f0 100644
--- a/src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp
@@ -18,7 +18,7 @@ namespace
         {
         }
 
-        void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
+        void PerformStep(ZoneReader& zoneReader, ILoadingStream& stream) override
         {
             assert(m_algorithm != nullptr);
             assert(m_signature_provider != nullptr);
diff --git a/src/ZoneLoading/Loading/ZoneLoader.cpp b/src/ZoneLoading/Loading/ZoneLoader.cpp
index a97f6c6f..f19803bd 100644
--- a/src/ZoneLoading/Loading/ZoneLoader.cpp
+++ b/src/ZoneLoading/Loading/ZoneLoader.cpp
@@ -7,54 +7,24 @@
 #include <algorithm>
 #include <cassert>
 #include <format>
-#include <iostream>
 
-ZoneLoader::ZoneLoader(std::unique_ptr<Zone> zone)
-    : m_processor_chain_dirty(false),
-      m_zone(std::move(zone))
+ZoneReader::ZoneReader()
+    : m_processor_chain_dirty(false)
 {
 }
 
-ILoadingStream* ZoneLoader::BuildLoadingChain(ILoadingStream* rootStream)
-{
-    auto* currentStream = rootStream;
-
-    for (const auto& processor : m_processors)
-    {
-        processor->SetBaseStream(currentStream);
-
-        currentStream = processor.get();
-    }
-
-    m_processor_chain_dirty = false;
-    return currentStream;
-}
-
-void ZoneLoader::AddXBlock(std::unique_ptr<XBlock> block)
-{
-    m_blocks.push_back(block.get());
-
-    std::ranges::sort(m_blocks,
-                      [](const XBlock* b1, const XBlock* b2) -> bool
-                      {
-                          return b1->m_index < b2->m_index;
-                      });
-
-    m_zone->Memory().AddBlock(std::move(block));
-}
-
-void ZoneLoader::AddLoadingStep(std::unique_ptr<ILoadingStep> step)
+void ZoneReader::AddLoadingStep(std::unique_ptr<ILoadingStep> step)
 {
     m_steps.emplace_back(std::move(step));
 }
 
-void ZoneLoader::AddStreamProcessor(std::unique_ptr<StreamProcessor> streamProcessor)
+void ZoneReader::AddStreamProcessor(std::unique_ptr<StreamProcessor> streamProcessor)
 {
     m_processors.push_back(std::move(streamProcessor));
     m_processor_chain_dirty = true;
 }
 
-void ZoneLoader::RemoveStreamProcessor(const StreamProcessor* streamProcessor)
+void ZoneReader::RemoveStreamProcessor(const StreamProcessor* streamProcessor)
 {
     for (auto i = m_processors.begin(); i < m_processors.end(); ++i)
     {
@@ -67,7 +37,7 @@ void ZoneLoader::RemoveStreamProcessor(const StreamProcessor* streamProcessor)
     }
 }
 
-std::unique_ptr<Zone> ZoneLoader::LoadZone(std::istream& stream)
+bool ZoneReader::Run(std::istream& stream)
 {
     LoadingFileStream fileStream(stream);
     auto* endStream = BuildLoadingChain(&fileStream);
@@ -90,9 +60,37 @@ std::unique_ptr<Zone> ZoneLoader::LoadZone(std::istream& stream)
     {
         con::error("Loading fastfile failed: {}", e.DetailedMessage());
 
-        return nullptr;
+        return false;
     }
 
+    return true;
+}
+
+ILoadingStream* ZoneReader::BuildLoadingChain(ILoadingStream* rootStream)
+{
+    auto* currentStream = rootStream;
+
+    for (const auto& processor : m_processors)
+    {
+        processor->SetBaseStream(currentStream);
+
+        currentStream = processor.get();
+    }
+
+    m_processor_chain_dirty = false;
+    return currentStream;
+}
+
+ZoneLoader::ZoneLoader(std::unique_ptr<Zone> zone)
+    : m_zone(std::move(zone))
+{
+}
+
+std::unique_ptr<Zone> ZoneLoader::LoadZone(std::istream& stream)
+{
+    if (!Run(stream))
+        return nullptr;
+
     m_zone->Register();
 
     return std::move(m_zone);
diff --git a/src/ZoneLoading/Loading/ZoneLoader.h b/src/ZoneLoading/Loading/ZoneLoader.h
index ddce977e..3bc3bc8a 100644
--- a/src/ZoneLoading/Loading/ZoneLoader.h
+++ b/src/ZoneLoading/Loading/ZoneLoader.h
@@ -2,7 +2,6 @@
 
 #include "ILoadingStep.h"
 #include "StreamProcessor.h"
-#include "Zone/XBlock.h"
 #include "Zone/Zone.h"
 
 #include <istream>
@@ -11,28 +10,34 @@
 
 class ILoadingStep;
 
-class ZoneLoader
+class ZoneReader
 {
 public:
-    explicit ZoneLoader(std::unique_ptr<Zone> zone);
+    ZoneReader();
 
-    void AddXBlock(std::unique_ptr<XBlock> block);
     void AddLoadingStep(std::unique_ptr<ILoadingStep> step);
     void AddStreamProcessor(std::unique_ptr<StreamProcessor> streamProcessor);
 
     void RemoveStreamProcessor(const StreamProcessor* streamProcessor);
 
-    std::unique_ptr<Zone> LoadZone(std::istream& stream);
+    bool Run(std::istream& stream);
 
-    std::vector<XBlock*> m_blocks;
-
-private:
+protected:
     ILoadingStream* BuildLoadingChain(ILoadingStream* rootStream);
 
     std::vector<std::unique_ptr<ILoadingStep>> m_steps;
     std::vector<std::unique_ptr<StreamProcessor>> m_processors;
 
     bool m_processor_chain_dirty;
+};
 
+class ZoneLoader : public ZoneReader
+{
+public:
+    explicit ZoneLoader(std::unique_ptr<Zone> zone);
+
+    std::unique_ptr<Zone> LoadZone(std::istream& stream);
+
+private:
     std::unique_ptr<Zone> m_zone;
 };