std::span -> eastl::spansb/eastl

15 files changed, 94 insertions, 94 deletions

diff --git a/src/zenutil/cache/cachepolicy.cpp b/src/zenutil/cache/cachepolicy.cpp
index 8bfb11a30..0b3551d38 100644
--- a/src/zenutil/cache/cachepolicy.cpp
+++ b/src/zenutil/cache/cachepolicy.cpp
@@ -163,7 +163,7 @@ public:
 		Values.insert(Insert, Value);
 	}
 
-	inline std::span<const CacheValuePolicy> GetValuePolicies() const final { return Values; }
+	inline eastl::span<const CacheValuePolicy> GetValuePolicies() const final { return Values; }
 
 private:
 	eastl::vector<CacheValuePolicy> Values;
@@ -174,8 +174,8 @@ CacheRecordPolicy::GetValuePolicy(const Oid& Id) const
 {
 	if (Shared)
 	{
-		const std::span<const CacheValuePolicy> Values = Shared->GetValuePolicies();
-		const auto								Iter =
+		const eastl::span<const CacheValuePolicy> Values = Shared->GetValuePolicies();
+		const auto								  Iter =
 			std::lower_bound(Values.begin(), Values.end(), Id, [](const CacheValuePolicy& A, const Oid& B) { return A.Id < B; });
 		if (Iter != Values.end() && Iter->Id == Id)
 		{
@@ -272,8 +272,8 @@ CacheRecordPolicyBuilder::Build()
 		const auto Add = [](const CachePolicy A, const CachePolicy B) {
 			return ((A | B) & ~CachePolicy::SkipData) | ((A & B) & CachePolicy::SkipData);
 		};
-		const std::span<const CacheValuePolicy> Values = Shared->GetValuePolicies();
-		Policy.RecordPolicy							   = BasePolicy;
+		const eastl::span<const CacheValuePolicy> Values = Shared->GetValuePolicies();
+		Policy.RecordPolicy								 = BasePolicy;
 		for (const CacheValuePolicy& ValuePolicy : Values)
 		{
 			Policy.RecordPolicy = Add(Policy.RecordPolicy, ValuePolicy.Policy);
diff --git a/src/zenutil/cache/cacherequests.cpp b/src/zenutil/cache/cacherequests.cpp
index 9b999304e..d5bc994c1 100644
--- a/src/zenutil/cache/cacherequests.cpp
+++ b/src/zenutil/cache/cacherequests.cpp
@@ -368,7 +368,7 @@ namespace cacherequests {
 
 	bool GetCacheRecordsRequest::Parse(const CbPackage& RpcRequest) { return Parse(RpcRequest.GetObject()); }
 
-	bool GetCacheRecordsRequest::Format(CbObjectWriter& Writer, const std::span<const size_t> OptionalRecordFilter) const
+	bool GetCacheRecordsRequest::Format(CbObjectWriter& Writer, const eastl::span<const size_t> OptionalRecordFilter) const
 	{
 		Writer << "Method"
 			   << "GetCacheRecords";
@@ -422,7 +422,7 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool GetCacheRecordsRequest::Format(CbPackage& OutPackage, const std::span<const size_t> OptionalRecordFilter) const
+	bool GetCacheRecordsRequest::Format(CbPackage& OutPackage, const eastl::span<const size_t> OptionalRecordFilter) const
 	{
 		CbObjectWriter Writer;
 		if (!Format(Writer, OptionalRecordFilter))
@@ -433,7 +433,7 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool GetCacheRecordsResult::Parse(const CbPackage& Package, const std::span<const size_t> OptionalRecordResultIndexes)
+	bool GetCacheRecordsResult::Parse(const CbPackage& Package, const eastl::span<const size_t> OptionalRecordResultIndexes)
 	{
 		CbObject	ResponseObject = Package.GetObject();
 		CbArrayView ResultsArray   = ResponseObject["Result"].AsArrayView();
@@ -700,7 +700,7 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool GetCacheValuesRequest::Format(CbPackage& OutPackage, const std::span<const size_t> OptionalValueFilter) const
+	bool GetCacheValuesRequest::Format(CbPackage& OutPackage, const eastl::span<const size_t> OptionalValueFilter) const
 	{
 		CbObjectWriter Writer;
 		Writer << "Method"
@@ -757,7 +757,7 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool CacheValuesResult::Parse(const CbPackage& Package, const std::span<const size_t> OptionalValueResultIndexes)
+	bool CacheValuesResult::Parse(const CbPackage& Package, const eastl::span<const size_t> OptionalValueResultIndexes)
 	{
 		CbObject	ResponseObject = Package.GetObject();
 		CbArrayView ResultsArray   = ResponseObject["Result"].AsArrayView();
@@ -1090,7 +1090,7 @@ namespace cacherequests {
 		return (Lhs.Id == Rhs.Id) && (Lhs.Policy == Rhs.Policy);
 	}
 
-	static bool operator==(const std::span<const zen::CacheValuePolicy>& Lhs, const std::span<const zen::CacheValuePolicy>& Rhs)
+	static bool operator==(const eastl::span<const zen::CacheValuePolicy>& Lhs, const eastl::span<const zen::CacheValuePolicy>& Rhs)
 	{
 		if (Lhs.size() != Lhs.size())
 		{
diff --git a/src/zenutil/chunkblock.cpp b/src/zenutil/chunkblock.cpp
index 6c8ed43cc..2606963e7 100644
--- a/src/zenutil/chunkblock.cpp
+++ b/src/zenutil/chunkblock.cpp
@@ -164,7 +164,7 @@ GenerateChunkBlock(eastl::vector<std::pair<IoHash, FetchChunkFunc>>&& FetchChunk
 		{
 			std::pair<uint64_t, CompressedBuffer> Chunk		= It.second(It.first);
 			uint64_t							  ChunkSize = 0;
-			std::span<const SharedBuffer>		  Segments	= Chunk.second.GetCompressed().GetSegments();
+			eastl::span<const SharedBuffer>		  Segments	= Chunk.second.GetCompressed().GetSegments();
 			for (const SharedBuffer& Segment : Segments)
 			{
 				ZEN_ASSERT(Segment.IsOwned());
diff --git a/src/zenutil/chunkedcontent.cpp b/src/zenutil/chunkedcontent.cpp
index 13b8dd0d2..351e2837e 100644
--- a/src/zenutil/chunkedcontent.cpp
+++ b/src/zenutil/chunkedcontent.cpp
@@ -28,9 +28,9 @@ namespace {
 						  ChunkedContentData&								InOutChunkedContent,
 						  tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& ChunkHashToChunkIndex,
 						  const IoHash&										RawHash,
-						  std::span<const uint32_t>							ChunkSequence,
-						  std::span<const IoHash>							ChunkHashes,
-						  std::span<const uint64_t>							ChunkRawSizes)
+						  eastl::span<const uint32_t>						ChunkSequence,
+						  eastl::span<const IoHash>							ChunkHashes,
+						  eastl::span<const uint64_t>						ChunkRawSizes)
 	{
 		ZEN_ASSERT(ChunkHashes.size() == ChunkRawSizes.size());
 		InOutChunkedContent.ChunkCounts.push_back(gsl::narrow<uint32_t>(ChunkSequence.size()));
@@ -529,7 +529,7 @@ LoadChunkedFolderContentToCompactBinary(CbObjectView Input)
 }
 
 ChunkedFolderContent
-MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const ChunkedFolderContent> Overlays)
+MergeChunkedFolderContents(const ChunkedFolderContent& Base, eastl::span<const ChunkedFolderContent> Overlays)
 {
 	ZEN_TRACE_CPU("MergeChunkedFolderContents");
 
@@ -564,7 +564,7 @@ MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const Chu
 
 	tsl::robin_map<IoHash, uint32_t, IoHash::Hasher> RawHashToSequenceRawHashIndex;
 
-	auto BuildOverlayPaths = [](std::span<const ChunkedFolderContent> Overlays) -> tsl::robin_set<std::string> {
+	auto BuildOverlayPaths = [](eastl::span<const ChunkedFolderContent> Overlays) -> tsl::robin_set<std::string> {
 		tsl::robin_set<std::string> Result;
 		for (const ChunkedFolderContent& OverlayContent : Overlays)
 		{
@@ -581,7 +581,7 @@ MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const Chu
 										   tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>&		 ChunkHashToChunkIndex,
 										   tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>&		 RawHashToSequenceRawHashIndex,
 										   const tsl::robin_map<std::string, std::filesystem::path>& GenericPathToActualPath,
-										   std::span<const ChunkedFolderContent>					 Overlays) {
+										   eastl::span<const ChunkedFolderContent>					 Overlays) {
 		const ChunkedContentLookup	OverlayLookup	 = BuildChunkedContentLookup(OverlayContent);
 		tsl::robin_set<std::string> BaseOverlayPaths = BuildOverlayPaths(Overlays);
 		for (uint32_t PathIndex = 0; PathIndex < OverlayContent.Paths.size(); PathIndex++)
@@ -604,12 +604,12 @@ MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const Chu
 					{
 						RawHashToSequenceRawHashIndex.insert(
 							{RawHash, gsl::narrow<uint32_t>(Result.ChunkedContent.SequenceRawHashes.size())});
-						const uint32_t			  SequenceRawHashIndex = OverlayLookup.RawHashToSequenceIndex.at(RawHash);
-						const uint32_t			  OrderIndexOffset	   = OverlayLookup.SequenceIndexChunkOrderOffset[SequenceRawHashIndex];
-						const uint32_t			  ChunkCount		   = OverlayContent.ChunkedContent.ChunkCounts[SequenceRawHashIndex];
-						ChunkingStatistics		  Stats;
-						std::span<const uint32_t> OriginalChunkOrder =
-							std::span<const uint32_t>(OverlayContent.ChunkedContent.ChunkOrders).subspan(OrderIndexOffset, ChunkCount);
+						const uint32_t				SequenceRawHashIndex = OverlayLookup.RawHashToSequenceIndex.at(RawHash);
+						const uint32_t				OrderIndexOffset = OverlayLookup.SequenceIndexChunkOrderOffset[SequenceRawHashIndex];
+						const uint32_t				ChunkCount		 = OverlayContent.ChunkedContent.ChunkCounts[SequenceRawHashIndex];
+						ChunkingStatistics			Stats;
+						eastl::span<const uint32_t> OriginalChunkOrder =
+							eastl::span<const uint32_t>(OverlayContent.ChunkedContent.ChunkOrders).subspan(OrderIndexOffset, ChunkCount);
 						AddChunkSequence(Stats,
 										 Result.ChunkedContent,
 										 ChunkHashToChunkIndex,
@@ -639,7 +639,7 @@ MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const Chu
 }
 
 ChunkedFolderContent
-DeletePathsFromChunkedContent(const ChunkedFolderContent& BaseContent, std::span<const std::filesystem::path> DeletedPaths)
+DeletePathsFromChunkedContent(const ChunkedFolderContent& BaseContent, eastl::span<const std::filesystem::path> DeletedPaths)
 {
 	ZEN_TRACE_CPU("DeletePathsFromChunkedContent");
 
@@ -674,12 +674,12 @@ DeletePathsFromChunkedContent(const ChunkedFolderContent& BaseContent, std::span
 					{
 						RawHashToSequenceRawHashIndex.insert(
 							{RawHash, gsl::narrow<uint32_t>(Result.ChunkedContent.SequenceRawHashes.size())});
-						const uint32_t			  SequenceRawHashIndex = BaseLookup.RawHashToSequenceIndex.at(RawHash);
-						const uint32_t			  OrderIndexOffset	   = BaseLookup.SequenceIndexChunkOrderOffset[SequenceRawHashIndex];
-						const uint32_t			  ChunkCount		   = BaseContent.ChunkedContent.ChunkCounts[SequenceRawHashIndex];
-						ChunkingStatistics		  Stats;
-						std::span<const uint32_t> OriginalChunkOrder =
-							std::span<const uint32_t>(BaseContent.ChunkedContent.ChunkOrders).subspan(OrderIndexOffset, ChunkCount);
+						const uint32_t				SequenceRawHashIndex = BaseLookup.RawHashToSequenceIndex.at(RawHash);
+						const uint32_t				OrderIndexOffset	 = BaseLookup.SequenceIndexChunkOrderOffset[SequenceRawHashIndex];
+						const uint32_t				ChunkCount			 = BaseContent.ChunkedContent.ChunkCounts[SequenceRawHashIndex];
+						ChunkingStatistics			Stats;
+						eastl::span<const uint32_t> OriginalChunkOrder =
+							eastl::span<const uint32_t>(BaseContent.ChunkedContent.ChunkOrders).subspan(OrderIndexOffset, ChunkCount);
 						AddChunkSequence(Stats,
 										 Result.ChunkedContent,
 										 ChunkHashToChunkIndex,
diff --git a/src/zenutil/chunkingcontroller.cpp b/src/zenutil/chunkingcontroller.cpp
index bdc030f2c..9e2f87d50 100644
--- a/src/zenutil/chunkingcontroller.cpp
+++ b/src/zenutil/chunkingcontroller.cpp
@@ -39,9 +39,9 @@ namespace {
 class BasicChunkingController : public ChunkingController
 {
 public:
-	BasicChunkingController(std::span<const std::string_view> ExcludeExtensions,
-							uint64_t						  ChunkFileSizeLimit,
-							const ChunkedParams&			  ChunkingParams)
+	BasicChunkingController(eastl::span<const std::string_view> ExcludeExtensions,
+							uint64_t							ChunkFileSizeLimit,
+							const ChunkedParams&				ChunkingParams)
 	: m_ChunkExcludeExtensions(ExcludeExtensions.begin(), ExcludeExtensions.end())
 	, m_ChunkFileSizeLimit(ChunkFileSizeLimit)
 	, m_ChunkingParams(ChunkingParams)
@@ -111,10 +111,10 @@ protected:
 class ChunkingControllerWithFixedChunking : public ChunkingController
 {
 public:
-	ChunkingControllerWithFixedChunking(std::span<const std::string_view> FixedChunkingExtensions,
-										uint64_t						  ChunkFileSizeLimit,
-										const ChunkedParams&			  ChunkingParams,
-										uint32_t						  FixedChunkingChunkSize)
+	ChunkingControllerWithFixedChunking(eastl::span<const std::string_view> FixedChunkingExtensions,
+										uint64_t							ChunkFileSizeLimit,
+										const ChunkedParams&				ChunkingParams,
+										uint32_t							FixedChunkingChunkSize)
 	: m_FixedChunkingExtensions(FixedChunkingExtensions.begin(), FixedChunkingExtensions.end())
 	, m_ChunkFileSizeLimit(ChunkFileSizeLimit)
 	, m_ChunkingParams(ChunkingParams)
@@ -225,9 +225,9 @@ protected:
 };
 
 std::unique_ptr<ChunkingController>
-CreateBasicChunkingController(std::span<const std::string_view> ExcludeExtensions,
-							  uint64_t							ChunkFileSizeLimit,
-							  const ChunkedParams&				ChunkingParams)
+CreateBasicChunkingController(eastl::span<const std::string_view> ExcludeExtensions,
+							  uint64_t							  ChunkFileSizeLimit,
+							  const ChunkedParams&				  ChunkingParams)
 {
 	return std::make_unique<BasicChunkingController>(ExcludeExtensions, ChunkFileSizeLimit, ChunkingParams);
 }
@@ -238,10 +238,10 @@ CreateBasicChunkingController(CbObjectView Parameters)
 }
 
 std::unique_ptr<ChunkingController>
-CreateChunkingControllerWithFixedChunking(std::span<const std::string_view> FixedChunkingExtensions,
-										  uint64_t							ChunkFileSizeLimit,
-										  const ChunkedParams&				ChunkingParams,
-										  uint32_t							FixedChunkingChunkSize)
+CreateChunkingControllerWithFixedChunking(eastl::span<const std::string_view> FixedChunkingExtensions,
+										  uint64_t							  ChunkFileSizeLimit,
+										  const ChunkedParams&				  ChunkingParams,
+										  uint32_t							  FixedChunkingChunkSize)
 {
 	return std::make_unique<ChunkingControllerWithFixedChunking>(FixedChunkingExtensions,
 																 ChunkFileSizeLimit,
diff --git a/src/zenutil/chunkrequests.cpp b/src/zenutil/chunkrequests.cpp
index 49ac9e2f5..ccbe06888 100644
--- a/src/zenutil/chunkrequests.cpp
+++ b/src/zenutil/chunkrequests.cpp
@@ -79,7 +79,7 @@ ParseChunkBatchRequest(const IoBuffer& Payload)
 }
 
 eastl::vector<IoBuffer>
-BuildChunkBatchResponse(const eastl::vector<RequestChunkEntry>& Requests, std::span<IoBuffer> Chunks)
+BuildChunkBatchResponse(const eastl::vector<RequestChunkEntry>& Requests, eastl::span<IoBuffer> Chunks)
 {
 	ZEN_ASSERT(Requests.size() == Chunks.size());
 	size_t ChunkCount = Requests.size();
diff --git a/src/zenutil/filebuildstorage.cpp b/src/zenutil/filebuildstorage.cpp
index 37bf82afe..cee9cbfc4 100644
--- a/src/zenutil/filebuildstorage.cpp
+++ b/src/zenutil/filebuildstorage.cpp
@@ -450,7 +450,7 @@ public:
 		return Result;
 	}
 
-	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, std::span<const IoHash> BlockHashes) override
+	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, eastl::span<const IoHash> BlockHashes) override
 	{
 		ZEN_UNUSED(BuildId);
 		SimulateLatency(0, 0);
diff --git a/src/zenutil/include/zenutil/buildstorage.h b/src/zenutil/include/zenutil/buildstorage.h
index 5eddd2da7..7b88b355e 100644
--- a/src/zenutil/include/zenutil/buildstorage.h
+++ b/src/zenutil/include/zenutil/buildstorage.h
@@ -47,9 +47,9 @@ public:
 		uint64_t																			   ChunkSize,
 		std::function<void(uint64_t Offset, const IoBuffer& Chunk, uint64_t BytesRemaining)>&& Receiver) = 0;
 
-	virtual void PutBlockMetadata(const Oid& BuildId, const IoHash& BlockRawHash, const CbObject& MetaData)				   = 0;
-	virtual eastl::vector<ChunkBlockDescription> FindBlocks(const Oid& BuildId)											   = 0;
-	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, std::span<const IoHash> BlockHashes) = 0;
+	virtual void PutBlockMetadata(const Oid& BuildId, const IoHash& BlockRawHash, const CbObject& MetaData)					 = 0;
+	virtual eastl::vector<ChunkBlockDescription> FindBlocks(const Oid& BuildId)												 = 0;
+	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, eastl::span<const IoHash> BlockHashes) = 0;
 };
 
 }  // namespace zen
diff --git a/src/zenutil/include/zenutil/cache/cachepolicy.h b/src/zenutil/include/zenutil/cache/cachepolicy.h
index 7773cd3d1..b68be18ce 100644
--- a/src/zenutil/include/zenutil/cache/cachepolicy.h
+++ b/src/zenutil/include/zenutil/cache/cachepolicy.h
@@ -8,8 +8,8 @@
 #include <zencore/string.h>
 #include <zencore/uid.h>
 
+#include <EASTL/span.h>
 #include <gsl/gsl-lite.hpp>
-#include <span>
 namespace zen::Private {
 class ICacheRecordPolicyShared;
 }
@@ -104,9 +104,9 @@ struct CacheValuePolicy
 class Private::ICacheRecordPolicyShared : public RefCounted
 {
 public:
-	virtual ~ICacheRecordPolicyShared()														 = default;
-	virtual void							  AddValuePolicy(const CacheValuePolicy& Policy) = 0;
-	virtual std::span<const CacheValuePolicy> GetValuePolicies() const						 = 0;
+	virtual ~ICacheRecordPolicyShared()														   = default;
+	virtual void								AddValuePolicy(const CacheValuePolicy& Policy) = 0;
+	virtual eastl::span<const CacheValuePolicy> GetValuePolicies() const					   = 0;
 };
 
 /**
@@ -144,9 +144,9 @@ public:
 	CachePolicy GetValuePolicy(const Oid& Id) const;
 
 	/** Returns the array of cache policy overrides for values, sorted by ID. */
-	inline std::span<const CacheValuePolicy> GetValuePolicies() const
+	inline eastl::span<const CacheValuePolicy> GetValuePolicies() const
 	{
-		return Shared ? Shared->GetValuePolicies() : std::span<const CacheValuePolicy>();
+		return Shared ? Shared->GetValuePolicies() : eastl::span<const CacheValuePolicy>();
 	}
 
 	/** Saves the cache record policy to a compact binary object. */
diff --git a/src/zenutil/include/zenutil/cache/cacherequests.h b/src/zenutil/include/zenutil/cache/cacherequests.h
index 351245d75..4a9e46399 100644
--- a/src/zenutil/include/zenutil/cache/cacherequests.h
+++ b/src/zenutil/include/zenutil/cache/cacherequests.h
@@ -115,8 +115,8 @@ namespace cacherequests {
 
 		bool Parse(const CbPackage& RpcRequest);
 		bool Parse(const CbObjectView& RpcRequest);
-		bool Format(CbPackage& OutPackage, const std::span<const size_t> OptionalRecordFilter = {}) const;
-		bool Format(CbObjectWriter& Writer, const std::span<const size_t> OptionalRecordFilter = {}) const;
+		bool Format(CbPackage& OutPackage, const eastl::span<const size_t> OptionalRecordFilter = {}) const;
+		bool Format(CbObjectWriter& Writer, const eastl::span<const size_t> OptionalRecordFilter = {}) const;
 	};
 
 	struct GetCacheRecordResultValue
@@ -137,7 +137,7 @@ namespace cacherequests {
 	{
 		eastl::vector<std::optional<GetCacheRecordResult>> Results;
 
-		bool Parse(const CbPackage& Package, const std::span<const size_t> OptionalRecordResultIndexes = {});
+		bool Parse(const CbPackage& Package, const eastl::span<const size_t> OptionalRecordResultIndexes = {});
 		bool Format(CbPackage& OutPackage) const;
 	};
 
@@ -190,7 +190,7 @@ namespace cacherequests {
 		eastl::vector<GetCacheValueRequest> Requests;
 
 		bool Parse(const CbObjectView& BatchObject);
-		bool Format(CbPackage& OutPackage, const std::span<const size_t> OptionalValueFilter = {}) const;
+		bool Format(CbPackage& OutPackage, const eastl::span<const size_t> OptionalValueFilter = {}) const;
 	};
 
 	struct CacheValueResult
@@ -206,7 +206,7 @@ namespace cacherequests {
 	{
 		eastl::vector<CacheValueResult> Results;
 
-		bool Parse(const CbPackage& Package, const std::span<const size_t> OptionalValueResultIndexes = {});
+		bool Parse(const CbPackage& Package, const eastl::span<const size_t> OptionalValueResultIndexes = {});
 		bool Format(CbPackage& OutPackage) const;
 	};
 
diff --git a/src/zenutil/include/zenutil/chunkedcontent.h b/src/zenutil/include/zenutil/chunkedcontent.h
index 931127c6d..e6ec13179 100644
--- a/src/zenutil/include/zenutil/chunkedcontent.h
+++ b/src/zenutil/include/zenutil/chunkedcontent.h
@@ -97,8 +97,8 @@ struct ChunkedFolderContent
 void				 SaveChunkedFolderContentToCompactBinary(const ChunkedFolderContent& Content, CbWriter& Output);
 ChunkedFolderContent LoadChunkedFolderContentToCompactBinary(CbObjectView Input);
 
-ChunkedFolderContent MergeChunkedFolderContents(const ChunkedFolderContent& Base, std::span<const ChunkedFolderContent> Overlays);
-ChunkedFolderContent DeletePathsFromChunkedContent(const ChunkedFolderContent& Base, std::span<const std::filesystem::path> DeletedPaths);
+ChunkedFolderContent MergeChunkedFolderContents(const ChunkedFolderContent& Base, eastl::span<const ChunkedFolderContent> Overlays);
+ChunkedFolderContent DeletePathsFromChunkedContent(const ChunkedFolderContent& Base, eastl::span<const std::filesystem::path> DeletedPaths);
 
 struct ChunkingStatistics
 {
@@ -146,11 +146,11 @@ GetChunkSequenceLocationRange(const ChunkedContentLookup& Lookup, uint32_t Chunk
 	return std::make_pair(Lookup.ChunkSequenceLocationOffset[ChunkIndex], Lookup.ChunkSequenceLocationCounts[ChunkIndex]);
 }
 
-inline std::span<const ChunkedContentLookup::ChunkSequenceLocation>
+inline eastl::span<const ChunkedContentLookup::ChunkSequenceLocation>
 GetChunkSequenceLocations(const ChunkedContentLookup& Lookup, uint32_t ChunkIndex)
 {
 	std::pair<size_t, uint32_t> Range = GetChunkSequenceLocationRange(Lookup, ChunkIndex);
-	return std::span<const ChunkedContentLookup::ChunkSequenceLocation>(Lookup.ChunkSequenceLocations).subspan(Range.first, Range.second);
+	return eastl::span<const ChunkedContentLookup::ChunkSequenceLocation>(Lookup.ChunkSequenceLocations).subspan(Range.first, Range.second);
 }
 
 inline uint32_t
@@ -180,7 +180,7 @@ GetFirstPathIndexForRawHash(const ChunkedContentLookup& Lookup, const IoHash& Ra
 
 namespace compactbinary_helpers {
 	template<typename Type>
-	void WriteArray(std::span<const Type> Values, std::string_view ArrayName, CbWriter& Output)
+	void WriteArray(eastl::span<const Type> Values, std::string_view ArrayName, CbWriter& Output)
 	{
 		Output.BeginArray(ArrayName);
 		for (const Type Value : Values)
@@ -193,11 +193,11 @@ namespace compactbinary_helpers {
 	template<typename Type>
 	void WriteArray(const eastl::vector<Type>& Values, std::string_view ArrayName, CbWriter& Output)
 	{
-		WriteArray(std::span<const Type>(Values), ArrayName, Output);
+		WriteArray(eastl::span<const Type>(Values), ArrayName, Output);
 	}
 
 	template<>
-	inline void WriteArray(std::span<const std::filesystem::path> Values, std::string_view ArrayName, CbWriter& Output)
+	inline void WriteArray(eastl::span<const std::filesystem::path> Values, std::string_view ArrayName, CbWriter& Output)
 	{
 		Output.BeginArray(ArrayName);
 		for (const std::filesystem::path& Path : Values)
@@ -210,10 +210,10 @@ namespace compactbinary_helpers {
 	template<>
 	inline void WriteArray(const eastl::vector<std::filesystem::path>& Values, std::string_view ArrayName, CbWriter& Output)
 	{
-		WriteArray(std::span<const std::filesystem::path>(Values), ArrayName, Output);
+		WriteArray(eastl::span<const std::filesystem::path>(Values), ArrayName, Output);
 	}
 
-	inline void WriteBinaryAttachmentArray(std::span<const IoHash> Values, std::string_view ArrayName, CbWriter& Output)
+	inline void WriteBinaryAttachmentArray(eastl::span<const IoHash> Values, std::string_view ArrayName, CbWriter& Output)
 	{
 		Output.BeginArray(ArrayName);
 		for (const IoHash& Hash : Values)
@@ -225,7 +225,7 @@ namespace compactbinary_helpers {
 
 	inline void WriteBinaryAttachmentArray(const eastl::vector<IoHash>& Values, std::string_view ArrayName, CbWriter& Output)
 	{
-		WriteArray(std::span<const IoHash>(Values), ArrayName, Output);
+		WriteArray(eastl::span<const IoHash>(Values), ArrayName, Output);
 	}
 
 	inline void ReadArray(std::string_view ArrayName, CbObjectView Input, eastl::vector<uint32_t>& Result)
diff --git a/src/zenutil/include/zenutil/chunkingcontroller.h b/src/zenutil/include/zenutil/chunkingcontroller.h
index ffdf453e5..ad77b8638 100644
--- a/src/zenutil/include/zenutil/chunkingcontroller.h
+++ b/src/zenutil/include/zenutil/chunkingcontroller.h
@@ -39,16 +39,16 @@ public:
 };
 
 std::unique_ptr<ChunkingController> CreateBasicChunkingController(
-	std::span<const std::string_view> ExcludeExtensions	 = DefaultChunkingExcludeExtensions,
-	uint64_t						  ChunkFileSizeLimit = DefaultChunkingFileSizeLimit,
-	const ChunkedParams&			  ChunkingParams	 = DefaultChunkedParams);
+	eastl::span<const std::string_view> ExcludeExtensions  = DefaultChunkingExcludeExtensions,
+	uint64_t							ChunkFileSizeLimit = DefaultChunkingFileSizeLimit,
+	const ChunkedParams&				ChunkingParams	   = DefaultChunkedParams);
 std::unique_ptr<ChunkingController> CreateBasicChunkingController(CbObjectView Parameters);
 
 std::unique_ptr<ChunkingController> CreateChunkingControllerWithFixedChunking(
-	std::span<const std::string_view> ExcludeExtensions		 = DefaultChunkingExcludeExtensions,
-	uint64_t						  ChunkFileSizeLimit	 = DefaultChunkingFileSizeLimit,
-	const ChunkedParams&			  ChunkingParams		 = DefaultChunkedParams,
-	uint32_t						  FixedChunkingChunkSize = DefaultFixedChunkingChunkSize);
+	eastl::span<const std::string_view> ExcludeExtensions	   = DefaultChunkingExcludeExtensions,
+	uint64_t							ChunkFileSizeLimit	   = DefaultChunkingFileSizeLimit,
+	const ChunkedParams&				ChunkingParams		   = DefaultChunkedParams,
+	uint32_t							FixedChunkingChunkSize = DefaultFixedChunkingChunkSize);
 std::unique_ptr<ChunkingController> CreateChunkingControllerWithFixedChunking(CbObjectView Parameters);
 
 std::unique_ptr<ChunkingController> CreateChunkingController(std::string_view Name, CbObjectView Parameters);
diff --git a/src/zenutil/include/zenutil/chunkrequests.h b/src/zenutil/include/zenutil/chunkrequests.h
index 91e23ec07..65385c346 100644
--- a/src/zenutil/include/zenutil/chunkrequests.h
+++ b/src/zenutil/include/zenutil/chunkrequests.h
@@ -4,9 +4,9 @@
 
 #include <zencore/uid.h>
 
+#include <EASTL/span.h>
 #include <EASTL/vector.h>
 #include <optional>
-#include <span>
 
 namespace zen {
 class IoBuffer;
@@ -22,6 +22,6 @@ struct RequestChunkEntry
 eastl::vector<IoBuffer>							ParseChunkBatchResponse(const IoBuffer& Buffer);
 IoBuffer										BuildChunkBatchRequest(const eastl::vector<RequestChunkEntry>& Entries);
 std::optional<eastl::vector<RequestChunkEntry>> ParseChunkBatchRequest(const IoBuffer& Payload);
-eastl::vector<IoBuffer> BuildChunkBatchResponse(const eastl::vector<RequestChunkEntry>& Requests, std::span<IoBuffer> Chunks);
+eastl::vector<IoBuffer> BuildChunkBatchResponse(const eastl::vector<RequestChunkEntry>& Requests, eastl::span<IoBuffer> Chunks);
 
 }  // namespace zen
diff --git a/src/zenutil/include/zenutil/referencemetadata.h b/src/zenutil/include/zenutil/referencemetadata.h
index f10eb1453..9377828b4 100644
--- a/src/zenutil/include/zenutil/referencemetadata.h
+++ b/src/zenutil/include/zenutil/referencemetadata.h
@@ -56,10 +56,10 @@ static_assert(sizeof(ReferenceMetaDataHeader) == 32);
 
 template<typename KeyType, typename AttachmentType>
 CompositeBuffer
-BuildReferenceMetaData(uint32_t						   HeaderMagic,
-					   std::span<const KeyType>		   Keys,
-					   std::span<const uint32_t>	   AttachmentCounts,
-					   std::span<const AttachmentType> Attachments)
+BuildReferenceMetaData(uint32_t							 HeaderMagic,
+					   eastl::span<const KeyType>		 Keys,
+					   eastl::span<const uint32_t>		 AttachmentCounts,
+					   eastl::span<const AttachmentType> Attachments)
 {
 	uint32_t KeyCount = gsl::narrow<uint32_t>(Keys.size());
 
@@ -73,11 +73,11 @@ BuildReferenceMetaData(uint32_t						   HeaderMagic,
 
 template<typename KeyType, typename AttachmentType>
 bool
-GetAttachmentsFromMetaData(const IoBuffer&													  MetaData,
-						   const uint32_t													  ExpectedHeaderMagic,
-						   std::function<void(std::span<const KeyType>		  Keys,
-											  std::span<const uint32_t>		  AttachmentCounts,
-											  std::span<const AttachmentType> Attachments)>&& Parser)
+GetAttachmentsFromMetaData(const IoBuffer&														MetaData,
+						   const uint32_t														ExpectedHeaderMagic,
+						   std::function<void(eastl::span<const KeyType>		Keys,
+											  eastl::span<const uint32_t>		AttachmentCounts,
+											  eastl::span<const AttachmentType> Attachments)>&& Parser)
 {
 	MemoryView PayloadView = MetaData.GetView();
 	if (PayloadView.GetSize() >= sizeof(ReferenceMetaDataHeader))
@@ -89,12 +89,12 @@ GetAttachmentsFromMetaData(const IoBuffer&													  MetaData,
 				ReferenceMetaDataHeader::ExpectedSize<KeyType, AttachmentType>(Header->EntryCount, Header->AttachmentCount))
 			{
 				PayloadView.MidInline(sizeof(ReferenceMetaDataHeader));
-				std::span<const KeyType> PayloadKeys = {(const KeyType*)PayloadView.GetData(), Header->EntryCount};
+				eastl::span<const KeyType> PayloadKeys = {(const KeyType*)PayloadView.GetData(), Header->EntryCount};
 				PayloadView.MidInline(sizeof(KeyType) * Header->EntryCount);
-				std::span<const uint32_t> PayloadAttachmentCounts = {(const uint32_t*)PayloadView.GetData(), Header->EntryCount};
+				eastl::span<const uint32_t> PayloadAttachmentCounts = {(const uint32_t*)PayloadView.GetData(), Header->EntryCount};
 				PayloadView.MidInline(sizeof(uint32_t) * Header->EntryCount);
-				std::span<const AttachmentType> PayloadAttachments = {(const AttachmentType*)PayloadView.GetData(),
-																	  Header->AttachmentCount};
+				eastl::span<const AttachmentType> PayloadAttachments = {(const AttachmentType*)PayloadView.GetData(),
+																		Header->AttachmentCount};
 				PayloadView.MidInline(sizeof(AttachmentType) * Header->AttachmentCount);
 				ZEN_ASSERT(PayloadView.GetSize() == 0);
 
diff --git a/src/zenutil/jupiter/jupiterbuildstorage.cpp b/src/zenutil/jupiter/jupiterbuildstorage.cpp
index bedbbd0a0..35a20366e 100644
--- a/src/zenutil/jupiter/jupiterbuildstorage.cpp
+++ b/src/zenutil/jupiter/jupiterbuildstorage.cpp
@@ -302,7 +302,7 @@ public:
 		return ParseChunkBlockDescriptionList(PayloadToJson("Failed fetching known blocks"sv, FindResult.Response));
 	}
 
-	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, std::span<const IoHash> BlockHashes) override
+	virtual eastl::vector<ChunkBlockDescription> GetBlockMetadata(const Oid& BuildId, eastl::span<const IoHash> BlockHashes) override
 	{
 		ZEN_TRACE_CPU("Jupiter::GetBlockMetadata");