Merge branch 'main' into zs/web-ui-improvements

21 files changed, 1970 insertions, 992 deletions

diff --git a/src/zenremotestore/builds/buildstoragecache.cpp b/src/zenremotestore/builds/buildstoragecache.cpp
index 07fcd62ba..faa85f81b 100644
--- a/src/zenremotestore/builds/buildstoragecache.cpp
+++ b/src/zenremotestore/builds/buildstoragecache.cpp
@@ -474,7 +474,13 @@ TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const boo
 	HttpClient::Response TestResponse = TestHttpClient.Get("/status/builds");
 	if (TestResponse.IsSuccess())
 	{
-		return {.Success = true};
+		LatencyTestResult LatencyResult = MeasureLatency(TestHttpClient, "/health");
+
+		if (!LatencyResult.Success)
+		{
+			return {.Success = false, .FailureReason = LatencyResult.FailureReason};
+		}
+		return {.Success = true, .LatencySeconds = LatencyResult.LatencySeconds};
 	}
 	return {.Success = false, .FailureReason = TestResponse.ErrorMessage("")};
 };
diff --git a/src/zenremotestore/builds/buildstorageoperations.cpp b/src/zenremotestore/builds/buildstorageoperations.cpp
index ade431393..5219e86d8 100644
--- a/src/zenremotestore/builds/buildstorageoperations.cpp
+++ b/src/zenremotestore/builds/buildstorageoperations.cpp
@@ -484,24 +484,6 @@ private:
 	uint64_t			  FilteredPerSecond = 0;
 };
 
-EPartialBlockRequestMode
-PartialBlockRequestModeFromString(const std::string_view ModeString)
-{
-	switch (HashStringAsLowerDjb2(ModeString))
-	{
-		case HashStringDjb2("false"):
-			return EPartialBlockRequestMode::Off;
-		case HashStringDjb2("zencacheonly"):
-			return EPartialBlockRequestMode::ZenCacheOnly;
-		case HashStringDjb2("mixed"):
-			return EPartialBlockRequestMode::Mixed;
-		case HashStringDjb2("true"):
-			return EPartialBlockRequestMode::All;
-		default:
-			return EPartialBlockRequestMode::Invalid;
-	}
-}
-
 std::filesystem::path
 ZenStateFilePath(const std::filesystem::path& ZenFolderPath)
 {
@@ -579,13 +561,6 @@ BuildsOperationUpdateFolder::Execute(FolderContent& OutLocalFolderState)
 		CreateDirectories(m_TempDownloadFolderPath);
 		CreateDirectories(m_TempBlockFolderPath);
 
-		Stopwatch IndexTimer;
-
-		if (!m_Options.IsQuiet)
-		{
-			ZEN_OPERATION_LOG_INFO(m_LogOutput, "Indexed local and remote content in {}", NiceTimeSpanMs(IndexTimer.GetElapsedTimeMs()));
-		}
-
 		Stopwatch CacheMappingTimer;
 
 		std::vector<std::atomic<uint32_t>> SequenceIndexChunksLeftToWriteCounters(m_RemoteContent.ChunkedContent.SequenceRawHashes.size());
@@ -906,343 +881,220 @@ BuildsOperationUpdateFolder::Execute(FolderContent& OutLocalFolderState)
 
 		CheckRequiredDiskSpace(RemotePathToRemoteIndex);
 
+		BlobsExistsResult ExistsResult;
 		{
-			ZEN_TRACE_CPU("WriteChunks");
-
-			m_LogOutput.SetLogOperationProgress((uint32_t)TaskSteps::WriteChunks, (uint32_t)TaskSteps::StepCount);
+			ChunkBlockAnalyser BlockAnalyser(m_LogOutput,
+											 m_BlockDescriptions,
+											 ChunkBlockAnalyser::Options{.IsQuiet				  = m_Options.IsQuiet,
+																		 .IsVerbose				  = m_Options.IsVerbose,
+																		 .HostLatencySec		  = m_Storage.BuildStorageLatencySec,
+																		 .HostHighSpeedLatencySec = m_Storage.CacheLatencySec});
 
-			Stopwatch WriteTimer;
+			std::vector<ChunkBlockAnalyser::NeededBlock> NeededBlocks = BlockAnalyser.GetNeeded(
+				m_RemoteLookup.ChunkHashToChunkIndex,
+				[&](uint32_t RemoteChunkIndex) -> bool { return RemoteChunkIndexNeedsCopyFromSourceFlags[RemoteChunkIndex]; });
 
-			FilteredRate FilteredDownloadedBytesPerSecond;
-			FilteredRate FilteredWrittenBytesPerSecond;
+			std::vector<uint32_t> FetchBlockIndexes;
+			std::vector<uint32_t> CachedChunkBlockIndexes;
 
-			std::unique_ptr<OperationLogOutput::ProgressBar> WriteProgressBarPtr(
-				m_LogOutput.CreateProgressBar(m_Options.PrimeCacheOnly ? "Downloading" : "Writing"));
-			OperationLogOutput::ProgressBar& WriteProgressBar(*WriteProgressBarPtr);
-			ParallelWork					 Work(m_AbortFlag, m_PauseFlag, WorkerThreadPool::EMode::EnableBacklog);
-
-			struct LooseChunkHashWorkData
 			{
-				std::vector<const ChunkedContentLookup::ChunkSequenceLocation*> ChunkTargetPtrs;
-				uint32_t														RemoteChunkIndex = (uint32_t)-1;
-			};
-
-			std::vector<LooseChunkHashWorkData> LooseChunkHashWorks;
-			TotalPartWriteCount += CopyChunkDatas.size();
-			TotalPartWriteCount += ScavengedSequenceCopyOperations.size();
-
-			for (const IoHash ChunkHash : m_LooseChunkHashes)
-			{
-				auto RemoteChunkIndexIt = m_RemoteLookup.ChunkHashToChunkIndex.find(ChunkHash);
-				ZEN_ASSERT(RemoteChunkIndexIt != m_RemoteLookup.ChunkHashToChunkIndex.end());
-				const uint32_t RemoteChunkIndex = RemoteChunkIndexIt->second;
-				if (RemoteChunkIndexNeedsCopyFromLocalFileFlags[RemoteChunkIndex])
+				ZEN_TRACE_CPU("BlockCacheFileExists");
+				for (const ChunkBlockAnalyser::NeededBlock& NeededBlock : NeededBlocks)
 				{
-					if (m_Options.IsVerbose)
-					{
-						ZEN_OPERATION_LOG_INFO(m_LogOutput, "Skipping chunk {} due to cache reuse", ChunkHash);
-					}
-					continue;
-				}
-				bool NeedsCopy = true;
-				if (RemoteChunkIndexNeedsCopyFromSourceFlags[RemoteChunkIndex].compare_exchange_strong(NeedsCopy, false))
-				{
-					std::vector<const ChunkedContentLookup::ChunkSequenceLocation*> ChunkTargetPtrs =
-						GetRemainingChunkTargets(SequenceIndexChunksLeftToWriteCounters, RemoteChunkIndex);
-
-					if (ChunkTargetPtrs.empty())
+					if (m_Options.PrimeCacheOnly)
 					{
-						if (m_Options.IsVerbose)
-						{
-							ZEN_OPERATION_LOG_INFO(m_LogOutput, "Skipping chunk {} due to cache reuse", ChunkHash);
-						}
+						FetchBlockIndexes.push_back(NeededBlock.BlockIndex);
 					}
 					else
 					{
-						TotalRequestCount++;
-						TotalPartWriteCount++;
-						LooseChunkHashWorks.push_back(
-							LooseChunkHashWorkData{.ChunkTargetPtrs = ChunkTargetPtrs, .RemoteChunkIndex = RemoteChunkIndex});
-					}
-				}
-			}
-
-			uint32_t BlockCount = gsl::narrow<uint32_t>(m_BlockDescriptions.size());
-
-			std::vector<bool> ChunkIsPickedUpByBlock(m_RemoteContent.ChunkedContent.ChunkHashes.size(), false);
-			auto			  GetNeededChunkBlockIndexes = [this, &RemoteChunkIndexNeedsCopyFromSourceFlags, &ChunkIsPickedUpByBlock](
-												   const ChunkBlockDescription& BlockDescription) {
-				ZEN_TRACE_CPU("GetNeededChunkBlockIndexes");
-				std::vector<uint32_t> NeededBlockChunkIndexes;
-				for (uint32_t ChunkBlockIndex = 0; ChunkBlockIndex < BlockDescription.ChunkRawHashes.size(); ChunkBlockIndex++)
-				{
-					const IoHash& ChunkHash = BlockDescription.ChunkRawHashes[ChunkBlockIndex];
-					if (auto It = m_RemoteLookup.ChunkHashToChunkIndex.find(ChunkHash); It != m_RemoteLookup.ChunkHashToChunkIndex.end())
-					{
-						const uint32_t RemoteChunkIndex = It->second;
-						if (!ChunkIsPickedUpByBlock[RemoteChunkIndex])
+						const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[NeededBlock.BlockIndex];
+						bool						 UsingCachedBlock = false;
+						if (auto It = CachedBlocksFound.find(BlockDescription.BlockHash); It != CachedBlocksFound.end())
 						{
-							if (RemoteChunkIndexNeedsCopyFromSourceFlags[RemoteChunkIndex])
+							TotalPartWriteCount++;
+
+							std::filesystem::path BlockPath = m_TempBlockFolderPath / BlockDescription.BlockHash.ToHexString();
+							if (IsFile(BlockPath))
 							{
-								ChunkIsPickedUpByBlock[RemoteChunkIndex] = true;
-								NeededBlockChunkIndexes.push_back(ChunkBlockIndex);
+								CachedChunkBlockIndexes.push_back(NeededBlock.BlockIndex);
+								UsingCachedBlock = true;
 							}
 						}
-					}
-					else
-					{
-						ZEN_DEBUG("Chunk {} not found in block {}", ChunkHash, BlockDescription.BlockHash);
+						if (!UsingCachedBlock)
+						{
+							FetchBlockIndexes.push_back(NeededBlock.BlockIndex);
+						}
 					}
 				}
-				return NeededBlockChunkIndexes;
-			};
+			}
 
-			std::vector<uint32_t>			   CachedChunkBlockIndexes;
-			std::vector<uint32_t>			   FetchBlockIndexes;
-			std::vector<std::vector<uint32_t>> AllBlockChunkIndexNeeded;
+			std::vector<uint32_t> NeededLooseChunkIndexes;
 
-			for (uint32_t BlockIndex = 0; BlockIndex < BlockCount; BlockIndex++)
 			{
-				const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
-
-				std::vector<uint32_t> BlockChunkIndexNeeded = GetNeededChunkBlockIndexes(BlockDescription);
-				if (!BlockChunkIndexNeeded.empty())
+				NeededLooseChunkIndexes.reserve(m_LooseChunkHashes.size());
+				for (uint32_t LooseChunkIndex = 0; LooseChunkIndex < m_LooseChunkHashes.size(); LooseChunkIndex++)
 				{
-					if (m_Options.PrimeCacheOnly)
+					const IoHash& ChunkHash			 = m_LooseChunkHashes[LooseChunkIndex];
+					auto		  RemoteChunkIndexIt = m_RemoteLookup.ChunkHashToChunkIndex.find(ChunkHash);
+					ZEN_ASSERT(RemoteChunkIndexIt != m_RemoteLookup.ChunkHashToChunkIndex.end());
+					const uint32_t RemoteChunkIndex = RemoteChunkIndexIt->second;
+
+					if (RemoteChunkIndexNeedsCopyFromLocalFileFlags[RemoteChunkIndex])
 					{
-						FetchBlockIndexes.push_back(BlockIndex);
+						if (m_Options.IsVerbose)
+						{
+							ZEN_OPERATION_LOG_INFO(m_LogOutput,
+												   "Skipping chunk {} due to cache reuse",
+												   m_RemoteContent.ChunkedContent.ChunkHashes[RemoteChunkIndex]);
+						}
+						continue;
 					}
-					else
+
+					bool NeedsCopy = true;
+					if (RemoteChunkIndexNeedsCopyFromSourceFlags[RemoteChunkIndex].compare_exchange_strong(NeedsCopy, false))
 					{
-						bool UsingCachedBlock = false;
-						if (auto It = CachedBlocksFound.find(BlockDescription.BlockHash); It != CachedBlocksFound.end())
+						uint64_t WriteCount = GetChunkWriteCount(SequenceIndexChunksLeftToWriteCounters, RemoteChunkIndex);
+						if (WriteCount == 0)
 						{
-							TotalPartWriteCount++;
-
-							std::filesystem::path BlockPath = m_TempBlockFolderPath / BlockDescription.BlockHash.ToHexString();
-							if (IsFile(BlockPath))
+							if (m_Options.IsVerbose)
 							{
-								CachedChunkBlockIndexes.push_back(BlockIndex);
-								UsingCachedBlock = true;
+								ZEN_OPERATION_LOG_INFO(m_LogOutput,
+													   "Skipping chunk {} due to cache reuse",
+													   m_RemoteContent.ChunkedContent.ChunkHashes[RemoteChunkIndex]);
 							}
 						}
-						if (!UsingCachedBlock)
+						else
 						{
-							FetchBlockIndexes.push_back(BlockIndex);
+							NeededLooseChunkIndexes.push_back(LooseChunkIndex);
 						}
 					}
 				}
-				AllBlockChunkIndexNeeded.emplace_back(std::move(BlockChunkIndexNeeded));
 			}
 
-			BlobsExistsResult ExistsResult;
-
 			if (m_Storage.BuildCacheStorage)
 			{
 				ZEN_TRACE_CPU("BlobCacheExistCheck");
 				Stopwatch Timer;
 
-				tsl::robin_set<IoHash> BlobHashesSet;
+				std::vector<IoHash> BlobHashes;
+				BlobHashes.reserve(NeededLooseChunkIndexes.size() + FetchBlockIndexes.size());
 
-				BlobHashesSet.reserve(LooseChunkHashWorks.size() + FetchBlockIndexes.size());
-				for (LooseChunkHashWorkData& LooseChunkHashWork : LooseChunkHashWorks)
+				for (const uint32_t LooseChunkIndex : NeededLooseChunkIndexes)
 				{
-					BlobHashesSet.insert(m_RemoteContent.ChunkedContent.ChunkHashes[LooseChunkHashWork.RemoteChunkIndex]);
+					BlobHashes.push_back(m_LooseChunkHashes[LooseChunkIndex]);
 				}
+
 				for (uint32_t BlockIndex : FetchBlockIndexes)
 				{
-					const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
-					BlobHashesSet.insert(BlockDescription.BlockHash);
+					BlobHashes.push_back(m_BlockDescriptions[BlockIndex].BlockHash);
 				}
 
-				if (!BlobHashesSet.empty())
-				{
-					const std::vector<IoHash>							   BlobHashes(BlobHashesSet.begin(), BlobHashesSet.end());
-					const std::vector<BuildStorageCache::BlobExistsResult> CacheExistsResult =
-						m_Storage.BuildCacheStorage->BlobsExists(m_BuildId, BlobHashes);
+				const std::vector<BuildStorageCache::BlobExistsResult> CacheExistsResult =
+					m_Storage.BuildCacheStorage->BlobsExists(m_BuildId, BlobHashes);
 
-					if (CacheExistsResult.size() == BlobHashes.size())
+				if (CacheExistsResult.size() == BlobHashes.size())
+				{
+					ExistsResult.ExistingBlobs.reserve(CacheExistsResult.size());
+					for (size_t BlobIndex = 0; BlobIndex < BlobHashes.size(); BlobIndex++)
 					{
-						ExistsResult.ExistingBlobs.reserve(CacheExistsResult.size());
-						for (size_t BlobIndex = 0; BlobIndex < BlobHashes.size(); BlobIndex++)
+						if (CacheExistsResult[BlobIndex].HasBody)
 						{
-							if (CacheExistsResult[BlobIndex].HasBody)
-							{
-								ExistsResult.ExistingBlobs.insert(BlobHashes[BlobIndex]);
-							}
+							ExistsResult.ExistingBlobs.insert(BlobHashes[BlobIndex]);
 						}
 					}
-					ExistsResult.ElapsedTimeMs = Timer.GetElapsedTimeMs();
-					if (!ExistsResult.ExistingBlobs.empty() && !m_Options.IsQuiet)
-					{
-						ZEN_OPERATION_LOG_INFO(m_LogOutput,
-											   "Remote cache  : Found {} out of {} needed blobs in {}",
-											   ExistsResult.ExistingBlobs.size(),
-											   BlobHashes.size(),
-											   NiceTimeSpanMs(ExistsResult.ElapsedTimeMs));
-					}
+				}
+				ExistsResult.ElapsedTimeMs = Timer.GetElapsedTimeMs();
+				if (!ExistsResult.ExistingBlobs.empty() && !m_Options.IsQuiet)
+				{
+					ZEN_OPERATION_LOG_INFO(m_LogOutput,
+										   "Remote cache  : Found {} out of {} needed blobs in {}",
+										   ExistsResult.ExistingBlobs.size(),
+										   BlobHashes.size(),
+										   NiceTimeSpanMs(ExistsResult.ElapsedTimeMs));
 				}
 			}
 
-			std::vector<BlockRangeDescriptor> BlockRangeWorks;
-			std::vector<uint32_t>			  FullBlockWorks;
+			std::vector<ChunkBlockAnalyser::EPartialBlockDownloadMode> BlockPartialDownloadModes;
+			if (m_Options.PartialBlockRequestMode == EPartialBlockRequestMode::Off)
 			{
-				Stopwatch Timer;
-
-				std::vector<uint32_t> PartialBlockIndexes;
-
-				for (uint32_t BlockIndex : FetchBlockIndexes)
+				BlockPartialDownloadModes.resize(m_BlockDescriptions.size(), ChunkBlockAnalyser::EPartialBlockDownloadMode::Off);
+			}
+			else
+			{
+				BlockPartialDownloadModes.reserve(m_BlockDescriptions.size());
+				for (uint32_t BlockIndex = 0; BlockIndex < m_BlockDescriptions.size(); BlockIndex++)
 				{
-					const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
-
-					const std::vector<uint32_t> BlockChunkIndexNeeded = std::move(AllBlockChunkIndexNeeded[BlockIndex]);
-					if (!BlockChunkIndexNeeded.empty())
+					const bool BlockExistInCache = ExistsResult.ExistingBlobs.contains(m_BlockDescriptions[BlockIndex].BlockHash);
+					if (m_Options.PartialBlockRequestMode == EPartialBlockRequestMode::All)
 					{
-						bool WantsToDoPartialBlockDownload = BlockChunkIndexNeeded.size() < BlockDescription.ChunkRawHashes.size();
-						bool CanDoPartialBlockDownload =
-							(BlockDescription.HeaderSize > 0) &&
-							(BlockDescription.ChunkCompressedLengths.size() == BlockDescription.ChunkRawHashes.size());
-
-						bool AllowedToDoPartialRequest = false;
-						bool BlockExistInCache		   = ExistsResult.ExistingBlobs.contains(BlockDescription.BlockHash);
-						switch (m_Options.PartialBlockRequestMode)
-						{
-							case EPartialBlockRequestMode::Off:
-								break;
-							case EPartialBlockRequestMode::ZenCacheOnly:
-								AllowedToDoPartialRequest = BlockExistInCache;
-								break;
-							case EPartialBlockRequestMode::Mixed:
-							case EPartialBlockRequestMode::All:
-								AllowedToDoPartialRequest = true;
-								break;
-							default:
-								ZEN_ASSERT(false);
-								break;
-						}
+						BlockPartialDownloadModes.push_back(BlockExistInCache
+																? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																: ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRange);
+					}
+					else if (m_Options.PartialBlockRequestMode == EPartialBlockRequestMode::ZenCacheOnly)
+					{
+						BlockPartialDownloadModes.push_back(BlockExistInCache
+																? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																: ChunkBlockAnalyser::EPartialBlockDownloadMode::Off);
+					}
+					else if (m_Options.PartialBlockRequestMode == EPartialBlockRequestMode::Mixed)
+					{
+						BlockPartialDownloadModes.push_back(BlockExistInCache
+																? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																: ChunkBlockAnalyser::EPartialBlockDownloadMode::SingleRange);
+					}
+				}
+			}
+			ZEN_ASSERT(BlockPartialDownloadModes.size() == m_BlockDescriptions.size());
 
-						const uint32_t ChunkStartOffsetInBlock =
-							gsl::narrow<uint32_t>(CompressedBuffer::GetHeaderSizeForNoneEncoder() + BlockDescription.HeaderSize);
+			ChunkBlockAnalyser::BlockResult PartialBlocks =
+				BlockAnalyser.CalculatePartialBlockDownloads(NeededBlocks, BlockPartialDownloadModes);
 
-						const uint64_t TotalBlockSize = std::accumulate(BlockDescription.ChunkCompressedLengths.begin(),
-																		BlockDescription.ChunkCompressedLengths.end(),
-																		std::uint64_t(ChunkStartOffsetInBlock));
+			struct LooseChunkHashWorkData
+			{
+				std::vector<const ChunkedContentLookup::ChunkSequenceLocation*> ChunkTargetPtrs;
+				uint32_t														RemoteChunkIndex = (uint32_t)-1;
+			};
 
-						if (AllowedToDoPartialRequest && WantsToDoPartialBlockDownload && CanDoPartialBlockDownload)
-						{
-							ZEN_TRACE_CPU("PartialBlockAnalysis");
-
-							bool LimitToSingleRange =
-								BlockExistInCache ? false : m_Options.PartialBlockRequestMode == EPartialBlockRequestMode::Mixed;
-							uint64_t										 TotalWantedChunksSize = 0;
-							std::optional<std::vector<BlockRangeDescriptor>> MaybeBlockRanges =
-								CalculateBlockRanges(BlockIndex,
-													 BlockDescription,
-													 BlockChunkIndexNeeded,
-													 LimitToSingleRange,
-													 ChunkStartOffsetInBlock,
-													 TotalBlockSize,
-													 TotalWantedChunksSize);
-							ZEN_ASSERT(TotalWantedChunksSize <= TotalBlockSize);
-
-							if (MaybeBlockRanges.has_value())
-							{
-								const std::vector<BlockRangeDescriptor>& BlockRanges = MaybeBlockRanges.value();
-								ZEN_ASSERT(!BlockRanges.empty());
-								BlockRangeWorks.insert(BlockRangeWorks.end(), BlockRanges.begin(), BlockRanges.end());
-								TotalRequestCount += BlockRanges.size();
-								TotalPartWriteCount += BlockRanges.size();
-
-								uint64_t RequestedSize = std::accumulate(
-									BlockRanges.begin(),
-									BlockRanges.end(),
-									uint64_t(0),
-									[](uint64_t Current, const BlockRangeDescriptor& Range) { return Current + Range.RangeLength; });
-								PartialBlockIndexes.push_back(BlockIndex);
-
-								if (RequestedSize > TotalWantedChunksSize)
-								{
-									if (m_Options.IsVerbose)
-									{
-										ZEN_OPERATION_LOG_INFO(
-											m_LogOutput,
-											"Requesting {} chunks ({}) from block {} ({}) using {} requests (extra bytes {})",
-											BlockChunkIndexNeeded.size(),
-											NiceBytes(RequestedSize),
-											BlockDescription.BlockHash,
-											NiceBytes(TotalBlockSize),
-											BlockRanges.size(),
-											NiceBytes(RequestedSize - TotalWantedChunksSize));
-									}
-								}
-							}
-							else
-							{
-								FullBlockWorks.push_back(BlockIndex);
-								TotalRequestCount++;
-								TotalPartWriteCount++;
-							}
-						}
-						else
-						{
-							FullBlockWorks.push_back(BlockIndex);
-							TotalRequestCount++;
-							TotalPartWriteCount++;
-						}
-					}
-				}
+			TotalRequestCount += NeededLooseChunkIndexes.size();
+			TotalPartWriteCount += NeededLooseChunkIndexes.size();
+			TotalRequestCount += PartialBlocks.BlockRanges.size();
+			TotalPartWriteCount += PartialBlocks.BlockRanges.size();
+			TotalRequestCount += PartialBlocks.FullBlockIndexes.size();
+			TotalPartWriteCount += PartialBlocks.FullBlockIndexes.size();
 
-				if (!PartialBlockIndexes.empty())
-				{
-					uint64_t TotalFullBlockRequestBytes = 0;
-					for (uint32_t BlockIndex : FullBlockWorks)
-					{
-						const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
-						uint32_t					 CurrentOffset =
-							gsl::narrow<uint32_t>(CompressedBuffer::GetHeaderSizeForNoneEncoder() + BlockDescription.HeaderSize);
+			std::vector<LooseChunkHashWorkData> LooseChunkHashWorks;
+			for (uint32_t LooseChunkIndex : NeededLooseChunkIndexes)
+			{
+				const IoHash& ChunkHash			 = m_LooseChunkHashes[LooseChunkIndex];
+				auto		  RemoteChunkIndexIt = m_RemoteLookup.ChunkHashToChunkIndex.find(ChunkHash);
+				ZEN_ASSERT(RemoteChunkIndexIt != m_RemoteLookup.ChunkHashToChunkIndex.end());
+				const uint32_t RemoteChunkIndex = RemoteChunkIndexIt->second;
 
-						TotalFullBlockRequestBytes += std::accumulate(BlockDescription.ChunkCompressedLengths.begin(),
-																	  BlockDescription.ChunkCompressedLengths.end(),
-																	  std::uint64_t(CurrentOffset));
-					}
+				std::vector<const ChunkedContentLookup::ChunkSequenceLocation*> ChunkTargetPtrs =
+					GetRemainingChunkTargets(SequenceIndexChunksLeftToWriteCounters, RemoteChunkIndex);
 
-					uint64_t TotalPartialBlockBytes = 0;
-					for (uint32_t BlockIndex : PartialBlockIndexes)
-					{
-						const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
-						uint32_t					 CurrentOffset =
-							gsl::narrow<uint32_t>(CompressedBuffer::GetHeaderSizeForNoneEncoder() + BlockDescription.HeaderSize);
+				ZEN_ASSERT(!ChunkTargetPtrs.empty());
+				LooseChunkHashWorks.push_back(
+					LooseChunkHashWorkData{.ChunkTargetPtrs = ChunkTargetPtrs, .RemoteChunkIndex = RemoteChunkIndex});
+			}
 
-						TotalPartialBlockBytes += std::accumulate(BlockDescription.ChunkCompressedLengths.begin(),
-																  BlockDescription.ChunkCompressedLengths.end(),
-																  std::uint64_t(CurrentOffset));
-					}
+			ZEN_TRACE_CPU("WriteChunks");
 
-					uint64_t NonPartialTotalBlockBytes = TotalFullBlockRequestBytes + TotalPartialBlockBytes;
+			m_LogOutput.SetLogOperationProgress((uint32_t)TaskSteps::WriteChunks, (uint32_t)TaskSteps::StepCount);
 
-					const uint64_t TotalPartialBlockRequestBytes =
-						std::accumulate(BlockRangeWorks.begin(),
-										BlockRangeWorks.end(),
-										uint64_t(0),
-										[](uint64_t Current, const BlockRangeDescriptor& Range) { return Current + Range.RangeLength; });
-					uint64_t TotalExtraPartialBlocksRequests = BlockRangeWorks.size() - PartialBlockIndexes.size();
+			Stopwatch WriteTimer;
 
-					uint64_t TotalSavedBlocksSize = TotalPartialBlockBytes - TotalPartialBlockRequestBytes;
-					double	 SavedSizePercent	  = (TotalSavedBlocksSize * 100.0) / NonPartialTotalBlockBytes;
+			FilteredRate FilteredDownloadedBytesPerSecond;
+			FilteredRate FilteredWrittenBytesPerSecond;
 
-					if (!m_Options.IsQuiet)
-					{
-						ZEN_OPERATION_LOG_INFO(m_LogOutput,
-											   "Analysis of partial block requests saves download of {} out of {} ({:.1f}%) using {} extra "
-											   "requests. Completed in {}",
-											   NiceBytes(TotalSavedBlocksSize),
-											   NiceBytes(NonPartialTotalBlockBytes),
-											   SavedSizePercent,
-											   TotalExtraPartialBlocksRequests,
-											   NiceTimeSpanMs(ExistsResult.ElapsedTimeMs));
-					}
-				}
-			}
+			std::unique_ptr<OperationLogOutput::ProgressBar> WriteProgressBarPtr(
+				m_LogOutput.CreateProgressBar(m_Options.PrimeCacheOnly ? "Downloading" : "Writing"));
+			OperationLogOutput::ProgressBar& WriteProgressBar(*WriteProgressBarPtr);
+			ParallelWork					 Work(m_AbortFlag, m_PauseFlag, WorkerThreadPool::EMode::EnableBacklog);
+
+			TotalPartWriteCount += CopyChunkDatas.size();
+			TotalPartWriteCount += ScavengedSequenceCopyOperations.size();
 
 			BufferedWriteFileCache WriteCache;
 
@@ -1472,13 +1324,23 @@ BuildsOperationUpdateFolder::Execute(FolderContent& OutLocalFolderState)
 					});
 			}
 
-			for (size_t BlockRangeIndex = 0; BlockRangeIndex < BlockRangeWorks.size(); BlockRangeIndex++)
+			for (size_t BlockRangeIndex = 0; BlockRangeIndex < PartialBlocks.BlockRanges.size();)
 			{
 				ZEN_ASSERT(!m_Options.PrimeCacheOnly);
 				if (m_AbortFlag)
 				{
 					break;
 				}
+
+				size_t											RangeCount		  = 1;
+				size_t											RangesLeft		  = PartialBlocks.BlockRanges.size() - BlockRangeIndex;
+				const ChunkBlockAnalyser::BlockRangeDescriptor& CurrentBlockRange = PartialBlocks.BlockRanges[BlockRangeIndex];
+				while (RangeCount < RangesLeft &&
+					   CurrentBlockRange.BlockIndex == PartialBlocks.BlockRanges[BlockRangeIndex + RangeCount].BlockIndex)
+				{
+					RangeCount++;
+				}
+
 				Work.ScheduleWork(
 					m_NetworkPool,
 					[this,
@@ -1492,119 +1354,127 @@ BuildsOperationUpdateFolder::Execute(FolderContent& OutLocalFolderState)
 					 TotalPartWriteCount,
 					 &FilteredWrittenBytesPerSecond,
 					 &Work,
-					 &BlockRangeWorks,
-					 BlockRangeIndex](std::atomic<bool>&) {
+					 &PartialBlocks,
+					 BlockRangeStartIndex = BlockRangeIndex,
+					 RangeCount](std::atomic<bool>&) {
 						if (!m_AbortFlag)
 						{
-							ZEN_TRACE_CPU("Async_GetPartialBlock");
-
-							const BlockRangeDescriptor& BlockRange = BlockRangeWorks[BlockRangeIndex];
+							ZEN_TRACE_CPU("Async_GetPartialBlockRanges");
 
 							FilteredDownloadedBytesPerSecond.Start();
 
-							DownloadPartialBlock(
-								BlockRange,
-								ExistsResult,
-								[this,
-								 &RemoteChunkIndexNeedsCopyFromSourceFlags,
-								 &SequenceIndexChunksLeftToWriteCounters,
-								 &WritePartsComplete,
-								 &WriteCache,
-								 &Work,
-								 TotalRequestCount,
-								 TotalPartWriteCount,
-								 &FilteredDownloadedBytesPerSecond,
-								 &FilteredWrittenBytesPerSecond,
-								 &BlockRange](IoBuffer&& InMemoryBuffer, const std::filesystem::path& OnDiskPath) {
-									if (m_DownloadStats.RequestsCompleteCount == TotalRequestCount)
-									{
-										FilteredDownloadedBytesPerSecond.Stop();
-									}
-
-									if (!m_AbortFlag)
-									{
-										Work.ScheduleWork(
-											m_IOWorkerPool,
-											[this,
-											 &RemoteChunkIndexNeedsCopyFromSourceFlags,
-											 &SequenceIndexChunksLeftToWriteCounters,
-											 &WritePartsComplete,
-											 &WriteCache,
-											 &Work,
-											 TotalPartWriteCount,
-											 &FilteredWrittenBytesPerSecond,
-											 &BlockRange,
-											 BlockChunkPath		= std::filesystem::path(OnDiskPath),
-											 BlockPartialBuffer = std::move(InMemoryBuffer)](std::atomic<bool>&) mutable {
-												if (!m_AbortFlag)
-												{
-													ZEN_TRACE_CPU("Async_WritePartialBlock");
+							for (size_t BlockRangeIndex = BlockRangeStartIndex; BlockRangeIndex < BlockRangeStartIndex + RangeCount;
+								 BlockRangeIndex++)
+							{
+								ZEN_TRACE_CPU("GetPartialBlock");
 
-													const uint32_t BlockIndex = BlockRange.BlockIndex;
+								const ChunkBlockAnalyser::BlockRangeDescriptor& BlockRange = PartialBlocks.BlockRanges[BlockRangeIndex];
 
-													const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
+								DownloadPartialBlock(
+									BlockRange,
+									ExistsResult,
+									[this,
+									 &RemoteChunkIndexNeedsCopyFromSourceFlags,
+									 &SequenceIndexChunksLeftToWriteCounters,
+									 &WritePartsComplete,
+									 &WriteCache,
+									 &Work,
+									 TotalRequestCount,
+									 TotalPartWriteCount,
+									 &FilteredDownloadedBytesPerSecond,
+									 &FilteredWrittenBytesPerSecond,
+									 &BlockRange](IoBuffer&& InMemoryBuffer, const std::filesystem::path& OnDiskPath) {
+										if (m_DownloadStats.RequestsCompleteCount == TotalRequestCount)
+										{
+											FilteredDownloadedBytesPerSecond.Stop();
+										}
 
-													if (BlockChunkPath.empty())
-													{
-														ZEN_ASSERT(BlockPartialBuffer);
-													}
-													else
+										if (!m_AbortFlag)
+										{
+											Work.ScheduleWork(
+												m_IOWorkerPool,
+												[this,
+												 &RemoteChunkIndexNeedsCopyFromSourceFlags,
+												 &SequenceIndexChunksLeftToWriteCounters,
+												 &WritePartsComplete,
+												 &WriteCache,
+												 &Work,
+												 TotalPartWriteCount,
+												 &FilteredWrittenBytesPerSecond,
+												 &BlockRange,
+												 BlockChunkPath		= std::filesystem::path(OnDiskPath),
+												 BlockPartialBuffer = std::move(InMemoryBuffer)](std::atomic<bool>&) mutable {
+													if (!m_AbortFlag)
 													{
-														ZEN_ASSERT(!BlockPartialBuffer);
-														BlockPartialBuffer = IoBufferBuilder::MakeFromFile(BlockChunkPath);
-														if (!BlockPartialBuffer)
+														ZEN_TRACE_CPU("Async_WritePartialBlock");
+
+														const uint32_t BlockIndex = BlockRange.BlockIndex;
+
+														const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
+
+														if (BlockChunkPath.empty())
 														{
-															throw std::runtime_error(
-																fmt::format("Could not open downloaded block {} from {}",
-																			BlockDescription.BlockHash,
-																			BlockChunkPath));
+															ZEN_ASSERT(BlockPartialBuffer);
+														}
+														else
+														{
+															ZEN_ASSERT(!BlockPartialBuffer);
+															BlockPartialBuffer = IoBufferBuilder::MakeFromFile(BlockChunkPath);
+															if (!BlockPartialBuffer)
+															{
+																throw std::runtime_error(
+																	fmt::format("Could not open downloaded block {} from {}",
+																				BlockDescription.BlockHash,
+																				BlockChunkPath));
+															}
 														}
-													}
-
-													FilteredWrittenBytesPerSecond.Start();
 
-													if (!WritePartialBlockChunksToCache(
-															BlockDescription,
-															SequenceIndexChunksLeftToWriteCounters,
-															Work,
-															CompositeBuffer(std::move(BlockPartialBuffer)),
-															BlockRange.ChunkBlockIndexStart,
-															BlockRange.ChunkBlockIndexStart + BlockRange.ChunkBlockIndexCount - 1,
-															RemoteChunkIndexNeedsCopyFromSourceFlags,
-															WriteCache))
-													{
-														std::error_code DummyEc;
-														RemoveFile(BlockChunkPath, DummyEc);
-														throw std::runtime_error(
-															fmt::format("Partial block {} is malformed", BlockDescription.BlockHash));
-													}
+														FilteredWrittenBytesPerSecond.Start();
+
+														if (!WritePartialBlockChunksToCache(
+																BlockDescription,
+																SequenceIndexChunksLeftToWriteCounters,
+																Work,
+																CompositeBuffer(std::move(BlockPartialBuffer)),
+																BlockRange.ChunkBlockIndexStart,
+																BlockRange.ChunkBlockIndexStart + BlockRange.ChunkBlockIndexCount - 1,
+																RemoteChunkIndexNeedsCopyFromSourceFlags,
+																WriteCache))
+														{
+															std::error_code DummyEc;
+															RemoveFile(BlockChunkPath, DummyEc);
+															throw std::runtime_error(
+																fmt::format("Partial block {} is malformed", BlockDescription.BlockHash));
+														}
 
-													std::error_code Ec = TryRemoveFile(BlockChunkPath);
-													if (Ec)
-													{
-														ZEN_OPERATION_LOG_DEBUG(m_LogOutput,
-																				"Failed removing file '{}', reason: ({}) {}",
-																				BlockChunkPath,
-																				Ec.value(),
-																				Ec.message());
-													}
+														std::error_code Ec = TryRemoveFile(BlockChunkPath);
+														if (Ec)
+														{
+															ZEN_OPERATION_LOG_DEBUG(m_LogOutput,
+																					"Failed removing file '{}', reason: ({}) {}",
+																					BlockChunkPath,
+																					Ec.value(),
+																					Ec.message());
+														}
 
-													WritePartsComplete++;
-													if (WritePartsComplete == TotalPartWriteCount)
-													{
-														FilteredWrittenBytesPerSecond.Stop();
+														WritePartsComplete++;
+														if (WritePartsComplete == TotalPartWriteCount)
+														{
+															FilteredWrittenBytesPerSecond.Stop();
+														}
 													}
-												}
-											},
-											OnDiskPath.empty() ? WorkerThreadPool::EMode::DisableBacklog
-															   : WorkerThreadPool::EMode::EnableBacklog);
-									}
-								});
+												},
+												OnDiskPath.empty() ? WorkerThreadPool::EMode::DisableBacklog
+																   : WorkerThreadPool::EMode::EnableBacklog);
+										}
+									});
+							}
 						}
 					});
+				BlockRangeIndex += RangeCount;
 			}
 
-			for (uint32_t BlockIndex : FullBlockWorks)
+			for (uint32_t BlockIndex : PartialBlocks.FullBlockIndexes)
 			{
 				if (m_AbortFlag)
 				{
@@ -3289,271 +3159,9 @@ BuildsOperationUpdateFolder::DownloadBuildBlob(uint32_t									 RemoteChunkInde
 	}
 }
 
-BuildsOperationUpdateFolder::BlockRangeDescriptor
-BuildsOperationUpdateFolder::MergeBlockRanges(std::span<const BlockRangeDescriptor> Ranges)
-{
-	ZEN_ASSERT(Ranges.size() > 1);
-	const BlockRangeDescriptor& First = Ranges.front();
-	const BlockRangeDescriptor& Last  = Ranges.back();
-
-	return BlockRangeDescriptor{.BlockIndex			  = First.BlockIndex,
-								.RangeStart			  = First.RangeStart,
-								.RangeLength		  = Last.RangeStart + Last.RangeLength - First.RangeStart,
-								.ChunkBlockIndexStart = First.ChunkBlockIndexStart,
-								.ChunkBlockIndexCount = Last.ChunkBlockIndexStart + Last.ChunkBlockIndexCount - First.ChunkBlockIndexStart};
-}
-
-std::optional<std::vector<BuildsOperationUpdateFolder::BlockRangeDescriptor>>
-BuildsOperationUpdateFolder::MakeOptionalBlockRangeVector(uint64_t TotalBlockSize, const BlockRangeDescriptor& Range)
-{
-	if (Range.RangeLength == TotalBlockSize)
-	{
-		return {};
-	}
-	else
-	{
-		return std::vector<BlockRangeDescriptor>{Range};
-	}
-};
-
-const BuildsOperationUpdateFolder::BlockRangeLimit*
-BuildsOperationUpdateFolder::GetBlockRangeLimitForRange(std::span<const BlockRangeLimit>	  Limits,
-														uint64_t							  TotalBlockSize,
-														std::span<const BlockRangeDescriptor> Ranges)
-{
-	if (Ranges.size() > 1)
-	{
-		const std::uint64_t WantedSize =
-			std::accumulate(Ranges.begin(), Ranges.end(), uint64_t(0), [](uint64_t Current, const BlockRangeDescriptor& Range) {
-				return Current + Range.RangeLength;
-			});
-
-		const double RangeRequestedPercent = (WantedSize * 100.0) / TotalBlockSize;
-
-		for (const BlockRangeLimit& Limit : Limits)
-		{
-			if (RangeRequestedPercent >= Limit.SizePercent && Ranges.size() > Limit.MaxRangeCount)
-			{
-				return &Limit;
-			}
-		}
-	}
-	return nullptr;
-};
-
-std::vector<BuildsOperationUpdateFolder::BlockRangeDescriptor>
-BuildsOperationUpdateFolder::CollapseBlockRanges(const uint64_t AlwaysAcceptableGap, std::span<const BlockRangeDescriptor> BlockRanges)
-{
-	ZEN_ASSERT(BlockRanges.size() > 1);
-	std::vector<BlockRangeDescriptor> CollapsedBlockRanges;
-
-	auto BlockRangesIt = BlockRanges.begin();
-	CollapsedBlockRanges.push_back(*BlockRangesIt++);
-	for (; BlockRangesIt != BlockRanges.end(); BlockRangesIt++)
-	{
-		BlockRangeDescriptor& LastRange = CollapsedBlockRanges.back();
-
-		const uint64_t BothRangeSize = BlockRangesIt->RangeLength + LastRange.RangeLength;
-
-		const uint64_t Gap = BlockRangesIt->RangeStart - (LastRange.RangeStart + LastRange.RangeLength);
-		if (Gap <= Max(BothRangeSize / 16, AlwaysAcceptableGap))
-		{
-			LastRange.ChunkBlockIndexCount =
-				(BlockRangesIt->ChunkBlockIndexStart + BlockRangesIt->ChunkBlockIndexCount) - LastRange.ChunkBlockIndexStart;
-			LastRange.RangeLength = (BlockRangesIt->RangeStart + BlockRangesIt->RangeLength) - LastRange.RangeStart;
-		}
-		else
-		{
-			CollapsedBlockRanges.push_back(*BlockRangesIt);
-		}
-	}
-
-	return CollapsedBlockRanges;
-};
-
-uint64_t
-BuildsOperationUpdateFolder::CalculateNextGap(std::span<const BlockRangeDescriptor> BlockRanges)
-{
-	ZEN_ASSERT(BlockRanges.size() > 1);
-	uint64_t AcceptableGap = (uint64_t)-1;
-	for (size_t RangeIndex = 0; RangeIndex < BlockRanges.size() - 1; RangeIndex++)
-	{
-		const BlockRangeDescriptor& Range	  = BlockRanges[RangeIndex];
-		const BlockRangeDescriptor& NextRange = BlockRanges[RangeIndex + 1];
-
-		const uint64_t Gap = NextRange.RangeStart - (Range.RangeStart + Range.RangeLength);
-		AcceptableGap	   = Min(Gap, AcceptableGap);
-	}
-	AcceptableGap = RoundUp(AcceptableGap, 16u * 1024u);
-	return AcceptableGap;
-};
-
-std::optional<std::vector<BuildsOperationUpdateFolder::BlockRangeDescriptor>>
-BuildsOperationUpdateFolder::CalculateBlockRanges(uint32_t					   BlockIndex,
-												  const ChunkBlockDescription& BlockDescription,
-												  std::span<const uint32_t>	   BlockChunkIndexNeeded,
-												  bool						   LimitToSingleRange,
-												  const uint64_t			   ChunkStartOffsetInBlock,
-												  const uint64_t			   TotalBlockSize,
-												  uint64_t&					   OutTotalWantedChunksSize)
-{
-	ZEN_TRACE_CPU("CalculateBlockRanges");
-
-	std::vector<BlockRangeDescriptor> BlockRanges;
-	{
-		uint64_t			 CurrentOffset			   = ChunkStartOffsetInBlock;
-		uint32_t			 ChunkBlockIndex		   = 0;
-		uint32_t			 NeedBlockChunkIndexOffset = 0;
-		BlockRangeDescriptor NextRange{.BlockIndex = BlockIndex};
-		while (NeedBlockChunkIndexOffset < BlockChunkIndexNeeded.size() && ChunkBlockIndex < BlockDescription.ChunkRawHashes.size())
-		{
-			const uint32_t ChunkCompressedLength = BlockDescription.ChunkCompressedLengths[ChunkBlockIndex];
-			if (ChunkBlockIndex < BlockChunkIndexNeeded[NeedBlockChunkIndexOffset])
-			{
-				if (NextRange.RangeLength > 0)
-				{
-					BlockRanges.push_back(NextRange);
-					NextRange = {.BlockIndex = BlockIndex};
-				}
-				ChunkBlockIndex++;
-				CurrentOffset += ChunkCompressedLength;
-			}
-			else if (ChunkBlockIndex == BlockChunkIndexNeeded[NeedBlockChunkIndexOffset])
-			{
-				if (NextRange.RangeLength == 0)
-				{
-					NextRange.RangeStart		   = CurrentOffset;
-					NextRange.ChunkBlockIndexStart = ChunkBlockIndex;
-				}
-				NextRange.RangeLength += ChunkCompressedLength;
-				NextRange.ChunkBlockIndexCount++;
-				ChunkBlockIndex++;
-				CurrentOffset += ChunkCompressedLength;
-				NeedBlockChunkIndexOffset++;
-			}
-			else
-			{
-				ZEN_ASSERT(false);
-			}
-		}
-		if (NextRange.RangeLength > 0)
-		{
-			BlockRanges.push_back(NextRange);
-		}
-	}
-	ZEN_ASSERT(!BlockRanges.empty());
-
-	OutTotalWantedChunksSize =
-		std::accumulate(BlockRanges.begin(), BlockRanges.end(), uint64_t(0), [](uint64_t Current, const BlockRangeDescriptor& Range) {
-			return Current + Range.RangeLength;
-		});
-
-	double RangeWantedPercent = (OutTotalWantedChunksSize * 100.0) / TotalBlockSize;
-
-	if (BlockRanges.size() == 1)
-	{
-		if (m_Options.IsVerbose)
-		{
-			ZEN_OPERATION_LOG_INFO(m_LogOutput,
-								   "Range request of {} ({:.2f}%) using single range from block {} ({}) as is",
-								   NiceBytes(OutTotalWantedChunksSize),
-								   RangeWantedPercent,
-								   BlockDescription.BlockHash,
-								   NiceBytes(TotalBlockSize));
-		}
-		return BlockRanges;
-	}
-
-	if (LimitToSingleRange)
-	{
-		const BlockRangeDescriptor MergedRange = MergeBlockRanges(BlockRanges);
-		if (m_Options.IsVerbose)
-		{
-			const double RangeRequestedPercent = (MergedRange.RangeLength * 100.0) / TotalBlockSize;
-			const double WastedPercent		   = ((MergedRange.RangeLength - OutTotalWantedChunksSize) * 100.0) / MergedRange.RangeLength;
-
-			ZEN_OPERATION_LOG_INFO(
-				m_LogOutput,
-				"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) limited to single block range {} ({:.2f}%) wasting "
-				"{:.2f}% ({})",
-				NiceBytes(OutTotalWantedChunksSize),
-				RangeWantedPercent,
-				BlockRanges.size(),
-				BlockDescription.BlockHash,
-				NiceBytes(TotalBlockSize),
-				NiceBytes(MergedRange.RangeLength),
-				RangeRequestedPercent,
-				WastedPercent,
-				NiceBytes(MergedRange.RangeLength - OutTotalWantedChunksSize));
-		}
-		return MakeOptionalBlockRangeVector(TotalBlockSize, MergedRange);
-	}
-
-	if (RangeWantedPercent > FullBlockRangePercentLimit)
-	{
-		const BlockRangeDescriptor MergedRange = MergeBlockRanges(BlockRanges);
-		if (m_Options.IsVerbose)
-		{
-			const double RangeRequestedPercent = (MergedRange.RangeLength * 100.0) / TotalBlockSize;
-			const double WastedPercent		   = ((MergedRange.RangeLength - OutTotalWantedChunksSize) * 100.0) / MergedRange.RangeLength;
-
-			ZEN_OPERATION_LOG_INFO(
-				m_LogOutput,
-				"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) exceeds {}%. Merged to single block range {} "
-				"({:.2f}%) wasting {:.2f}% ({})",
-				NiceBytes(OutTotalWantedChunksSize),
-				RangeWantedPercent,
-				BlockRanges.size(),
-				BlockDescription.BlockHash,
-				NiceBytes(TotalBlockSize),
-				FullBlockRangePercentLimit,
-				NiceBytes(MergedRange.RangeLength),
-				RangeRequestedPercent,
-				WastedPercent,
-				NiceBytes(MergedRange.RangeLength - OutTotalWantedChunksSize));
-		}
-		return MakeOptionalBlockRangeVector(TotalBlockSize, MergedRange);
-	}
-
-	std::vector<BlockRangeDescriptor> CollapsedBlockRanges = CollapseBlockRanges(16u * 1024u, BlockRanges);
-	while (GetBlockRangeLimitForRange(ForceMergeLimits, TotalBlockSize, CollapsedBlockRanges))
-	{
-		CollapsedBlockRanges = CollapseBlockRanges(CalculateNextGap(CollapsedBlockRanges), CollapsedBlockRanges);
-	}
-
-	const std::uint64_t WantedCollapsedSize =
-		std::accumulate(CollapsedBlockRanges.begin(),
-						CollapsedBlockRanges.end(),
-						uint64_t(0),
-						[](uint64_t Current, const BlockRangeDescriptor& Range) { return Current + Range.RangeLength; });
-
-	const double CollapsedRangeRequestedPercent = (WantedCollapsedSize * 100.0) / TotalBlockSize;
-
-	if (m_Options.IsVerbose)
-	{
-		const double WastedPercent = ((WantedCollapsedSize - OutTotalWantedChunksSize) * 100.0) / WantedCollapsedSize;
-
-		ZEN_OPERATION_LOG_INFO(
-			m_LogOutput,
-			"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) collapsed to {} {:.2f}% using {} ranges wasting {:.2f}% "
-			"({})",
-			NiceBytes(OutTotalWantedChunksSize),
-			RangeWantedPercent,
-			BlockRanges.size(),
-			BlockDescription.BlockHash,
-			NiceBytes(TotalBlockSize),
-			NiceBytes(WantedCollapsedSize),
-			CollapsedRangeRequestedPercent,
-			CollapsedBlockRanges.size(),
-			WastedPercent,
-			NiceBytes(WantedCollapsedSize - OutTotalWantedChunksSize));
-	}
-	return CollapsedBlockRanges;
-}
-
 void
 BuildsOperationUpdateFolder::DownloadPartialBlock(
-	const BlockRangeDescriptor																  BlockRange,
+	const ChunkBlockAnalyser::BlockRangeDescriptor											  BlockRange,
 	const BlobsExistsResult&																  ExistsResult,
 	std::function<void(IoBuffer&& InMemoryBuffer, const std::filesystem::path& OnDiskPath)>&& OnDownloaded)
 {
diff --git a/src/zenremotestore/builds/buildstorageutil.cpp b/src/zenremotestore/builds/buildstorageutil.cpp
index 36b45e800..b249d7d52 100644
--- a/src/zenremotestore/builds/buildstorageutil.cpp
+++ b/src/zenremotestore/builds/buildstorageutil.cpp
@@ -63,11 +63,13 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 
 	std::string HostUrl;
 	std::string HostName;
+	double		HostLatencySec = -1.0;
 
 	std::string CacheUrl;
 	std::string CacheName;
 	bool		HostAssumeHttp2	 = ClientSettings.AssumeHttp2;
 	bool		CacheAssumeHttp2 = ClientSettings.AssumeHttp2;
+	double		CacheLatencySec	 = -1.0;
 
 	JupiterServerDiscovery DiscoveryResponse;
 	const std::string_view DiscoveryHost = Host.empty() ? OverrideHost : Host;
@@ -98,8 +100,9 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 			{
 				ZEN_OPERATION_LOG_INFO(Output, "Server endpoint at '{}/api/v1/status/servers' succeeded", OverrideHost);
 			}
-			HostUrl	 = OverrideHost;
-			HostName = GetHostNameFromUrl(OverrideHost);
+			HostUrl		   = OverrideHost;
+			HostName	   = GetHostNameFromUrl(OverrideHost);
+			HostLatencySec = TestResult.LatencySeconds;
 		}
 		else
 		{
@@ -137,6 +140,7 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 					HostUrl			= ServerEndpoint.BaseUrl;
 					HostAssumeHttp2 = ServerEndpoint.AssumeHttp2;
 					HostName		= ServerEndpoint.Name;
+					HostLatencySec	= TestResult.LatencySeconds;
 					break;
 				}
 				else
@@ -183,6 +187,7 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 						CacheUrl		 = CacheEndpoint.BaseUrl;
 						CacheAssumeHttp2 = CacheEndpoint.AssumeHttp2;
 						CacheName		 = CacheEndpoint.Name;
+						CacheLatencySec	 = TestResult.LatencySeconds;
 						break;
 					}
 				}
@@ -204,6 +209,7 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 							CacheUrl		 = ZenServerLocalHostUrl;
 							CacheAssumeHttp2 = false;
 							CacheName		 = "localhost";
+							CacheLatencySec	 = TestResult.LatencySeconds;
 						}
 					}
 				});
@@ -219,8 +225,9 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 		if (ZenCacheEndpointTestResult TestResult = TestZenCacheEndpoint(ZenCacheHost, /*AssumeHttp2*/ false, ClientSettings.Verbose);
 			TestResult.Success)
 		{
-			CacheUrl  = ZenCacheHost;
-			CacheName = GetHostNameFromUrl(ZenCacheHost);
+			CacheUrl		= ZenCacheHost;
+			CacheName		= GetHostNameFromUrl(ZenCacheHost);
+			CacheLatencySec = TestResult.LatencySeconds;
 		}
 		else
 		{
@@ -231,10 +238,12 @@ ResolveBuildStorage(OperationLogOutput&		  Output,
 	return BuildStorageResolveResult{.HostUrl		  = HostUrl,
 									 .HostName		  = HostName,
 									 .HostAssumeHttp2 = HostAssumeHttp2,
+									 .HostLatencySec  = HostLatencySec,
 
 									 .CacheUrl		   = CacheUrl,
 									 .CacheName		   = CacheName,
-									 .CacheAssumeHttp2 = CacheAssumeHttp2};
+									 .CacheAssumeHttp2 = CacheAssumeHttp2,
+									 .CacheLatencySec  = CacheLatencySec};
 }
 
 std::vector<ChunkBlockDescription>
diff --git a/src/zenremotestore/chunking/chunkblock.cpp b/src/zenremotestore/chunking/chunkblock.cpp
index c4d8653f4..d203e0292 100644
--- a/src/zenremotestore/chunking/chunkblock.cpp
+++ b/src/zenremotestore/chunking/chunkblock.cpp
@@ -10,18 +10,17 @@
 
 #include <zenremotestore/operationlogoutput.h>
 
+#include <numeric>
 #include <vector>
 
 ZEN_THIRD_PARTY_INCLUDES_START
 #include <tsl/robin_map.h>
+#include <tsl/robin_set.h>
 ZEN_THIRD_PARTY_INCLUDES_END
 
 #if ZEN_WITH_TESTS
 #	include <zencore/testing.h>
 #	include <zencore/testutils.h>
-
-#	include <unordered_map>
-#	include <numeric>
 #endif	// ZEN_WITH_TESTS
 
 namespace zen {
@@ -455,6 +454,578 @@ FindReuseBlocks(OperationLogOutput&						  Output,
 	return FilteredReuseBlockIndexes;
 }
 
+ChunkBlockAnalyser::ChunkBlockAnalyser(OperationLogOutput&					  LogOutput,
+									   std::span<const ChunkBlockDescription> BlockDescriptions,
+									   const Options&						  Options)
+: m_LogOutput(LogOutput)
+, m_BlockDescriptions(BlockDescriptions)
+, m_Options(Options)
+{
+}
+
+std::vector<ChunkBlockAnalyser::NeededBlock>
+ChunkBlockAnalyser::GetNeeded(const tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& ChunkHashToChunkIndex,
+							  std::function<bool(uint32_t ChunkIndex)>&&			  NeedsBlockChunk)
+{
+	ZEN_TRACE_CPU("ChunkBlockAnalyser::GetNeeded");
+
+	std::vector<NeededBlock> Result;
+
+	std::vector<bool> ChunkIsNeeded(ChunkHashToChunkIndex.size());
+	for (uint32_t ChunkIndex = 0; ChunkIndex < ChunkHashToChunkIndex.size(); ChunkIndex++)
+	{
+		ChunkIsNeeded[ChunkIndex] = NeedsBlockChunk(ChunkIndex);
+	}
+
+	std::vector<uint64_t> BlockSlack(m_BlockDescriptions.size(), 0u);
+	for (uint32_t BlockIndex = 0; BlockIndex < m_BlockDescriptions.size(); BlockIndex++)
+	{
+		const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
+
+		uint64_t BlockUsedSize = 0;
+		uint64_t BlockSize	   = 0;
+
+		for (uint32_t ChunkBlockIndex = 0; ChunkBlockIndex < BlockDescription.ChunkRawHashes.size(); ChunkBlockIndex++)
+		{
+			const IoHash& ChunkHash = BlockDescription.ChunkRawHashes[ChunkBlockIndex];
+			if (auto It = ChunkHashToChunkIndex.find(ChunkHash); It != ChunkHashToChunkIndex.end())
+			{
+				const uint32_t RemoteChunkIndex = It->second;
+				if (ChunkIsNeeded[RemoteChunkIndex])
+				{
+					BlockUsedSize += BlockDescription.ChunkCompressedLengths[ChunkBlockIndex];
+				}
+			}
+			BlockSize += BlockDescription.ChunkCompressedLengths[ChunkBlockIndex];
+		}
+		BlockSlack[BlockIndex] = BlockSize - BlockUsedSize;
+	}
+
+	std::vector<uint32_t> BlockOrder(m_BlockDescriptions.size());
+	std::iota(BlockOrder.begin(), BlockOrder.end(), 0);
+
+	std::sort(BlockOrder.begin(), BlockOrder.end(), [&BlockSlack](uint32_t Lhs, uint32_t Rhs) {
+		return BlockSlack[Lhs] < BlockSlack[Rhs];
+	});
+
+	std::vector<bool> ChunkIsPickedUp(ChunkHashToChunkIndex.size(), false);
+
+	for (uint32_t BlockIndex : BlockOrder)
+	{
+		const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
+
+		std::vector<uint32_t> BlockChunkIndexNeeded;
+
+		for (uint32_t ChunkBlockIndex = 0; ChunkBlockIndex < BlockDescription.ChunkRawHashes.size(); ChunkBlockIndex++)
+		{
+			const IoHash& ChunkHash = BlockDescription.ChunkRawHashes[ChunkBlockIndex];
+			if (auto It = ChunkHashToChunkIndex.find(ChunkHash); It != ChunkHashToChunkIndex.end())
+			{
+				const uint32_t RemoteChunkIndex = It->second;
+				if (ChunkIsNeeded[RemoteChunkIndex])
+				{
+					if (!ChunkIsPickedUp[RemoteChunkIndex])
+					{
+						ChunkIsPickedUp[RemoteChunkIndex] = true;
+						BlockChunkIndexNeeded.push_back(ChunkBlockIndex);
+					}
+				}
+			}
+			else
+			{
+				ZEN_DEBUG("Chunk {} not found in block {}", ChunkHash, BlockDescription.BlockHash);
+			}
+		}
+
+		if (!BlockChunkIndexNeeded.empty())
+		{
+			Result.push_back(NeededBlock{.BlockIndex = BlockIndex, .ChunkIndexes = std::move(BlockChunkIndexNeeded)});
+		}
+	}
+	return Result;
+}
+
+ChunkBlockAnalyser::BlockResult
+ChunkBlockAnalyser::CalculatePartialBlockDownloads(std::span<const NeededBlock>				  NeededBlocks,
+												   std::span<const EPartialBlockDownloadMode> BlockPartialDownloadModes)
+{
+	ZEN_TRACE_CPU("ChunkBlockAnalyser::CalculatePartialBlockDownloads");
+
+	Stopwatch PartialAnalisysTimer;
+
+	ChunkBlockAnalyser::BlockResult Result;
+
+	uint64_t IdealDownloadTotalSize	  = 0;
+	uint64_t AllBlocksTotalBlocksSize = 0;
+
+	for (const NeededBlock& NeededBlock : NeededBlocks)
+	{
+		const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[NeededBlock.BlockIndex];
+
+		std::span<const uint32_t> BlockChunkIndexNeeded(NeededBlock.ChunkIndexes);
+		if (!NeededBlock.ChunkIndexes.empty())
+		{
+			bool WantsToDoPartialBlockDownload = NeededBlock.ChunkIndexes.size() < BlockDescription.ChunkRawHashes.size();
+			bool CanDoPartialBlockDownload	   = (BlockDescription.HeaderSize > 0) &&
+											 (BlockDescription.ChunkCompressedLengths.size() == BlockDescription.ChunkRawHashes.size());
+
+			EPartialBlockDownloadMode PartialBlockDownloadMode = BlockPartialDownloadModes[NeededBlock.BlockIndex];
+
+			const uint32_t ChunkStartOffsetInBlock =
+				gsl::narrow<uint32_t>(CompressedBuffer::GetHeaderSizeForNoneEncoder() + BlockDescription.HeaderSize);
+
+			const uint64_t TotalBlockSize = std::accumulate(BlockDescription.ChunkCompressedLengths.begin(),
+															BlockDescription.ChunkCompressedLengths.end(),
+															std::uint64_t(ChunkStartOffsetInBlock));
+
+			AllBlocksTotalBlocksSize += TotalBlockSize;
+
+			if ((PartialBlockDownloadMode != EPartialBlockDownloadMode::Off) && WantsToDoPartialBlockDownload && CanDoPartialBlockDownload)
+			{
+				ZEN_TRACE_CPU("PartialBlockAnalysis");
+
+				uint64_t										 TotalWantedChunksSize = 0;
+				std::optional<std::vector<BlockRangeDescriptor>> MaybeBlockRanges	   = CalculateBlockRanges(NeededBlock.BlockIndex,
+																										  BlockDescription,
+																										  NeededBlock.ChunkIndexes,
+																										  PartialBlockDownloadMode,
+																										  ChunkStartOffsetInBlock,
+																										  TotalBlockSize,
+																										  TotalWantedChunksSize);
+				ZEN_ASSERT(TotalWantedChunksSize <= TotalBlockSize);
+				IdealDownloadTotalSize += TotalWantedChunksSize;
+
+				if (MaybeBlockRanges.has_value())
+				{
+					std::vector<BlockRangeDescriptor> BlockRanges = MaybeBlockRanges.value();
+					ZEN_ASSERT(!BlockRanges.empty());
+
+					uint64_t RequestedSize =
+						std::accumulate(BlockRanges.begin(),
+										BlockRanges.end(),
+										uint64_t(0),
+										[](uint64_t Current, const BlockRangeDescriptor& Range) { return Current + Range.RangeLength; });
+
+					if (PartialBlockDownloadMode != EPartialBlockDownloadMode::Exact && BlockRanges.size() > 1)
+					{
+						// TODO: Once we have support in our http client to request multiple ranges in one request this
+						// logic would need to change as the per-request overhead would go away
+
+						const double LatencySec = PartialBlockDownloadMode == EPartialBlockDownloadMode::MultiRangeHighSpeed
+													  ? m_Options.HostHighSpeedLatencySec
+													  : m_Options.HostLatencySec;
+						if (LatencySec > 0)
+						{
+							const uint64_t BytesPerSec = PartialBlockDownloadMode == EPartialBlockDownloadMode::MultiRangeHighSpeed
+															 ? m_Options.HostHighSpeedBytesPerSec
+															 : m_Options.HostSpeedBytesPerSec;
+
+							const double   ExtraRequestTimeSec	 = (BlockRanges.size() - 1) * LatencySec;
+							const uint64_t ExtraRequestTimeBytes = uint64_t(ExtraRequestTimeSec * BytesPerSec);
+
+							const uint64_t FullRangeSize =
+								BlockRanges.back().RangeStart + BlockRanges.back().RangeLength - BlockRanges.front().RangeStart;
+
+							if (ExtraRequestTimeBytes + RequestedSize >= FullRangeSize)
+							{
+								BlockRanges = std::vector<BlockRangeDescriptor>{MergeBlockRanges(BlockRanges)};
+
+								if (m_Options.IsVerbose)
+								{
+									ZEN_OPERATION_LOG_INFO(m_LogOutput,
+														   "Merging {} chunks ({}) from block {} ({}) to single request (extra bytes {})",
+														   NeededBlock.ChunkIndexes.size(),
+														   NiceBytes(RequestedSize),
+														   BlockDescription.BlockHash,
+														   NiceBytes(TotalBlockSize),
+														   NiceBytes(BlockRanges.front().RangeLength - RequestedSize));
+								}
+
+								RequestedSize = BlockRanges.front().RangeLength;
+							}
+						}
+					}
+
+					if ((PartialBlockDownloadMode != EPartialBlockDownloadMode::Exact) &&
+						((TotalBlockSize - RequestedSize) < (512u * 1024u)))
+					{
+						if (m_Options.IsVerbose)
+						{
+							ZEN_OPERATION_LOG_INFO(m_LogOutput,
+												   "Requesting {} chunks ({}) from block {} ({}) using full block request due to small "
+												   "total slack (extra bytes {})",
+												   NeededBlock.ChunkIndexes.size(),
+												   NiceBytes(RequestedSize),
+												   BlockDescription.BlockHash,
+												   NiceBytes(TotalBlockSize),
+												   NiceBytes(TotalBlockSize - TotalWantedChunksSize));
+						}
+						Result.FullBlockIndexes.push_back(NeededBlock.BlockIndex);
+					}
+					else
+					{
+						Result.BlockRanges.insert(Result.BlockRanges.end(), BlockRanges.begin(), BlockRanges.end());
+
+						if (m_Options.IsVerbose)
+						{
+							ZEN_OPERATION_LOG_INFO(m_LogOutput,
+												   "Requesting {} chunks ({}) from block {} ({}) using {} requests (extra bytes {})",
+												   NeededBlock.ChunkIndexes.size(),
+												   NiceBytes(RequestedSize),
+												   BlockDescription.BlockHash,
+												   NiceBytes(TotalBlockSize),
+												   BlockRanges.size(),
+												   NiceBytes(RequestedSize - TotalWantedChunksSize));
+						}
+					}
+				}
+				else
+				{
+					Result.FullBlockIndexes.push_back(NeededBlock.BlockIndex);
+				}
+			}
+			else
+			{
+				Result.FullBlockIndexes.push_back(NeededBlock.BlockIndex);
+				IdealDownloadTotalSize += TotalBlockSize;
+			}
+		}
+	}
+
+	if (!Result.BlockRanges.empty() && !m_Options.IsQuiet)
+	{
+		tsl::robin_set<uint32_t> PartialBlockIndexes;
+		uint64_t				 PartialBlocksTotalSize = std::accumulate(Result.BlockRanges.begin(),
+														  Result.BlockRanges.end(),
+														  uint64_t(0u),
+														  [&](uint64_t Current, const BlockRangeDescriptor& Range) {
+															  PartialBlockIndexes.insert(Range.BlockIndex);
+															  return Current + Range.RangeLength;
+														  });
+
+		uint64_t FullBlocksTotalSize =
+			std::accumulate(Result.FullBlockIndexes.begin(),
+							Result.FullBlockIndexes.end(),
+							uint64_t(0u),
+							[&](uint64_t Current, uint32_t BlockIndex) {
+								const ChunkBlockDescription& BlockDescription = m_BlockDescriptions[BlockIndex];
+								uint32_t					 CurrentOffset =
+									gsl::narrow<uint32_t>(CompressedBuffer::GetHeaderSizeForNoneEncoder() + BlockDescription.HeaderSize);
+
+								return Current + std::accumulate(BlockDescription.ChunkCompressedLengths.begin(),
+																 BlockDescription.ChunkCompressedLengths.end(),
+																 std::uint64_t(CurrentOffset));
+							});
+
+		uint64_t PartialBlockRequestCount = Result.BlockRanges.size();
+		uint64_t PartialBlockCount		  = PartialBlockIndexes.size();
+
+		uint64_t TotalExtraPartialBlocksRequestCount = PartialBlockRequestCount - PartialBlockCount;
+		uint64_t ActualPartialDownloadTotalSize		 = FullBlocksTotalSize + PartialBlocksTotalSize;
+
+		uint64_t IdealSkippedSize  = AllBlocksTotalBlocksSize - IdealDownloadTotalSize;
+		uint64_t ActualSkippedSize = AllBlocksTotalBlocksSize - ActualPartialDownloadTotalSize;
+
+		double PercentOfIdealPartialSkippedSize = (ActualSkippedSize * 100.0) / IdealSkippedSize;
+
+		ZEN_OPERATION_LOG_INFO(m_LogOutput,
+							   "Analysis of partial block requests saves download of {} out of {}, {:.1f}% of possible {} using {} extra "
+							   "requests. Completed in {}",
+							   NiceBytes(ActualSkippedSize),
+							   NiceBytes(AllBlocksTotalBlocksSize),
+							   PercentOfIdealPartialSkippedSize,
+							   NiceBytes(IdealSkippedSize),
+							   TotalExtraPartialBlocksRequestCount,
+							   NiceTimeSpanMs(PartialAnalisysTimer.GetElapsedTimeMs()));
+	}
+
+	return Result;
+}
+
+ChunkBlockAnalyser::BlockRangeDescriptor
+ChunkBlockAnalyser::MergeBlockRanges(std::span<const BlockRangeDescriptor> Ranges)
+{
+	ZEN_ASSERT(Ranges.size() > 1);
+	const BlockRangeDescriptor& First = Ranges.front();
+	const BlockRangeDescriptor& Last  = Ranges.back();
+
+	return BlockRangeDescriptor{.BlockIndex			  = First.BlockIndex,
+								.RangeStart			  = First.RangeStart,
+								.RangeLength		  = Last.RangeStart + Last.RangeLength - First.RangeStart,
+								.ChunkBlockIndexStart = First.ChunkBlockIndexStart,
+								.ChunkBlockIndexCount = Last.ChunkBlockIndexStart + Last.ChunkBlockIndexCount - First.ChunkBlockIndexStart};
+}
+
+std::optional<std::vector<ChunkBlockAnalyser::BlockRangeDescriptor>>
+ChunkBlockAnalyser::MakeOptionalBlockRangeVector(uint64_t TotalBlockSize, const BlockRangeDescriptor& Range)
+{
+	if (Range.RangeLength == TotalBlockSize)
+	{
+		return {};
+	}
+	else
+	{
+		return std::vector<BlockRangeDescriptor>{Range};
+	}
+};
+
+const ChunkBlockAnalyser::BlockRangeLimit*
+ChunkBlockAnalyser::GetBlockRangeLimitForRange(std::span<const BlockRangeLimit>		 Limits,
+											   uint64_t								 TotalBlockSize,
+											   std::span<const BlockRangeDescriptor> Ranges)
+{
+	if (Ranges.size() > 1)
+	{
+		const std::uint64_t WantedSize =
+			std::accumulate(Ranges.begin(), Ranges.end(), uint64_t(0), [](uint64_t Current, const BlockRangeDescriptor& Range) {
+				return Current + Range.RangeLength;
+			});
+
+		const double RangeRequestedPercent = (WantedSize * 100.0) / TotalBlockSize;
+
+		for (const BlockRangeLimit& Limit : Limits)
+		{
+			if (RangeRequestedPercent >= Limit.SizePercent && Ranges.size() > Limit.MaxRangeCount)
+			{
+				return &Limit;
+			}
+		}
+	}
+	return nullptr;
+};
+
+std::vector<ChunkBlockAnalyser::BlockRangeDescriptor>
+ChunkBlockAnalyser::CollapseBlockRanges(const uint64_t AlwaysAcceptableGap, std::span<const BlockRangeDescriptor> BlockRanges)
+{
+	ZEN_ASSERT(BlockRanges.size() > 1);
+	std::vector<BlockRangeDescriptor> CollapsedBlockRanges;
+
+	auto BlockRangesIt = BlockRanges.begin();
+	CollapsedBlockRanges.push_back(*BlockRangesIt++);
+	for (; BlockRangesIt != BlockRanges.end(); BlockRangesIt++)
+	{
+		BlockRangeDescriptor& LastRange = CollapsedBlockRanges.back();
+
+		const uint64_t BothRangeSize = BlockRangesIt->RangeLength + LastRange.RangeLength;
+
+		const uint64_t Gap = BlockRangesIt->RangeStart - (LastRange.RangeStart + LastRange.RangeLength);
+		if (Gap <= Max(BothRangeSize / 16, AlwaysAcceptableGap))
+		{
+			LastRange.ChunkBlockIndexCount =
+				(BlockRangesIt->ChunkBlockIndexStart + BlockRangesIt->ChunkBlockIndexCount) - LastRange.ChunkBlockIndexStart;
+			LastRange.RangeLength = (BlockRangesIt->RangeStart + BlockRangesIt->RangeLength) - LastRange.RangeStart;
+		}
+		else
+		{
+			CollapsedBlockRanges.push_back(*BlockRangesIt);
+		}
+	}
+
+	return CollapsedBlockRanges;
+};
+
+uint64_t
+ChunkBlockAnalyser::CalculateNextGap(const uint64_t AlwaysAcceptableGap, std::span<const BlockRangeDescriptor> BlockRanges)
+{
+	ZEN_ASSERT(BlockRanges.size() > 1);
+	uint64_t AcceptableGap = (uint64_t)-1;
+	for (size_t RangeIndex = 0; RangeIndex < BlockRanges.size() - 1; RangeIndex++)
+	{
+		const BlockRangeDescriptor& Range	  = BlockRanges[RangeIndex];
+		const BlockRangeDescriptor& NextRange = BlockRanges[RangeIndex + 1];
+
+		const uint64_t Gap = NextRange.RangeStart - (Range.RangeStart + Range.RangeLength);
+		AcceptableGap	   = Min(Gap, AcceptableGap);
+	}
+	AcceptableGap = RoundUp(AcceptableGap, AlwaysAcceptableGap);
+	return AcceptableGap;
+};
+
+std::optional<std::vector<ChunkBlockAnalyser::BlockRangeDescriptor>>
+ChunkBlockAnalyser::CalculateBlockRanges(uint32_t					  BlockIndex,
+										 const ChunkBlockDescription& BlockDescription,
+										 std::span<const uint32_t>	  BlockChunkIndexNeeded,
+										 EPartialBlockDownloadMode	  PartialBlockDownloadMode,
+										 const uint64_t				  ChunkStartOffsetInBlock,
+										 const uint64_t				  TotalBlockSize,
+										 uint64_t&					  OutTotalWantedChunksSize)
+{
+	ZEN_TRACE_CPU("CalculateBlockRanges");
+
+	if (PartialBlockDownloadMode == EPartialBlockDownloadMode::Off)
+	{
+		return {};
+	}
+
+	std::vector<BlockRangeDescriptor> BlockRanges;
+	{
+		uint64_t			 CurrentOffset			   = ChunkStartOffsetInBlock;
+		uint32_t			 ChunkBlockIndex		   = 0;
+		uint32_t			 NeedBlockChunkIndexOffset = 0;
+		BlockRangeDescriptor NextRange{.BlockIndex = BlockIndex};
+		while (NeedBlockChunkIndexOffset < BlockChunkIndexNeeded.size() && ChunkBlockIndex < BlockDescription.ChunkRawHashes.size())
+		{
+			const uint32_t ChunkCompressedLength = BlockDescription.ChunkCompressedLengths[ChunkBlockIndex];
+			if (ChunkBlockIndex < BlockChunkIndexNeeded[NeedBlockChunkIndexOffset])
+			{
+				if (NextRange.RangeLength > 0)
+				{
+					BlockRanges.push_back(NextRange);
+					NextRange = {.BlockIndex = BlockIndex};
+				}
+				ChunkBlockIndex++;
+				CurrentOffset += ChunkCompressedLength;
+			}
+			else if (ChunkBlockIndex == BlockChunkIndexNeeded[NeedBlockChunkIndexOffset])
+			{
+				if (NextRange.RangeLength == 0)
+				{
+					NextRange.RangeStart		   = CurrentOffset;
+					NextRange.ChunkBlockIndexStart = ChunkBlockIndex;
+				}
+				NextRange.RangeLength += ChunkCompressedLength;
+				NextRange.ChunkBlockIndexCount++;
+				ChunkBlockIndex++;
+				CurrentOffset += ChunkCompressedLength;
+				NeedBlockChunkIndexOffset++;
+			}
+			else
+			{
+				ZEN_ASSERT(false);
+			}
+		}
+		if (NextRange.RangeLength > 0)
+		{
+			BlockRanges.push_back(NextRange);
+		}
+	}
+	ZEN_ASSERT(!BlockRanges.empty());
+
+	OutTotalWantedChunksSize =
+		std::accumulate(BlockRanges.begin(), BlockRanges.end(), uint64_t(0), [](uint64_t Current, const BlockRangeDescriptor& Range) {
+			return Current + Range.RangeLength;
+		});
+
+	double RangeWantedPercent = (OutTotalWantedChunksSize * 100.0) / TotalBlockSize;
+
+	if (BlockRanges.size() == 1)
+	{
+		if (m_Options.IsVerbose)
+		{
+			ZEN_OPERATION_LOG_INFO(m_LogOutput,
+								   "Range request of {} ({:.2f}%) using single range from block {} ({}) as is",
+								   NiceBytes(OutTotalWantedChunksSize),
+								   RangeWantedPercent,
+								   BlockDescription.BlockHash,
+								   NiceBytes(TotalBlockSize));
+		}
+		return BlockRanges;
+	}
+
+	if (PartialBlockDownloadMode == EPartialBlockDownloadMode::Exact)
+	{
+		if (m_Options.IsVerbose)
+		{
+			ZEN_OPERATION_LOG_INFO(m_LogOutput,
+								   "Range request of {} ({:.2f}%) using {} ranges from block {} ({})",
+								   NiceBytes(OutTotalWantedChunksSize),
+								   RangeWantedPercent,
+								   BlockRanges.size(),
+								   BlockDescription.BlockHash,
+								   NiceBytes(TotalBlockSize));
+		}
+		return BlockRanges;
+	}
+
+	if (PartialBlockDownloadMode == EPartialBlockDownloadMode::SingleRange)
+	{
+		const BlockRangeDescriptor MergedRange = MergeBlockRanges(BlockRanges);
+		if (m_Options.IsVerbose)
+		{
+			const double RangeRequestedPercent = (MergedRange.RangeLength * 100.0) / TotalBlockSize;
+			const double WastedPercent		   = ((MergedRange.RangeLength - OutTotalWantedChunksSize) * 100.0) / MergedRange.RangeLength;
+
+			ZEN_OPERATION_LOG_INFO(
+				m_LogOutput,
+				"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) limited to single block range {} ({:.2f}%) wasting "
+				"{:.2f}% ({})",
+				NiceBytes(OutTotalWantedChunksSize),
+				RangeWantedPercent,
+				BlockRanges.size(),
+				BlockDescription.BlockHash,
+				NiceBytes(TotalBlockSize),
+				NiceBytes(MergedRange.RangeLength),
+				RangeRequestedPercent,
+				WastedPercent,
+				NiceBytes(MergedRange.RangeLength - OutTotalWantedChunksSize));
+		}
+		return MakeOptionalBlockRangeVector(TotalBlockSize, MergedRange);
+	}
+
+	if (RangeWantedPercent > FullBlockRangePercentLimit)
+	{
+		const BlockRangeDescriptor MergedRange = MergeBlockRanges(BlockRanges);
+		if (m_Options.IsVerbose)
+		{
+			const double RangeRequestedPercent = (MergedRange.RangeLength * 100.0) / TotalBlockSize;
+			const double WastedPercent		   = ((MergedRange.RangeLength - OutTotalWantedChunksSize) * 100.0) / MergedRange.RangeLength;
+
+			ZEN_OPERATION_LOG_INFO(
+				m_LogOutput,
+				"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) exceeds {}%. Merged to single block range {} "
+				"({:.2f}%) wasting {:.2f}% ({})",
+				NiceBytes(OutTotalWantedChunksSize),
+				RangeWantedPercent,
+				BlockRanges.size(),
+				BlockDescription.BlockHash,
+				NiceBytes(TotalBlockSize),
+				FullBlockRangePercentLimit,
+				NiceBytes(MergedRange.RangeLength),
+				RangeRequestedPercent,
+				WastedPercent,
+				NiceBytes(MergedRange.RangeLength - OutTotalWantedChunksSize));
+		}
+		return MakeOptionalBlockRangeVector(TotalBlockSize, MergedRange);
+	}
+
+	const uint64_t AlwaysAcceptableGap = 4u * 1024u;
+
+	std::vector<BlockRangeDescriptor> CollapsedBlockRanges = CollapseBlockRanges(AlwaysAcceptableGap, BlockRanges);
+	while (GetBlockRangeLimitForRange(ForceMergeLimits, TotalBlockSize, CollapsedBlockRanges))
+	{
+		CollapsedBlockRanges = CollapseBlockRanges(CalculateNextGap(AlwaysAcceptableGap, CollapsedBlockRanges), CollapsedBlockRanges);
+	}
+
+	const std::uint64_t WantedCollapsedSize =
+		std::accumulate(CollapsedBlockRanges.begin(),
+						CollapsedBlockRanges.end(),
+						uint64_t(0),
+						[](uint64_t Current, const BlockRangeDescriptor& Range) { return Current + Range.RangeLength; });
+
+	const double CollapsedRangeRequestedPercent = (WantedCollapsedSize * 100.0) / TotalBlockSize;
+
+	if (m_Options.IsVerbose)
+	{
+		const double WastedPercent = ((WantedCollapsedSize - OutTotalWantedChunksSize) * 100.0) / WantedCollapsedSize;
+
+		ZEN_OPERATION_LOG_INFO(
+			m_LogOutput,
+			"Range request of {} ({:.2f}%) using {} ranges from block {} ({}) collapsed to {} {:.2f}% using {} ranges wasting {:.2f}% "
+			"({})",
+			NiceBytes(OutTotalWantedChunksSize),
+			RangeWantedPercent,
+			BlockRanges.size(),
+			BlockDescription.BlockHash,
+			NiceBytes(TotalBlockSize),
+			NiceBytes(WantedCollapsedSize),
+			CollapsedRangeRequestedPercent,
+			CollapsedBlockRanges.size(),
+			WastedPercent,
+			NiceBytes(WantedCollapsedSize - OutTotalWantedChunksSize));
+	}
+	return CollapsedBlockRanges;
+}
+
 #if ZEN_WITH_TESTS
 
 namespace testutils {
@@ -476,7 +1047,7 @@ namespace testutils {
 
 }  // namespace testutils
 
-TEST_CASE("project.store.block")
+TEST_CASE("chunkblock.block")
 {
 	using namespace std::literals;
 	using namespace testutils;
@@ -504,7 +1075,7 @@ TEST_CASE("project.store.block")
 		HeaderSize));
 }
 
-TEST_CASE("project.store.reuseblocks")
+TEST_CASE("chunkblock.reuseblocks")
 {
 	using namespace std::literals;
 	using namespace testutils;
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h b/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
index bb5b1c5f4..f25ce5b5e 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstoragecache.h
@@ -65,6 +65,7 @@ struct ZenCacheEndpointTestResult
 {
 	bool		Success = false;
 	std::string FailureReason;
+	double		LatencySeconds = -1.0;
 };
 
 ZenCacheEndpointTestResult TestZenCacheEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose);
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h b/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
index 9e5bf8d91..31733569e 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
@@ -7,7 +7,9 @@
 #include <zencore/uid.h>
 #include <zencore/zencore.h>
 #include <zenremotestore/builds/buildstoragecache.h>
+#include <zenremotestore/chunking/chunkblock.h>
 #include <zenremotestore/chunking/chunkedcontent.h>
+#include <zenremotestore/partialblockrequestmode.h>
 #include <zenutil/bufferedwritefilecache.h>
 
 #include <atomic>
@@ -108,17 +110,6 @@ struct RebuildFolderStateStatistics
 	uint64_t			  FinalizeTreeElapsedWallTimeUs = 0;
 };
 
-enum EPartialBlockRequestMode
-{
-	Off,
-	ZenCacheOnly,
-	Mixed,
-	All,
-	Invalid
-};
-
-EPartialBlockRequestMode PartialBlockRequestModeFromString(const std::string_view ModeString);
-
 std::filesystem::path ZenStateFilePath(const std::filesystem::path& ZenFolderPath);
 std::filesystem::path ZenTempFolderPath(const std::filesystem::path& ZenFolderPath);
 
@@ -218,33 +209,6 @@ private:
 		uint64_t			   ElapsedTimeMs = 0;
 	};
 
-	struct BlockRangeDescriptor
-	{
-		uint32_t BlockIndex			  = (uint32_t)-1;
-		uint64_t RangeStart			  = 0;
-		uint64_t RangeLength		  = 0;
-		uint32_t ChunkBlockIndexStart = 0;
-		uint32_t ChunkBlockIndexCount = 0;
-	};
-
-	struct BlockRangeLimit
-	{
-		uint16_t SizePercent;
-		uint16_t MaxRangeCount;
-	};
-
-	static constexpr uint16_t FullBlockRangePercentLimit = 95;
-
-	static constexpr BuildsOperationUpdateFolder::BlockRangeLimit ForceMergeLimits[] = {
-		{.SizePercent = FullBlockRangePercentLimit, .MaxRangeCount = 1},
-		{.SizePercent = 90, .MaxRangeCount = 2},
-		{.SizePercent = 85, .MaxRangeCount = 8},
-		{.SizePercent = 80, .MaxRangeCount = 16},
-		{.SizePercent = 70, .MaxRangeCount = 32},
-		{.SizePercent = 60, .MaxRangeCount = 48},
-		{.SizePercent = 2, .MaxRangeCount = 56},
-		{.SizePercent = 0, .MaxRangeCount = 64}};
-
 	void				  ScanCacheFolder(tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& OutCachedChunkHashesFound,
 										  tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& OutCachedSequenceHashesFound);
 	void				  ScanTempBlocksFolder(tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& OutCachedBlocksFound);
@@ -299,25 +263,9 @@ private:
 						   ParallelWork&							 Work,
 						   std::function<void(IoBuffer&& Payload)>&& OnDownloaded);
 
-	BlockRangeDescriptor							 MergeBlockRanges(std::span<const BlockRangeDescriptor> Ranges);
-	std::optional<std::vector<BlockRangeDescriptor>> MakeOptionalBlockRangeVector(uint64_t					  TotalBlockSize,
-																				  const BlockRangeDescriptor& Range);
-	const BlockRangeLimit*							 GetBlockRangeLimitForRange(std::span<const BlockRangeLimit>	  Limits,
-																				uint64_t							  TotalBlockSize,
-																				std::span<const BlockRangeDescriptor> Ranges);
-	std::vector<BlockRangeDescriptor>				 CollapseBlockRanges(const uint64_t						   AlwaysAcceptableGap,
-																		 std::span<const BlockRangeDescriptor> BlockRanges);
-	uint64_t										 CalculateNextGap(std::span<const BlockRangeDescriptor> BlockRanges);
-	std::optional<std::vector<BlockRangeDescriptor>> CalculateBlockRanges(uint32_t					   BlockIndex,
-																		  const ChunkBlockDescription& BlockDescription,
-																		  std::span<const uint32_t>	   BlockChunkIndexNeeded,
-																		  bool						   LimitToSingleRange,
-																		  const uint64_t			   ChunkStartOffsetInBlock,
-																		  const uint64_t			   TotalBlockSize,
-																		  uint64_t&					   OutTotalWantedChunksSize);
-	void											 DownloadPartialBlock(const BlockRangeDescriptor																BlockRange,
-																		  const BlobsExistsResult&																	ExistsResult,
-																		  std::function<void(IoBuffer&& InMemoryBuffer, const std::filesystem::path& OnDiskPath)>&& OnDownloaded);
+	void DownloadPartialBlock(const ChunkBlockAnalyser::BlockRangeDescriptor											BlockRange,
+							  const BlobsExistsResult&																	ExistsResult,
+							  std::function<void(IoBuffer&& InMemoryBuffer, const std::filesystem::path& OnDiskPath)>&& OnDownloaded);
 
 	std::vector<uint32_t> WriteLocalChunkToCache(CloneQueryInterface*					   CloneQuery,
 												 const CopyChunkData&					   CopyData,
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h b/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
index ab3037c89..4b85d8f1e 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstorageutil.h
@@ -17,10 +17,12 @@ struct BuildStorageResolveResult
 	std::string HostUrl;
 	std::string HostName;
 	bool		HostAssumeHttp2 = false;
+	double		HostLatencySec	= -1.0;
 
 	std::string CacheUrl;
 	std::string CacheName;
 	bool		CacheAssumeHttp2 = false;
+	double		CacheLatencySec	 = -1.0;
 };
 
 enum class ZenCacheResolveMode
@@ -54,9 +56,11 @@ struct StorageInstance
 	std::unique_ptr<HttpClient>		   BuildStorageHttp;
 	std::unique_ptr<BuildStorageBase>  BuildStorage;
 	std::string						   StorageName;
+	double							   BuildStorageLatencySec = -1.0;
 	std::unique_ptr<HttpClient>		   CacheHttp;
 	std::unique_ptr<BuildStorageCache> BuildCacheStorage;
 	std::string						   CacheName;
+	double							   CacheLatencySec = -1.0;
 };
 
 }  // namespace zen
diff --git a/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h b/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
index d339b0f94..5a17ef79c 100644
--- a/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
+++ b/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
@@ -7,6 +7,10 @@
 #include <zencore/compactbinary.h>
 #include <zencore/compress.h>
 
+ZEN_THIRD_PARTY_INCLUDES_START
+#include <tsl/robin_map.h>
+ZEN_THIRD_PARTY_INCLUDES_END
+
 #include <optional>
 #include <vector>
 
@@ -73,6 +77,101 @@ std::vector<size_t> FindReuseBlocks(OperationLogOutput&						  Output,
 									std::span<const uint32_t>				  ChunkIndexes,
 									std::vector<uint32_t>&					  OutUnusedChunkIndexes);
 
+class ChunkBlockAnalyser
+{
+public:
+	struct Options
+	{
+		bool	 IsQuiet				  = false;
+		bool	 IsVerbose				  = false;
+		double	 HostLatencySec			  = -1.0;
+		double	 HostHighSpeedLatencySec  = -1.0;
+		uint64_t HostSpeedBytesPerSec	  = (1u * 1024u * 1024u * 1024u) / 8u;	// 1GBit
+		uint64_t HostHighSpeedBytesPerSec = (2u * 1024u * 1024u * 1024u) / 8u;	// 2GBit
+	};
+
+	ChunkBlockAnalyser(OperationLogOutput& LogOutput, std::span<const ChunkBlockDescription> BlockDescriptions, const Options& Options);
+
+	struct BlockRangeDescriptor
+	{
+		uint32_t BlockIndex			  = (uint32_t)-1;
+		uint64_t RangeStart			  = 0;
+		uint64_t RangeLength		  = 0;
+		uint32_t ChunkBlockIndexStart = 0;
+		uint32_t ChunkBlockIndexCount = 0;
+	};
+
+	struct NeededBlock
+	{
+		uint32_t			  BlockIndex;
+		std::vector<uint32_t> ChunkIndexes;
+	};
+
+	std::vector<NeededBlock> GetNeeded(const tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& ChunkHashToChunkIndex,
+									   std::function<bool(uint32_t ChunkIndex)>&&			   NeedsBlockChunk);
+
+	enum EPartialBlockDownloadMode
+	{
+		Off,
+		SingleRange,
+		MultiRange,
+		MultiRangeHighSpeed,
+		Exact
+	};
+
+	struct BlockResult
+	{
+		std::vector<BlockRangeDescriptor> BlockRanges;
+		std::vector<uint32_t>			  FullBlockIndexes;
+	};
+
+	BlockResult CalculatePartialBlockDownloads(std::span<const NeededBlock>				  NeededBlocks,
+											   std::span<const EPartialBlockDownloadMode> BlockPartialDownloadModes);
+
+private:
+	struct BlockRangeLimit
+	{
+		uint16_t SizePercent;
+		uint16_t MaxRangeCount;
+	};
+
+	static constexpr uint16_t FullBlockRangePercentLimit = 98;
+
+	static constexpr BlockRangeLimit ForceMergeLimits[] = {{.SizePercent = FullBlockRangePercentLimit, .MaxRangeCount = 1},
+														   {.SizePercent = 90, .MaxRangeCount = 4},
+														   {.SizePercent = 85, .MaxRangeCount = 16},
+														   {.SizePercent = 80, .MaxRangeCount = 32},
+														   {.SizePercent = 75, .MaxRangeCount = 48},
+														   {.SizePercent = 70, .MaxRangeCount = 64},
+														   {.SizePercent = 4, .MaxRangeCount = 82},
+														   {.SizePercent = 0, .MaxRangeCount = 96}};
+
+	BlockRangeDescriptor							 MergeBlockRanges(std::span<const BlockRangeDescriptor> Ranges);
+	std::optional<std::vector<BlockRangeDescriptor>> MakeOptionalBlockRangeVector(uint64_t					  TotalBlockSize,
+																				  const BlockRangeDescriptor& Range);
+	const BlockRangeLimit*							 GetBlockRangeLimitForRange(std::span<const BlockRangeLimit>	  Limits,
+																				uint64_t							  TotalBlockSize,
+																				std::span<const BlockRangeDescriptor> Ranges);
+	std::vector<BlockRangeDescriptor>				 CollapseBlockRanges(const uint64_t						   AlwaysAcceptableGap,
+																		 std::span<const BlockRangeDescriptor> BlockRanges);
+	uint64_t CalculateNextGap(const uint64_t AlwaysAcceptableGap, std::span<const BlockRangeDescriptor> BlockRanges);
+	std::optional<std::vector<BlockRangeDescriptor>> CalculateBlockRanges(uint32_t					   BlockIndex,
+																		  const ChunkBlockDescription& BlockDescription,
+																		  std::span<const uint32_t>	   BlockChunkIndexNeeded,
+																		  EPartialBlockDownloadMode	   PartialBlockDownloadMode,
+																		  const uint64_t			   ChunkStartOffsetInBlock,
+																		  const uint64_t			   TotalBlockSize,
+																		  uint64_t&					   OutTotalWantedChunksSize);
+
+	OperationLogOutput&							 m_LogOutput;
+	const std::span<const ChunkBlockDescription> m_BlockDescriptions;
+	const Options								 m_Options;
+};
+
+#if ZEN_WITH_TESTS
+
+class CbWriter;
 void chunkblock_forcelink();
+#endif	// ZEN_WITH_TESTS
 
 }  // namespace zen
diff --git a/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h b/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
index 432496bc1..7bbf40dfa 100644
--- a/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
+++ b/src/zenremotestore/include/zenremotestore/jupiter/jupiterhost.h
@@ -28,6 +28,7 @@ struct JupiterEndpointTestResult
 {
 	bool		Success = false;
 	std::string FailureReason;
+	double		LatencySeconds = -1.0;
 };
 
 JupiterEndpointTestResult TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool HttpVerbose);
diff --git a/src/zenremotestore/include/zenremotestore/operationlogoutput.h b/src/zenremotestore/include/zenremotestore/operationlogoutput.h
index 9693e69cf..6f10ab156 100644
--- a/src/zenremotestore/include/zenremotestore/operationlogoutput.h
+++ b/src/zenremotestore/include/zenremotestore/operationlogoutput.h
@@ -3,6 +3,7 @@
 #pragma once
 
 #include <zencore/fmtutils.h>
+#include <zencore/logbase.h>
 
 namespace zen {
 
@@ -57,9 +58,7 @@ public:
 	virtual ProgressBar* CreateProgressBar(std::string_view InSubTask) = 0;
 };
 
-struct LoggerRef;
-
-OperationLogOutput* CreateStandardLogOutput(LoggerRef& Log);
+OperationLogOutput* CreateStandardLogOutput(LoggerRef Log);
 
 #define ZEN_OPERATION_LOG(OutputTarget, InLevel, fmtstr, ...)                                         \
 	do                                                                                                \
diff --git a/src/zenremotestore/include/zenremotestore/partialblockrequestmode.h b/src/zenremotestore/include/zenremotestore/partialblockrequestmode.h
new file mode 100644
index 000000000..54adea2b2
--- /dev/null
+++ b/src/zenremotestore/include/zenremotestore/partialblockrequestmode.h
@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <string_view>
+
+namespace zen {
+
+enum EPartialBlockRequestMode
+{
+	Off,
+	ZenCacheOnly,
+	Mixed,
+	All,
+	Invalid
+};
+
+EPartialBlockRequestMode PartialBlockRequestModeFromString(const std::string_view ModeString);
+
+}  // namespace zen
diff --git a/src/zenremotestore/include/zenremotestore/projectstore/buildsremoteprojectstore.h b/src/zenremotestore/include/zenremotestore/projectstore/buildsremoteprojectstore.h
index e8b7c15c0..66dfcc62d 100644
--- a/src/zenremotestore/include/zenremotestore/projectstore/buildsremoteprojectstore.h
+++ b/src/zenremotestore/include/zenremotestore/projectstore/buildsremoteprojectstore.h
@@ -34,6 +34,8 @@ std::shared_ptr<RemoteProjectStore> CreateJupiterBuildsRemoteStore(LoggerRef
 																   bool							   Quiet,
 																   bool							   Unattended,
 																   bool							   Hidden,
-																   WorkerThreadPool&			   CacheBackgroundWorkerPool);
+																   WorkerThreadPool&			   CacheBackgroundWorkerPool,
+																   double&						   OutHostLatencySec,
+																   double&						   OutCacheLatencySec);
 
 }  // namespace zen
diff --git a/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h b/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
index 008f94351..152c02ee2 100644
--- a/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
+++ b/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
@@ -6,6 +6,7 @@
 #include <zenstore/projectstore.h>
 
 #include <zenremotestore/chunking/chunkblock.h>
+#include <zenremotestore/partialblockrequestmode.h>
 
 #include <unordered_set>
 
@@ -73,6 +74,16 @@ public:
 		std::vector<ChunkBlockDescription> Blocks;
 	};
 
+	struct GetBlockDescriptionsResult : public Result
+	{
+		std::vector<ChunkBlockDescription> Blocks;
+	};
+
+	struct AttachmentExistsInCacheResult : public Result
+	{
+		std::vector<bool> HasBody;
+	};
+
 	struct RemoteStoreInfo
 	{
 		bool		CreateBlocks;
@@ -111,10 +122,20 @@ public:
 	virtual FinalizeResult		  FinalizeContainer(const IoHash& RawHash)															   = 0;
 	virtual SaveAttachmentsResult SaveAttachments(const std::vector<SharedBuffer>& Payloads)										   = 0;
 
-	virtual LoadContainerResult	  LoadContainer()										= 0;
-	virtual GetKnownBlocksResult  GetKnownBlocks()										= 0;
-	virtual LoadAttachmentResult  LoadAttachment(const IoHash& RawHash)					= 0;
-	virtual LoadAttachmentsResult LoadAttachments(const std::vector<IoHash>& RawHashes) = 0;
+	virtual LoadContainerResult			  LoadContainer()											 = 0;
+	virtual GetKnownBlocksResult		  GetKnownBlocks()											 = 0;
+	virtual GetBlockDescriptionsResult	  GetBlockDescriptions(std::span<const IoHash> BlockHashes)	 = 0;
+	virtual AttachmentExistsInCacheResult AttachmentExistsInCache(std::span<const IoHash> RawHashes) = 0;
+
+	struct AttachmentRange
+	{
+		uint64_t Offset = 0;
+		uint64_t Bytes	= (uint64_t)-1;
+
+		inline operator bool() const { return Offset != 0 || Bytes != (uint64_t)-1; }
+	};
+	virtual LoadAttachmentResult  LoadAttachment(const IoHash& RawHash, const AttachmentRange& Range) = 0;
+	virtual LoadAttachmentsResult LoadAttachments(const std::vector<IoHash>& RawHashes)				  = 0;
 
 	virtual void Flush() = 0;
 };
@@ -153,14 +174,15 @@ RemoteProjectStore::LoadContainerResult BuildContainer(
 
 class JobContext;
 
-RemoteProjectStore::Result SaveOplogContainer(ProjectStore::Oplog&									  Oplog,
-											  const CbObject&										  ContainerObject,
-											  const std::function<void(std::span<IoHash> RawHashes)>& OnReferencedAttachments,
-											  const std::function<bool(const IoHash& RawHash)>&		  HasAttachment,
-											  const std::function<void(const IoHash& BlockHash, std::vector<IoHash>&& Chunks)>& OnNeedBlock,
-											  const std::function<void(const IoHash& RawHash)>&		 OnNeedAttachment,
-											  const std::function<void(const ChunkedInfo& Chunked)>& OnChunkedAttachment,
-											  JobContext*											 OptionalContext);
+RemoteProjectStore::Result SaveOplogContainer(
+	ProjectStore::Oplog&									Oplog,
+	const CbObject&											ContainerObject,
+	const std::function<void(std::span<IoHash> RawHashes)>& OnReferencedAttachments,
+	const std::function<bool(const IoHash& RawHash)>&		HasAttachment,
+	const std::function<void(ThinChunkBlockDescription&& ThinBlockDescription, std::vector<uint32_t>&& NeededChunkIndexes)>& OnNeedBlock,
+	const std::function<void(const IoHash& RawHash)>&	   OnNeedAttachment,
+	const std::function<void(const ChunkedInfo& Chunked)>& OnChunkedAttachment,
+	JobContext*											   OptionalContext);
 
 RemoteProjectStore::Result SaveOplog(CidStore&				ChunkStore,
 									 RemoteProjectStore&	RemoteStore,
@@ -177,15 +199,18 @@ RemoteProjectStore::Result SaveOplog(CidStore&				ChunkStore,
 									 bool					IgnoreMissingAttachments,
 									 JobContext*			OptionalContext);
 
-RemoteProjectStore::Result LoadOplog(CidStore&			  ChunkStore,
-									 RemoteProjectStore&  RemoteStore,
-									 ProjectStore::Oplog& Oplog,
-									 WorkerThreadPool&	  NetworkWorkerPool,
-									 WorkerThreadPool&	  WorkerPool,
-									 bool				  ForceDownload,
-									 bool				  IgnoreMissingAttachments,
-									 bool				  CleanOplog,
-									 JobContext*		  OptionalContext);
+RemoteProjectStore::Result LoadOplog(CidStore&				  ChunkStore,
+									 RemoteProjectStore&	  RemoteStore,
+									 ProjectStore::Oplog&	  Oplog,
+									 WorkerThreadPool&		  NetworkWorkerPool,
+									 WorkerThreadPool&		  WorkerPool,
+									 bool					  ForceDownload,
+									 bool					  IgnoreMissingAttachments,
+									 bool					  CleanOplog,
+									 EPartialBlockRequestMode PartialBlockRequestMode,
+									 double					  HostLatencySec,
+									 double					  CacheLatencySec,
+									 JobContext*			  OptionalContext);
 
 std::vector<IoHash>					   GetBlockHashesFromOplog(CbObjectView ContainerObject);
 std::vector<ThinChunkBlockDescription> GetBlocksFromOplog(CbObjectView ContainerObject, std::span<const IoHash> IncludeBlockHashes);
diff --git a/src/zenremotestore/jupiter/jupiterhost.cpp b/src/zenremotestore/jupiter/jupiterhost.cpp
index 7706f00c2..2583cfc84 100644
--- a/src/zenremotestore/jupiter/jupiterhost.cpp
+++ b/src/zenremotestore/jupiter/jupiterhost.cpp
@@ -59,7 +59,13 @@ TestJupiterEndpoint(std::string_view BaseUrl, const bool AssumeHttp2, const bool
 	HttpClient::Response TestResponse = TestHttpClient.Get("/health/live");
 	if (TestResponse.IsSuccess())
 	{
-		return {.Success = true};
+		LatencyTestResult LatencyResult = MeasureLatency(TestHttpClient, "/health/ready");
+
+		if (!LatencyResult.Success)
+		{
+			return {.Success = false, .FailureReason = LatencyResult.FailureReason};
+		}
+		return {.Success = true, .LatencySeconds = LatencyResult.LatencySeconds};
 	}
 	return {.Success = false, .FailureReason = TestResponse.ErrorMessage("")};
 }
diff --git a/src/zenremotestore/operationlogoutput.cpp b/src/zenremotestore/operationlogoutput.cpp
index 0837ed716..7ed93c947 100644
--- a/src/zenremotestore/operationlogoutput.cpp
+++ b/src/zenremotestore/operationlogoutput.cpp
@@ -95,7 +95,7 @@ StandardLogOutputProgressBar::Finish()
 }
 
 OperationLogOutput*
-CreateStandardLogOutput(LoggerRef& Log)
+CreateStandardLogOutput(LoggerRef Log)
 {
 	return new StandardLogOutput(Log);
 }
diff --git a/src/zenremotestore/partialblockrequestmode.cpp b/src/zenremotestore/partialblockrequestmode.cpp
new file mode 100644
index 000000000..b3edf515b
--- /dev/null
+++ b/src/zenremotestore/partialblockrequestmode.cpp
@@ -0,0 +1,27 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zenremotestore/partialblockrequestmode.h>
+
+#include <zencore/string.h>
+
+namespace zen {
+
+EPartialBlockRequestMode
+PartialBlockRequestModeFromString(const std::string_view ModeString)
+{
+	switch (HashStringAsLowerDjb2(ModeString))
+	{
+		case HashStringDjb2("false"):
+			return EPartialBlockRequestMode::Off;
+		case HashStringDjb2("zencacheonly"):
+			return EPartialBlockRequestMode::ZenCacheOnly;
+		case HashStringDjb2("mixed"):
+			return EPartialBlockRequestMode::Mixed;
+		case HashStringDjb2("true"):
+			return EPartialBlockRequestMode::All;
+		default:
+			return EPartialBlockRequestMode::Invalid;
+	}
+}
+
+}  // namespace zen
diff --git a/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp b/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
index a8e883dde..c42373e4d 100644
--- a/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/buildsremoteprojectstore.cpp
@@ -441,7 +441,7 @@ public:
 		catch (const HttpClientError& Ex)
 		{
 			Result.ErrorCode = MakeErrorCode(Ex);
-			Result.Reason	 = fmt::format("Failed listing know blocks for {}/{}/{}/{}. Reason: '{}'",
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
 										   m_BuildStorageHttp.GetBaseUri(),
 										   m_Namespace,
 										   m_Bucket,
@@ -451,7 +451,7 @@ public:
 		catch (const std::exception& Ex)
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
-			Result.Reason	 = fmt::format("Failed listing know blocks for {}/{}/{}/{}. Reason: '{}'",
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
 										   m_BuildStorageHttp.GetBaseUri(),
 										   m_Namespace,
 										   m_Bucket,
@@ -462,7 +462,94 @@ public:
 		return Result;
 	}
 
-	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
+	virtual GetBlockDescriptionsResult GetBlockDescriptions(std::span<const IoHash> BlockHashes) override
+	{
+		std::unique_ptr<OperationLogOutput> Output(CreateStandardLogOutput(Log()));
+
+		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
+
+		GetBlockDescriptionsResult Result;
+		Stopwatch				   Timer;
+		auto					   _ = MakeGuard([&Timer, &Result]() { Result.ElapsedSeconds = Timer.GetElapsedTimeUs() / 1000000.0; });
+
+		try
+		{
+			Result.Blocks = zen::GetBlockDescriptions(*Output,
+													  *m_BuildStorage,
+													  m_BuildCacheStorage.get(),
+													  m_BuildId,
+													  m_OplogBuildPartId,
+													  BlockHashes,
+													  /*AttemptFallback*/ false,
+													  /*IsQuiet*/ false,
+													  /*IsVerbose)*/ false);
+		}
+		catch (const HttpClientError& Ex)
+		{
+			Result.ErrorCode = MakeErrorCode(Ex);
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
+										   m_BuildStorageHttp.GetBaseUri(),
+										   m_Namespace,
+										   m_Bucket,
+										   m_BuildId,
+										   Ex.what());
+		}
+		catch (const std::exception& Ex)
+		{
+			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
+										   m_BuildStorageHttp.GetBaseUri(),
+										   m_Namespace,
+										   m_Bucket,
+										   m_BuildId,
+										   Ex.what());
+		}
+		return Result;
+	}
+
+	virtual AttachmentExistsInCacheResult AttachmentExistsInCache(std::span<const IoHash> RawHashes) override
+	{
+		AttachmentExistsInCacheResult Result;
+		Stopwatch					  Timer;
+		auto						  _ = MakeGuard([&Timer, &Result]() { Result.ElapsedSeconds = Timer.GetElapsedTimeUs() / 1000000.0; });
+		try
+		{
+			const std::vector<BuildStorageCache::BlobExistsResult> CacheExistsResult =
+				m_BuildCacheStorage->BlobsExists(m_BuildId, RawHashes);
+
+			if (CacheExistsResult.size() == RawHashes.size())
+			{
+				Result.HasBody.reserve(CacheExistsResult.size());
+				for (size_t BlobIndex = 0; BlobIndex < CacheExistsResult.size(); BlobIndex++)
+				{
+					Result.HasBody.push_back(CacheExistsResult[BlobIndex].HasBody);
+				}
+			}
+		}
+		catch (const HttpClientError& Ex)
+		{
+			Result.ErrorCode = MakeErrorCode(Ex);
+			Result.Reason	 = fmt::format("Remote cache: Failed finding known blobs for {}/{}/{}/{}. Reason: '{}'",
+										   m_BuildStorageHttp.GetBaseUri(),
+										   m_Namespace,
+										   m_Bucket,
+										   m_BuildId,
+										   Ex.what());
+		}
+		catch (const std::exception& Ex)
+		{
+			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
+			Result.Reason	 = fmt::format("Remote cache: Failed finding known blobs for {}/{}/{}/{}. Reason: '{}'",
+										   m_BuildStorageHttp.GetBaseUri(),
+										   m_Namespace,
+										   m_Bucket,
+										   m_BuildId,
+										   Ex.what());
+		}
+		return Result;
+	}
+
+	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash, const AttachmentRange& Range) override
 	{
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
 
@@ -474,7 +561,7 @@ public:
 		{
 			if (m_BuildCacheStorage)
 			{
-				IoBuffer CachedBlob = m_BuildCacheStorage->GetBuildBlob(m_BuildId, RawHash);
+				IoBuffer CachedBlob = m_BuildCacheStorage->GetBuildBlob(m_BuildId, RawHash, Range.Offset, Range.Bytes);
 				if (CachedBlob)
 				{
 					Result.Bytes = std::move(CachedBlob);
@@ -482,20 +569,23 @@ public:
 			}
 			if (!Result.Bytes)
 			{
-				Result.Bytes = m_BuildStorage->GetBuildBlob(m_BuildId, RawHash);
+				Result.Bytes = m_BuildStorage->GetBuildBlob(m_BuildId, RawHash, Range.Offset, Range.Bytes);
 				if (m_BuildCacheStorage && Result.Bytes && m_PopulateCache)
 				{
-					m_BuildCacheStorage->PutBuildBlob(m_BuildId,
-													  RawHash,
-													  Result.Bytes.GetContentType(),
-													  CompositeBuffer(SharedBuffer(Result.Bytes)));
+					if (!Range)
+					{
+						m_BuildCacheStorage->PutBuildBlob(m_BuildId,
+														  RawHash,
+														  Result.Bytes.GetContentType(),
+														  CompositeBuffer(SharedBuffer(Result.Bytes)));
+					}
 				}
 			}
 		}
 		catch (const HttpClientError& Ex)
 		{
 			Result.ErrorCode = MakeErrorCode(Ex);
-			Result.Reason	 = fmt::format("Failed listing know blocks for {}/{}/{}/{}. Reason: '{}'",
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
 										   m_BuildStorageHttp.GetBaseUri(),
 										   m_Namespace,
 										   m_Bucket,
@@ -505,7 +595,7 @@ public:
 		catch (const std::exception& Ex)
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
-			Result.Reason	 = fmt::format("Failed listing know blocks for {}/{}/{}/{}. Reason: '{}'",
+			Result.Reason	 = fmt::format("Failed listing known blocks for {}/{}/{}/{}. Reason: '{}'",
 										   m_BuildStorageHttp.GetBaseUri(),
 										   m_Namespace,
 										   m_Bucket,
@@ -558,7 +648,7 @@ public:
 
 		for (const IoHash& Hash : AttachmentsLeftToFind)
 		{
-			LoadAttachmentResult ChunkResult = LoadAttachment(Hash);
+			LoadAttachmentResult ChunkResult = LoadAttachment(Hash, {});
 			if (ChunkResult.ErrorCode)
 			{
 				return LoadAttachmentsResult{ChunkResult};
@@ -623,7 +713,9 @@ CreateJupiterBuildsRemoteStore(LoggerRef					   InLog,
 							   bool							   Quiet,
 							   bool							   Unattended,
 							   bool							   Hidden,
-							   WorkerThreadPool&			   CacheBackgroundWorkerPool)
+							   WorkerThreadPool&			   CacheBackgroundWorkerPool,
+							   double&						   OutHostLatencySec,
+							   double&						   OutCacheLatencySec)
 {
 	std::string Host = Options.Host;
 	if (!Host.empty() && Host.find("://"sv) == std::string::npos)
@@ -727,6 +819,10 @@ CreateJupiterBuildsRemoteStore(LoggerRef					   InLog,
 																						  Options.ForceDisableBlocks,
 																						  Options.ForceDisableTempBlocks,
 																						  Options.PopulateCache);
+
+	OutHostLatencySec  = ResolveRes.HostLatencySec;
+	OutCacheLatencySec = ResolveRes.CacheLatencySec;
+
 	return RemoteStore;
 }
 
diff --git a/src/zenremotestore/projectstore/fileremoteprojectstore.cpp b/src/zenremotestore/projectstore/fileremoteprojectstore.cpp
index 3a67d3842..ec7fb7bbc 100644
--- a/src/zenremotestore/projectstore/fileremoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/fileremoteprojectstore.cpp
@@ -217,7 +217,18 @@ public:
 		return Result;
 	}
 
-	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
+	virtual GetBlockDescriptionsResult GetBlockDescriptions(std::span<const IoHash> BlockHashes) override
+	{
+		ZEN_UNUSED(BlockHashes);
+		return GetBlockDescriptionsResult{Result{.ErrorCode = int(HttpResponseCode::NotFound)}};
+	}
+
+	virtual AttachmentExistsInCacheResult AttachmentExistsInCache(std::span<const IoHash> RawHashes) override
+	{
+		return AttachmentExistsInCacheResult{Result{.ErrorCode = 0}, std::vector<bool>(RawHashes.size(), false)};
+	}
+
+	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash, const AttachmentRange& Range) override
 	{
 		Stopwatch			  Timer;
 		LoadAttachmentResult  Result;
@@ -232,7 +243,14 @@ public:
 		{
 			BasicFile ChunkFile;
 			ChunkFile.Open(ChunkPath, BasicFile::Mode::kRead);
-			Result.Bytes = ChunkFile.ReadAll();
+			if (Range)
+			{
+				Result.Bytes = ChunkFile.ReadRange(Range.Offset, Range.Bytes);
+			}
+			else
+			{
+				Result.Bytes = ChunkFile.ReadAll();
+			}
 		}
 		AddStats(0, Result.Bytes.GetSize(), Timer.GetElapsedTimeUs() * 1000);
 		Result.ElapsedSeconds = Timer.GetElapsedTimeMs() / 1000.0;
@@ -245,7 +263,7 @@ public:
 		LoadAttachmentsResult Result;
 		for (const IoHash& Hash : RawHashes)
 		{
-			LoadAttachmentResult ChunkResult = LoadAttachment(Hash);
+			LoadAttachmentResult ChunkResult = LoadAttachment(Hash, {});
 			if (ChunkResult.ErrorCode)
 			{
 				ChunkResult.ElapsedSeconds = Timer.GetElapsedTimeMs() / 1000.0;
diff --git a/src/zenremotestore/projectstore/jupiterremoteprojectstore.cpp b/src/zenremotestore/projectstore/jupiterremoteprojectstore.cpp
index 462de2988..f8179831c 100644
--- a/src/zenremotestore/projectstore/jupiterremoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/jupiterremoteprojectstore.cpp
@@ -212,7 +212,18 @@ public:
 		return Result;
 	}
 
-	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
+	virtual GetBlockDescriptionsResult GetBlockDescriptions(std::span<const IoHash> BlockHashes) override
+	{
+		ZEN_UNUSED(BlockHashes);
+		return GetBlockDescriptionsResult{Result{.ErrorCode = int(HttpResponseCode::NotFound)}};
+	}
+
+	virtual AttachmentExistsInCacheResult AttachmentExistsInCache(std::span<const IoHash> RawHashes) override
+	{
+		return AttachmentExistsInCacheResult{Result{.ErrorCode = 0}, std::vector<bool>(RawHashes.size(), false)};
+	}
+
+	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash, const AttachmentRange& Range) override
 	{
 		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client(), m_AllowRedirect);
 		JupiterResult  GetResult = Session.GetCompressedBlob(m_Namespace, RawHash, m_TempFilePath);
@@ -227,6 +238,10 @@ public:
 										RawHash,
 										Result.Reason);
 		}
+		if (!Result.ErrorCode && Range)
+		{
+			Result.Bytes = IoBuffer(Result.Bytes, Range.Offset, Range.Bytes);
+		}
 		return Result;
 	}
 
@@ -235,7 +250,7 @@ public:
 		LoadAttachmentsResult Result;
 		for (const IoHash& Hash : RawHashes)
 		{
-			LoadAttachmentResult ChunkResult = LoadAttachment(Hash);
+			LoadAttachmentResult ChunkResult = LoadAttachment(Hash, {});
 			if (ChunkResult.ErrorCode)
 			{
 				return LoadAttachmentsResult{ChunkResult};
diff --git a/src/zenremotestore/projectstore/remoteprojectstore.cpp b/src/zenremotestore/projectstore/remoteprojectstore.cpp
index 8be8eb0df..2a9da6f58 100644
--- a/src/zenremotestore/projectstore/remoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/remoteprojectstore.cpp
@@ -14,6 +14,7 @@
 #include <zencore/trace.h>
 #include <zencore/workthreadpool.h>
 #include <zenhttp/httpcommon.h>
+#include <zenremotestore/chunking/chunkedcontent.h>
 #include <zenremotestore/chunking/chunkedfile.h>
 #include <zenremotestore/operationlogoutput.h>
 #include <zenstore/cidstore.h>
@@ -229,29 +230,60 @@ namespace remotestore_impl {
 
 	struct DownloadInfo
 	{
-		uint64_t			  OplogSizeBytes				 = 0;
-		std::atomic<uint64_t> AttachmentsDownloaded			 = 0;
-		std::atomic<uint64_t> AttachmentBlocksDownloaded	 = 0;
-		std::atomic<uint64_t> AttachmentBytesDownloaded		 = 0;
-		std::atomic<uint64_t> AttachmentBlockBytesDownloaded = 0;
-		std::atomic<uint64_t> AttachmentsStored				 = 0;
-		std::atomic<uint64_t> AttachmentBytesStored			 = 0;
-		std::atomic_size_t	  MissingAttachmentCount		 = 0;
+		uint64_t			  OplogSizeBytes					  = 0;
+		std::atomic<uint64_t> AttachmentsDownloaded				  = 0;
+		std::atomic<uint64_t> AttachmentBlocksDownloaded		  = 0;
+		std::atomic<uint64_t> AttachmentBlocksRangesDownloaded	  = 0;
+		std::atomic<uint64_t> AttachmentBytesDownloaded			  = 0;
+		std::atomic<uint64_t> AttachmentBlockBytesDownloaded	  = 0;
+		std::atomic<uint64_t> AttachmentBlockRangeBytesDownloaded = 0;
+		std::atomic<uint64_t> AttachmentsStored					  = 0;
+		std::atomic<uint64_t> AttachmentBytesStored				  = 0;
+		std::atomic_size_t	  MissingAttachmentCount			  = 0;
 	};
 
-	void DownloadAndSaveBlockChunks(CidStore&				   ChunkStore,
-									RemoteProjectStore&		   RemoteStore,
-									bool					   IgnoreMissingAttachments,
-									JobContext*				   OptionalContext,
-									WorkerThreadPool&		   NetworkWorkerPool,
-									WorkerThreadPool&		   WorkerPool,
-									Latch&					   AttachmentsDownloadLatch,
-									Latch&					   AttachmentsWriteLatch,
-									AsyncRemoteResult&		   RemoteResult,
-									DownloadInfo&			   Info,
-									Stopwatch&				   LoadAttachmentsTimer,
-									std::atomic_uint64_t&	   DownloadStartMS,
-									const std::vector<IoHash>& Chunks)
+	class JobContextLogOutput : public OperationLogOutput
+	{
+	public:
+		JobContextLogOutput(JobContext* OptionalContext) : m_OptionalContext(OptionalContext) {}
+		virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) override
+		{
+			ZEN_UNUSED(LogLevel);
+			if (m_OptionalContext)
+			{
+				fmt::basic_memory_buffer<char, 250> MessageBuffer;
+				fmt::vformat_to(fmt::appender(MessageBuffer), Format, Args);
+				remotestore_impl::ReportMessage(m_OptionalContext, std::string_view(MessageBuffer.data(), MessageBuffer.size()));
+			}
+		}
+
+		virtual void		 SetLogOperationName(std::string_view Name) override { ZEN_UNUSED(Name); }
+		virtual void		 SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) override { ZEN_UNUSED(StepIndex, StepCount); }
+		virtual uint32_t	 GetProgressUpdateDelayMS() override { return 0; }
+		virtual ProgressBar* CreateProgressBar(std::string_view InSubTask) override
+		{
+			ZEN_UNUSED(InSubTask);
+			return nullptr;
+		}
+
+	private:
+		JobContext* m_OptionalContext;
+	};
+
+	void DownloadAndSaveBlockChunks(CidStore&					ChunkStore,
+									RemoteProjectStore&			RemoteStore,
+									bool						IgnoreMissingAttachments,
+									JobContext*					OptionalContext,
+									WorkerThreadPool&			NetworkWorkerPool,
+									WorkerThreadPool&			WorkerPool,
+									Latch&						AttachmentsDownloadLatch,
+									Latch&						AttachmentsWriteLatch,
+									AsyncRemoteResult&			RemoteResult,
+									DownloadInfo&				Info,
+									Stopwatch&					LoadAttachmentsTimer,
+									std::atomic_uint64_t&		DownloadStartMS,
+									ThinChunkBlockDescription&& ThinBlockDescription,
+									std::vector<uint32_t>&&		NeededChunkIndexes)
 	{
 		AttachmentsDownloadLatch.AddCount(1);
 		NetworkWorkerPool.ScheduleWork(
@@ -261,7 +293,8 @@ namespace remotestore_impl {
 			 &AttachmentsDownloadLatch,
 			 &AttachmentsWriteLatch,
 			 &RemoteResult,
-			 Chunks = Chunks,
+			 ThinBlockDescription = std::move(ThinBlockDescription),
+			 NeededChunkIndexes	  = std::move(NeededChunkIndexes),
 			 &Info,
 			 &LoadAttachmentsTimer,
 			 &DownloadStartMS,
@@ -276,6 +309,13 @@ namespace remotestore_impl {
 				}
 				try
 				{
+					std::vector<IoHash> Chunks;
+					Chunks.reserve(NeededChunkIndexes.size());
+					for (uint32_t ChunkIndex : NeededChunkIndexes)
+					{
+						Chunks.push_back(ThinBlockDescription.ChunkRawHashes[ChunkIndex]);
+					}
+
 					uint64_t Unset = (std::uint64_t)-1;
 					DownloadStartMS.compare_exchange_strong(Unset, LoadAttachmentsTimer.GetElapsedTimeMs());
 					RemoteProjectStore::LoadAttachmentsResult Result = RemoteStore.LoadAttachments(Chunks);
@@ -293,7 +333,12 @@ namespace remotestore_impl {
 						}
 						return;
 					}
-					Info.AttachmentsDownloaded.fetch_add(Chunks.size());
+					Info.AttachmentsDownloaded.fetch_add(Result.Chunks.size());
+					for (const auto& It : Result.Chunks)
+					{
+						uint64_t ChunkSize = It.second.GetCompressedSize();
+						Info.AttachmentBytesDownloaded.fetch_add(ChunkSize);
+					}
 					ZEN_INFO("Loaded {} bulk attachments in {}",
 							 Chunks.size(),
 							 NiceTimeSpanMs(static_cast<uint64_t>(Result.ElapsedSeconds * 1000)));
@@ -320,8 +365,6 @@ namespace remotestore_impl {
 
 									for (const auto& It : Chunks)
 									{
-										uint64_t ChunkSize = It.second.GetCompressedSize();
-										Info.AttachmentBytesDownloaded.fetch_add(ChunkSize);
 										WriteAttachmentBuffers.push_back(It.second.GetCompressed().Flatten().AsIoBuffer());
 										WriteRawHashes.push_back(It.first);
 									}
@@ -350,28 +393,29 @@ namespace remotestore_impl {
 				catch (const std::exception& Ex)
 				{
 					RemoteResult.SetError(gsl::narrow<int>(HttpResponseCode::InternalServerError),
-										  fmt::format("Failed to bulk load {} attachments", Chunks.size()),
+										  fmt::format("Failed to bulk load {} attachments", NeededChunkIndexes.size()),
 										  Ex.what());
 				}
 			},
 			WorkerThreadPool::EMode::EnableBacklog);
 	};
 
-	void DownloadAndSaveBlock(CidStore&					 ChunkStore,
-							  RemoteProjectStore&		 RemoteStore,
-							  bool						 IgnoreMissingAttachments,
-							  JobContext*				 OptionalContext,
-							  WorkerThreadPool&			 NetworkWorkerPool,
-							  WorkerThreadPool&			 WorkerPool,
-							  Latch&					 AttachmentsDownloadLatch,
-							  Latch&					 AttachmentsWriteLatch,
-							  AsyncRemoteResult&		 RemoteResult,
-							  DownloadInfo&				 Info,
-							  Stopwatch&				 LoadAttachmentsTimer,
-							  std::atomic_uint64_t&		 DownloadStartMS,
-							  const IoHash&				 BlockHash,
-							  const std::vector<IoHash>& Chunks,
-							  uint32_t					 RetriesLeft)
+	void DownloadAndSaveBlock(CidStore&												  ChunkStore,
+							  RemoteProjectStore&									  RemoteStore,
+							  bool													  IgnoreMissingAttachments,
+							  JobContext*											  OptionalContext,
+							  WorkerThreadPool&										  NetworkWorkerPool,
+							  WorkerThreadPool&										  WorkerPool,
+							  Latch&												  AttachmentsDownloadLatch,
+							  Latch&												  AttachmentsWriteLatch,
+							  AsyncRemoteResult&									  RemoteResult,
+							  DownloadInfo&											  Info,
+							  Stopwatch&											  LoadAttachmentsTimer,
+							  std::atomic_uint64_t&									  DownloadStartMS,
+							  const IoHash&											  BlockHash,
+							  const tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>& AllNeededPartialChunkHashesLookup,
+							  std::span<std::atomic<bool>>							  ChunkDownloadedFlags,
+							  uint32_t												  RetriesLeft)
 	{
 		AttachmentsDownloadLatch.AddCount(1);
 		NetworkWorkerPool.ScheduleWork(
@@ -381,7 +425,6 @@ namespace remotestore_impl {
 			 &RemoteStore,
 			 &NetworkWorkerPool,
 			 &WorkerPool,
-			 BlockHash,
 			 &RemoteResult,
 			 &Info,
 			 &LoadAttachmentsTimer,
@@ -389,7 +432,9 @@ namespace remotestore_impl {
 			 IgnoreMissingAttachments,
 			 OptionalContext,
 			 RetriesLeft,
-			 Chunks = std::vector<IoHash>(Chunks)]() {
+			 BlockHash = IoHash(BlockHash),
+			 &AllNeededPartialChunkHashesLookup,
+			 ChunkDownloadedFlags]() {
 				ZEN_TRACE_CPU("DownloadBlock");
 
 				auto _ = MakeGuard([&AttachmentsDownloadLatch] { AttachmentsDownloadLatch.CountDown(); });
@@ -401,7 +446,7 @@ namespace remotestore_impl {
 				{
 					uint64_t Unset = (std::uint64_t)-1;
 					DownloadStartMS.compare_exchange_strong(Unset, LoadAttachmentsTimer.GetElapsedTimeMs());
-					RemoteProjectStore::LoadAttachmentResult BlockResult = RemoteStore.LoadAttachment(BlockHash);
+					RemoteProjectStore::LoadAttachmentResult BlockResult = RemoteStore.LoadAttachment(BlockHash, {});
 					if (BlockResult.ErrorCode)
 					{
 						ReportMessage(OptionalContext,
@@ -422,10 +467,10 @@ namespace remotestore_impl {
 					}
 					uint64_t BlockSize = BlockResult.Bytes.GetSize();
 					Info.AttachmentBlocksDownloaded.fetch_add(1);
-					ZEN_INFO("Loaded block attachment '{}' in {} ({})",
-							 BlockHash,
-							 NiceTimeSpanMs(static_cast<uint64_t>(BlockResult.ElapsedSeconds * 1000)),
-							 NiceBytes(BlockSize));
+					ZEN_DEBUG("Loaded block attachment '{}' in {} ({})",
+							  BlockHash,
+							  NiceTimeSpanMs(static_cast<uint64_t>(BlockResult.ElapsedSeconds * 1000)),
+							  NiceBytes(BlockSize));
 					Info.AttachmentBlockBytesDownloaded.fetch_add(BlockSize);
 
 					AttachmentsWriteLatch.AddCount(1);
@@ -436,7 +481,6 @@ namespace remotestore_impl {
 						 &RemoteStore,
 						 &NetworkWorkerPool,
 						 &WorkerPool,
-						 BlockHash,
 						 &RemoteResult,
 						 &Info,
 						 &LoadAttachmentsTimer,
@@ -444,8 +488,10 @@ namespace remotestore_impl {
 						 IgnoreMissingAttachments,
 						 OptionalContext,
 						 RetriesLeft,
-						 Chunks = std::move(Chunks),
-						 Bytes	= std::move(BlockResult.Bytes)]() {
+						 BlockHash = IoHash(BlockHash),
+						 &AllNeededPartialChunkHashesLookup,
+						 ChunkDownloadedFlags,
+						 Bytes = std::move(BlockResult.Bytes)]() {
 							auto _ = MakeGuard([&AttachmentsWriteLatch] { AttachmentsWriteLatch.CountDown(); });
 							if (RemoteResult.IsError())
 							{
@@ -454,9 +500,6 @@ namespace remotestore_impl {
 							try
 							{
 								ZEN_ASSERT(Bytes.Size() > 0);
-								std::unordered_set<IoHash, IoHash::Hasher> WantedChunks;
-								WantedChunks.reserve(Chunks.size());
-								WantedChunks.insert(Chunks.begin(), Chunks.end());
 								std::vector<IoBuffer> WriteAttachmentBuffers;
 								std::vector<IoHash>	  WriteRawHashes;
 
@@ -485,7 +528,8 @@ namespace remotestore_impl {
 																	LoadAttachmentsTimer,
 																	DownloadStartMS,
 																	BlockHash,
-																	std::move(Chunks),
+																	AllNeededPartialChunkHashesLookup,
+																	ChunkDownloadedFlags,
 																	RetriesLeft - 1);
 									}
 									ReportMessage(
@@ -519,7 +563,8 @@ namespace remotestore_impl {
 																	LoadAttachmentsTimer,
 																	DownloadStartMS,
 																	BlockHash,
-																	std::move(Chunks),
+																	AllNeededPartialChunkHashesLookup,
+																	ChunkDownloadedFlags,
 																	RetriesLeft - 1);
 									}
 									ReportMessage(OptionalContext,
@@ -546,28 +591,36 @@ namespace remotestore_impl {
 								uint64_t BlockSize	   = BlockPayload.GetSize();
 
 								uint64_t BlockHeaderSize = 0;
-								bool	 StoreChunksOK	 = IterateChunkBlock(
-									  BlockPayload.Flatten(),
-									  [&WantedChunks, &WriteAttachmentBuffers, &WriteRawHashes, &Info, &PotentialSize](
-										  CompressedBuffer&& Chunk,
-										  const IoHash&		 AttachmentRawHash) {
-										  if (WantedChunks.contains(AttachmentRawHash))
-										  {
-											  WriteAttachmentBuffers.emplace_back(Chunk.GetCompressed().Flatten().AsIoBuffer());
-											  IoHash   RawHash;
-											  uint64_t RawSize;
-											  ZEN_ASSERT(
-												  CompressedBuffer::ValidateCompressedHeader(WriteAttachmentBuffers.back(),
-																							 RawHash,
-																							 RawSize,
-																							 /*OutOptionalTotalCompressedSize*/ nullptr));
-											  ZEN_ASSERT(RawHash == AttachmentRawHash);
-											  WriteRawHashes.emplace_back(AttachmentRawHash);
-											  WantedChunks.erase(AttachmentRawHash);
-											  PotentialSize += WriteAttachmentBuffers.back().GetSize();
-										  }
-									  },
-									  BlockHeaderSize);
+
+								bool StoreChunksOK = IterateChunkBlock(
+									BlockPayload.Flatten(),
+									[&AllNeededPartialChunkHashesLookup,
+									 &ChunkDownloadedFlags,
+									 &WriteAttachmentBuffers,
+									 &WriteRawHashes,
+									 &Info,
+									 &PotentialSize](CompressedBuffer&& Chunk, const IoHash& AttachmentRawHash) {
+										auto ChunkIndexIt = AllNeededPartialChunkHashesLookup.find(AttachmentRawHash);
+										if (ChunkIndexIt != AllNeededPartialChunkHashesLookup.end())
+										{
+											bool Expected = false;
+											if (ChunkDownloadedFlags[ChunkIndexIt->second].compare_exchange_strong(Expected, true))
+											{
+												WriteAttachmentBuffers.emplace_back(Chunk.GetCompressed().Flatten().AsIoBuffer());
+												IoHash	 RawHash;
+												uint64_t RawSize;
+												ZEN_ASSERT(
+													CompressedBuffer::ValidateCompressedHeader(WriteAttachmentBuffers.back(),
+																							   RawHash,
+																							   RawSize,
+																							   /*OutOptionalTotalCompressedSize*/ nullptr));
+												ZEN_ASSERT(RawHash == AttachmentRawHash);
+												WriteRawHashes.emplace_back(AttachmentRawHash);
+												PotentialSize += WriteAttachmentBuffers.back().GetSize();
+											}
+										}
+									},
+									BlockHeaderSize);
 
 								if (!StoreChunksOK)
 								{
@@ -582,8 +635,6 @@ namespace remotestore_impl {
 									return;
 								}
 
-								ZEN_ASSERT(WantedChunks.empty());
-
 								if (!WriteAttachmentBuffers.empty())
 								{
 									auto Results = ChunkStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
@@ -625,6 +676,293 @@ namespace remotestore_impl {
 			WorkerThreadPool::EMode::EnableBacklog);
 	};
 
+	void DownloadAndSavePartialBlock(CidStore&												   ChunkStore,
+									 RemoteProjectStore&									   RemoteStore,
+									 bool													   IgnoreMissingAttachments,
+									 JobContext*											   OptionalContext,
+									 WorkerThreadPool&										   NetworkWorkerPool,
+									 WorkerThreadPool&										   WorkerPool,
+									 Latch&													   AttachmentsDownloadLatch,
+									 Latch&													   AttachmentsWriteLatch,
+									 AsyncRemoteResult&										   RemoteResult,
+									 DownloadInfo&											   Info,
+									 Stopwatch&												   LoadAttachmentsTimer,
+									 std::atomic_uint64_t&									   DownloadStartMS,
+									 const ChunkBlockDescription&							   BlockDescription,
+									 std::span<const ChunkBlockAnalyser::BlockRangeDescriptor> BlockRangeDescriptors,
+									 size_t													   BlockRangeIndexStart,
+									 size_t													   BlockRangeCount,
+									 const tsl::robin_map<IoHash, uint32_t, IoHash::Hasher>&   AllNeededPartialChunkHashesLookup,
+									 std::span<std::atomic<bool>>							   ChunkDownloadedFlags,
+									 uint32_t												   RetriesLeft)
+	{
+		AttachmentsDownloadLatch.AddCount(1);
+		NetworkWorkerPool.ScheduleWork(
+			[&AttachmentsDownloadLatch,
+			 &AttachmentsWriteLatch,
+			 &ChunkStore,
+			 &RemoteStore,
+			 &NetworkWorkerPool,
+			 &WorkerPool,
+			 &RemoteResult,
+			 &Info,
+			 &LoadAttachmentsTimer,
+			 &DownloadStartMS,
+			 IgnoreMissingAttachments,
+			 OptionalContext,
+			 RetriesLeft,
+			 BlockDescription,
+			 BlockRangeDescriptors,
+			 BlockRangeIndexStart,
+			 BlockRangeCount,
+			 &AllNeededPartialChunkHashesLookup,
+			 ChunkDownloadedFlags]() {
+				ZEN_TRACE_CPU("DownloadBlockRanges");
+
+				auto _ = MakeGuard([&AttachmentsDownloadLatch] { AttachmentsDownloadLatch.CountDown(); });
+				try
+				{
+					uint64_t Unset = (std::uint64_t)-1;
+					DownloadStartMS.compare_exchange_strong(Unset, LoadAttachmentsTimer.GetElapsedTimeMs());
+
+					double	 DownloadElapsedSeconds = 0;
+					uint64_t DownloadedBytes		= 0;
+
+					for (size_t BlockRangeIndex = BlockRangeIndexStart; BlockRangeIndex < BlockRangeIndexStart + BlockRangeCount;
+						 BlockRangeIndex++)
+					{
+						if (RemoteResult.IsError())
+						{
+							return;
+						}
+
+						const ChunkBlockAnalyser::BlockRangeDescriptor& BlockRange = BlockRangeDescriptors[BlockRangeIndex];
+
+						RemoteProjectStore::LoadAttachmentResult BlockResult =
+							RemoteStore.LoadAttachment(BlockDescription.BlockHash,
+													   {.Offset = BlockRange.RangeStart, .Bytes = BlockRange.RangeLength});
+						if (BlockResult.ErrorCode)
+						{
+							ReportMessage(OptionalContext,
+										  fmt::format("Failed to download block attachment '{}' range {},{} ({}): {}",
+													  BlockDescription.BlockHash,
+													  BlockRange.RangeStart,
+													  BlockRange.RangeLength,
+													  BlockResult.ErrorCode,
+													  BlockResult.Reason));
+							Info.MissingAttachmentCount.fetch_add(1);
+							if (!IgnoreMissingAttachments)
+							{
+								RemoteResult.SetError(BlockResult.ErrorCode, BlockResult.Reason, BlockResult.Text);
+							}
+							return;
+						}
+						if (RemoteResult.IsError())
+						{
+							return;
+						}
+						uint64_t BlockPartSize = BlockResult.Bytes.GetSize();
+						if (BlockPartSize != BlockRange.RangeLength)
+						{
+							std::string ErrorString =
+								fmt::format("Failed to download block attachment '{}' range {},{}, got {} bytes ({}): {}",
+											BlockDescription.BlockHash,
+											BlockRange.RangeStart,
+											BlockRange.RangeLength,
+											BlockPartSize,
+											RemoteResult.GetError(),
+											RemoteResult.GetErrorReason());
+
+							ReportMessage(OptionalContext, ErrorString);
+							Info.MissingAttachmentCount.fetch_add(1);
+							if (!IgnoreMissingAttachments)
+							{
+								RemoteResult.SetError(gsl::narrow<int32_t>(HttpResponseCode::NotFound),
+													  "Mismatching block part range received",
+													  ErrorString);
+							}
+							return;
+						}
+						Info.AttachmentBlocksRangesDownloaded.fetch_add(1);
+
+						DownloadElapsedSeconds += BlockResult.ElapsedSeconds;
+						DownloadedBytes += BlockPartSize;
+
+						Info.AttachmentBlockRangeBytesDownloaded.fetch_add(BlockPartSize);
+
+						AttachmentsWriteLatch.AddCount(1);
+						WorkerPool.ScheduleWork(
+							[&AttachmentsDownloadLatch,
+							 &AttachmentsWriteLatch,
+							 &ChunkStore,
+							 &RemoteStore,
+							 &NetworkWorkerPool,
+							 &WorkerPool,
+							 &RemoteResult,
+							 &Info,
+							 &LoadAttachmentsTimer,
+							 &DownloadStartMS,
+							 IgnoreMissingAttachments,
+							 OptionalContext,
+							 RetriesLeft,
+							 BlockDescription,
+							 BlockRange,
+							 &AllNeededPartialChunkHashesLookup,
+							 ChunkDownloadedFlags,
+							 BlockPayload = std::move(BlockResult.Bytes)]() {
+								auto _ = MakeGuard([&AttachmentsWriteLatch] { AttachmentsWriteLatch.CountDown(); });
+								if (RemoteResult.IsError())
+								{
+									return;
+								}
+								try
+								{
+									ZEN_ASSERT(BlockPayload.Size() > 0);
+									std::vector<IoBuffer> WriteAttachmentBuffers;
+									std::vector<IoHash>	  WriteRawHashes;
+
+									uint64_t PotentialSize = 0;
+									uint64_t UsedSize	   = 0;
+									uint64_t BlockPartSize = BlockPayload.GetSize();
+
+									uint32_t OffsetInBlock = 0;
+									for (uint32_t ChunkBlockIndex = BlockRange.ChunkBlockIndexStart;
+										 ChunkBlockIndex < BlockRange.ChunkBlockIndexStart + BlockRange.ChunkBlockIndexCount;
+										 ChunkBlockIndex++)
+									{
+										const uint32_t ChunkCompressedSize = BlockDescription.ChunkCompressedLengths[ChunkBlockIndex];
+										const IoHash&  ChunkHash		   = BlockDescription.ChunkRawHashes[ChunkBlockIndex];
+
+										if (auto ChunkIndexIt = AllNeededPartialChunkHashesLookup.find(ChunkHash);
+											ChunkIndexIt != AllNeededPartialChunkHashesLookup.end())
+										{
+											bool Expected = false;
+											if (ChunkDownloadedFlags[ChunkIndexIt->second].compare_exchange_strong(Expected, true))
+											{
+												IoHash			 VerifyChunkHash;
+												uint64_t		 VerifyChunkSize;
+												CompressedBuffer CompressedChunk = CompressedBuffer::FromCompressed(
+													SharedBuffer(IoBuffer(BlockPayload, OffsetInBlock, ChunkCompressedSize)),
+													VerifyChunkHash,
+													VerifyChunkSize);
+												if (!CompressedChunk)
+												{
+													std::string ErrorString = fmt::format(
+														"Chunk at {},{} in block attachment '{}' is not a valid compressed buffer",
+														OffsetInBlock,
+														ChunkCompressedSize,
+														BlockDescription.BlockHash);
+													ReportMessage(OptionalContext, ErrorString);
+													Info.MissingAttachmentCount.fetch_add(1);
+													if (!IgnoreMissingAttachments)
+													{
+														RemoteResult.SetError(gsl::narrow<int32_t>(HttpResponseCode::NotFound),
+																			  "Malformed chunk block",
+																			  ErrorString);
+													}
+													continue;
+												}
+												if (VerifyChunkHash != ChunkHash)
+												{
+													std::string ErrorString = fmt::format(
+														"Chunk at {},{} in block attachment '{}' has mismatching hash, expected {}, got {}",
+														OffsetInBlock,
+														ChunkCompressedSize,
+														BlockDescription.BlockHash,
+														ChunkHash,
+														VerifyChunkHash);
+													ReportMessage(OptionalContext, ErrorString);
+													Info.MissingAttachmentCount.fetch_add(1);
+													if (!IgnoreMissingAttachments)
+													{
+														RemoteResult.SetError(gsl::narrow<int32_t>(HttpResponseCode::NotFound),
+																			  "Malformed chunk block",
+																			  ErrorString);
+													}
+													continue;
+												}
+												if (VerifyChunkSize != BlockDescription.ChunkRawLengths[ChunkBlockIndex])
+												{
+													std::string ErrorString = fmt::format(
+														"Chunk at {},{} in block attachment '{}' has mismatching raw size, expected {}, "
+														"got {}",
+														OffsetInBlock,
+														ChunkCompressedSize,
+														BlockDescription.BlockHash,
+														BlockDescription.ChunkRawLengths[ChunkBlockIndex],
+														VerifyChunkSize);
+													ReportMessage(OptionalContext, ErrorString);
+													Info.MissingAttachmentCount.fetch_add(1);
+													if (!IgnoreMissingAttachments)
+													{
+														RemoteResult.SetError(gsl::narrow<int32_t>(HttpResponseCode::NotFound),
+																			  "Malformed chunk block",
+																			  ErrorString);
+													}
+													continue;
+												}
+
+												WriteAttachmentBuffers.emplace_back(CompressedChunk.GetCompressed().Flatten().AsIoBuffer());
+												WriteRawHashes.emplace_back(ChunkHash);
+												PotentialSize += WriteAttachmentBuffers.back().GetSize();
+											}
+										}
+										OffsetInBlock += ChunkCompressedSize;
+									}
+
+									if (!WriteAttachmentBuffers.empty())
+									{
+										auto Results = ChunkStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
+										for (size_t Index = 0; Index < Results.size(); Index++)
+										{
+											const auto& Result = Results[Index];
+											if (Result.New)
+											{
+												Info.AttachmentBytesStored.fetch_add(WriteAttachmentBuffers[Index].GetSize());
+												Info.AttachmentsStored.fetch_add(1);
+												UsedSize += WriteAttachmentBuffers[Index].GetSize();
+											}
+										}
+										ZEN_DEBUG("Used {} (matching {}) out of {} for block {} range {}, {} ({} %) (use of matching {}%)",
+												  NiceBytes(UsedSize),
+												  NiceBytes(PotentialSize),
+												  NiceBytes(BlockPartSize),
+												  BlockDescription.BlockHash,
+												  BlockRange.RangeStart,
+												  BlockRange.RangeLength,
+												  (100 * UsedSize) / BlockPartSize,
+												  PotentialSize > 0 ? (UsedSize * 100) / PotentialSize : 0);
+									}
+								}
+								catch (const std::exception& Ex)
+								{
+									RemoteResult.SetError(gsl::narrow<int>(HttpResponseCode::InternalServerError),
+														  fmt::format("Failed save block attachment {} range {}, {}",
+																	  BlockDescription.BlockHash,
+																	  BlockRange.RangeStart,
+																	  BlockRange.RangeLength),
+														  Ex.what());
+								}
+							},
+							WorkerThreadPool::EMode::EnableBacklog);
+					}
+
+					ZEN_DEBUG("Loaded {} ranges from block attachment '{}' in {} ({})",
+							  BlockRangeCount,
+							  BlockDescription.BlockHash,
+							  NiceTimeSpanMs(static_cast<uint64_t>(DownloadElapsedSeconds * 1000)),
+							  NiceBytes(DownloadedBytes));
+				}
+				catch (const std::exception& Ex)
+				{
+					RemoteResult.SetError(gsl::narrow<int>(HttpResponseCode::InternalServerError),
+										  fmt::format("Failed to download block attachment {} ranges", BlockDescription.BlockHash),
+										  Ex.what());
+				}
+			},
+			WorkerThreadPool::EMode::EnableBacklog);
+	};
+
 	void DownloadAndSaveAttachment(CidStore&			 ChunkStore,
 								   RemoteProjectStore&	 RemoteStore,
 								   bool					 IgnoreMissingAttachments,
@@ -664,7 +1002,7 @@ namespace remotestore_impl {
 				{
 					uint64_t Unset = (std::uint64_t)-1;
 					DownloadStartMS.compare_exchange_strong(Unset, LoadAttachmentsTimer.GetElapsedTimeMs());
-					RemoteProjectStore::LoadAttachmentResult AttachmentResult = RemoteStore.LoadAttachment(RawHash);
+					RemoteProjectStore::LoadAttachmentResult AttachmentResult = RemoteStore.LoadAttachment(RawHash, {});
 					if (AttachmentResult.ErrorCode)
 					{
 						ReportMessage(OptionalContext,
@@ -680,10 +1018,10 @@ namespace remotestore_impl {
 						return;
 					}
 					uint64_t AttachmentSize = AttachmentResult.Bytes.GetSize();
-					ZEN_INFO("Loaded large attachment '{}' in {} ({})",
-							 RawHash,
-							 NiceTimeSpanMs(static_cast<uint64_t>(AttachmentResult.ElapsedSeconds * 1000)),
-							 NiceBytes(AttachmentSize));
+					ZEN_DEBUG("Loaded large attachment '{}' in {} ({})",
+							  RawHash,
+							  NiceTimeSpanMs(static_cast<uint64_t>(AttachmentResult.ElapsedSeconds * 1000)),
+							  NiceBytes(AttachmentSize));
 					Info.AttachmentsDownloaded.fetch_add(1);
 					if (RemoteResult.IsError())
 					{
@@ -1224,35 +1562,7 @@ BuildContainer(CidStore&																	ChunkStore,
 {
 	using namespace std::literals;
 
-	class JobContextLogOutput : public OperationLogOutput
-	{
-	public:
-		JobContextLogOutput(JobContext* OptionalContext) : m_OptionalContext(OptionalContext) {}
-		virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) override
-		{
-			ZEN_UNUSED(LogLevel);
-			if (m_OptionalContext)
-			{
-				fmt::basic_memory_buffer<char, 250> MessageBuffer;
-				fmt::vformat_to(fmt::appender(MessageBuffer), Format, Args);
-				remotestore_impl::ReportMessage(m_OptionalContext, std::string_view(MessageBuffer.data(), MessageBuffer.size()));
-			}
-		}
-
-		virtual void		 SetLogOperationName(std::string_view Name) override { ZEN_UNUSED(Name); }
-		virtual void		 SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) override { ZEN_UNUSED(StepIndex, StepCount); }
-		virtual uint32_t	 GetProgressUpdateDelayMS() override { return 0; }
-		virtual ProgressBar* CreateProgressBar(std::string_view InSubTask) override
-		{
-			ZEN_UNUSED(InSubTask);
-			return nullptr;
-		}
-
-	private:
-		JobContext* m_OptionalContext;
-	};
-
-	std::unique_ptr<OperationLogOutput> LogOutput(std::make_unique<JobContextLogOutput>(OptionalContext));
+	std::unique_ptr<OperationLogOutput> LogOutput(std::make_unique<remotestore_impl::JobContextLogOutput>(OptionalContext));
 
 	size_t OpCount = 0;
 
@@ -2768,14 +3078,15 @@ SaveOplog(CidStore&				 ChunkStore,
 };
 
 RemoteProjectStore::Result
-ParseOplogContainer(const CbObject&																	  ContainerObject,
-					const std::function<void(std::span<IoHash> RawHashes)>&							  OnReferencedAttachments,
-					const std::function<bool(const IoHash& RawHash)>&								  HasAttachment,
-					const std::function<void(const IoHash& BlockHash, std::vector<IoHash>&& Chunks)>& OnNeedBlock,
-					const std::function<void(const IoHash& RawHash)>&								  OnNeedAttachment,
-					const std::function<void(const ChunkedInfo&)>&									  OnChunkedAttachment,
-					CbObject&																		  OutOplogSection,
-					JobContext*																		  OptionalContext)
+ParseOplogContainer(
+	const CbObject&											ContainerObject,
+	const std::function<void(std::span<IoHash> RawHashes)>& OnReferencedAttachments,
+	const std::function<bool(const IoHash& RawHash)>&		HasAttachment,
+	const std::function<void(ThinChunkBlockDescription&& ThinBlockDescription, std::vector<uint32_t>&& NeededChunkIndexes)>& OnNeedBlock,
+	const std::function<void(const IoHash& RawHash)>& OnNeedAttachment,
+	const std::function<void(const ChunkedInfo&)>&	  OnChunkedAttachment,
+	CbObject&										  OutOplogSection,
+	JobContext*										  OptionalContext)
 {
 	using namespace std::literals;
 
@@ -2801,12 +3112,12 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 										  "Section has unexpected data type",
 										  "Failed to save oplog container"};
 	}
-	std::unordered_set<IoHash, IoHash::Hasher> OpsAttachments;
+	std::unordered_set<IoHash, IoHash::Hasher> NeededAttachments;
 	{
 		CbArrayView OpsArray = OutOplogSection["ops"sv].AsArrayView();
 		for (CbFieldView OpEntry : OpsArray)
 		{
-			OpEntry.IterateAttachments([&](CbFieldView FieldView) { OpsAttachments.insert(FieldView.AsAttachment()); });
+			OpEntry.IterateAttachments([&](CbFieldView FieldView) { NeededAttachments.insert(FieldView.AsAttachment()); });
 			if (remotestore_impl::IsCancelled(OptionalContext))
 			{
 				return RemoteProjectStore::Result{.ErrorCode	  = gsl::narrow<int>(HttpResponseCode::OK),
@@ -2816,7 +3127,7 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 		}
 	}
 	{
-		std::vector<IoHash> ReferencedAttachments(OpsAttachments.begin(), OpsAttachments.end());
+		std::vector<IoHash> ReferencedAttachments(NeededAttachments.begin(), NeededAttachments.end());
 		OnReferencedAttachments(ReferencedAttachments);
 	}
 
@@ -2827,24 +3138,27 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 										  .Reason		  = "Operation cancelled"};
 	}
 
-	remotestore_impl::ReportMessage(OptionalContext, fmt::format("Oplog references {} attachments", OpsAttachments.size()));
+	remotestore_impl::ReportMessage(OptionalContext, fmt::format("Oplog references {} attachments", NeededAttachments.size()));
 
 	CbArrayView ChunkedFilesArray = ContainerObject["chunkedfiles"sv].AsArrayView();
 	for (CbFieldView ChunkedFileField : ChunkedFilesArray)
 	{
 		CbObjectView ChunkedFileView = ChunkedFileField.AsObjectView();
 		IoHash		 RawHash		 = ChunkedFileView["rawhash"sv].AsHash();
-		if (OpsAttachments.contains(RawHash) && (!HasAttachment(RawHash)))
+		if (NeededAttachments.erase(RawHash) == 1)
 		{
-			ChunkedInfo Chunked = ReadChunkedInfo(ChunkedFileView);
-
-			OnReferencedAttachments(Chunked.ChunkHashes);
-			OpsAttachments.insert(Chunked.ChunkHashes.begin(), Chunked.ChunkHashes.end());
-			OnChunkedAttachment(Chunked);
-			ZEN_INFO("Requesting chunked attachment '{}' ({}) built from {} chunks",
-					 Chunked.RawHash,
-					 NiceBytes(Chunked.RawSize),
-					 Chunked.ChunkHashes.size());
+			if (!HasAttachment(RawHash))
+			{
+				ChunkedInfo Chunked = ReadChunkedInfo(ChunkedFileView);
+
+				OnReferencedAttachments(Chunked.ChunkHashes);
+				NeededAttachments.insert(Chunked.ChunkHashes.begin(), Chunked.ChunkHashes.end());
+				OnChunkedAttachment(Chunked);
+				ZEN_INFO("Requesting chunked attachment '{}' ({}) built from {} chunks",
+						 Chunked.RawHash,
+						 NiceBytes(Chunked.RawSize),
+						 Chunked.ChunkHashes.size());
+			}
 		}
 		if (remotestore_impl::IsCancelled(OptionalContext))
 		{
@@ -2854,6 +3168,8 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 		}
 	}
 
+	std::vector<ThinChunkBlockDescription> ThinBlocksDescriptions;
+
 	size_t		NeedBlockCount = 0;
 	CbArrayView BlocksArray	   = ContainerObject["blocks"sv].AsArrayView();
 	for (CbFieldView BlockField : BlocksArray)
@@ -2863,45 +3179,38 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 
 		CbArrayView ChunksArray = BlockView["chunks"sv].AsArrayView();
 
-		std::vector<IoHash> NeededChunks;
-		NeededChunks.reserve(ChunksArray.Num());
-		if (BlockHash == IoHash::Zero)
+		std::vector<IoHash> ChunkHashes;
+		ChunkHashes.reserve(ChunksArray.Num());
+		for (CbFieldView ChunkField : ChunksArray)
 		{
-			for (CbFieldView ChunkField : ChunksArray)
-			{
-				IoHash ChunkHash = ChunkField.AsBinaryAttachment();
-				if (OpsAttachments.erase(ChunkHash) == 1)
-				{
-					if (!HasAttachment(ChunkHash))
-					{
-						NeededChunks.emplace_back(ChunkHash);
-					}
-				}
-			}
+			ChunkHashes.push_back(ChunkField.AsHash());
 		}
-		else
+		ThinBlocksDescriptions.push_back(ThinChunkBlockDescription{.BlockHash = BlockHash, .ChunkRawHashes = std::move(ChunkHashes)});
+	}
+
+	for (ThinChunkBlockDescription& ThinBlockDescription : ThinBlocksDescriptions)
+	{
+		std::vector<uint32_t> NeededBlockChunkIndexes;
+		for (uint32_t ChunkIndex = 0; ChunkIndex < ThinBlockDescription.ChunkRawHashes.size(); ChunkIndex++)
 		{
-			for (CbFieldView ChunkField : ChunksArray)
+			const IoHash& ChunkHash = ThinBlockDescription.ChunkRawHashes[ChunkIndex];
+			if (NeededAttachments.erase(ChunkHash) == 1)
 			{
-				const IoHash ChunkHash = ChunkField.AsHash();
-				if (OpsAttachments.erase(ChunkHash) == 1)
+				if (!HasAttachment(ChunkHash))
 				{
-					if (!HasAttachment(ChunkHash))
-					{
-						NeededChunks.emplace_back(ChunkHash);
-					}
+					NeededBlockChunkIndexes.push_back(ChunkIndex);
 				}
 			}
 		}
-
-		if (!NeededChunks.empty())
+		if (!NeededBlockChunkIndexes.empty())
 		{
-			OnNeedBlock(BlockHash, std::move(NeededChunks));
-			if (BlockHash != IoHash::Zero)
+			if (ThinBlockDescription.BlockHash != IoHash::Zero)
 			{
 				NeedBlockCount++;
 			}
+			OnNeedBlock(std::move(ThinBlockDescription), std::move(NeededBlockChunkIndexes));
 		}
+
 		if (remotestore_impl::IsCancelled(OptionalContext))
 		{
 			return RemoteProjectStore::Result{.ErrorCode	  = gsl::narrow<int>(HttpResponseCode::OK),
@@ -2909,6 +3218,7 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 											  .Reason		  = "Operation cancelled"};
 		}
 	}
+
 	remotestore_impl::ReportMessage(OptionalContext,
 									fmt::format("Requesting {} of {} attachment blocks", NeedBlockCount, BlocksArray.Num()));
 
@@ -2918,7 +3228,7 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 	{
 		IoHash AttachmentHash = LargeChunksField.AsBinaryAttachment();
 
-		if (OpsAttachments.erase(AttachmentHash) == 1)
+		if (NeededAttachments.erase(AttachmentHash) == 1)
 		{
 			if (!HasAttachment(AttachmentHash))
 			{
@@ -2941,14 +3251,15 @@ ParseOplogContainer(const CbObject&																	  ContainerObject,
 }
 
 RemoteProjectStore::Result
-SaveOplogContainer(ProjectStore::Oplog&																 Oplog,
-				   const CbObject&																	 ContainerObject,
-				   const std::function<void(std::span<IoHash> RawHashes)>&							 OnReferencedAttachments,
-				   const std::function<bool(const IoHash& RawHash)>&								 HasAttachment,
-				   const std::function<void(const IoHash& BlockHash, std::vector<IoHash>&& Chunks)>& OnNeedBlock,
-				   const std::function<void(const IoHash& RawHash)>&								 OnNeedAttachment,
-				   const std::function<void(const ChunkedInfo&)>&									 OnChunkedAttachment,
-				   JobContext*																		 OptionalContext)
+SaveOplogContainer(
+	ProjectStore::Oplog&									Oplog,
+	const CbObject&											ContainerObject,
+	const std::function<void(std::span<IoHash> RawHashes)>& OnReferencedAttachments,
+	const std::function<bool(const IoHash& RawHash)>&		HasAttachment,
+	const std::function<void(ThinChunkBlockDescription&& ThinBlockDescription, std::vector<uint32_t>&& NeededChunkIndexes)>& OnNeedBlock,
+	const std::function<void(const IoHash& RawHash)>& OnNeedAttachment,
+	const std::function<void(const ChunkedInfo&)>&	  OnChunkedAttachment,
+	JobContext*										  OptionalContext)
 {
 	using namespace std::literals;
 
@@ -2972,18 +3283,23 @@ SaveOplogContainer(ProjectStore::Oplog&																 Oplog,
 }
 
 RemoteProjectStore::Result
-LoadOplog(CidStore&			   ChunkStore,
-		  RemoteProjectStore&  RemoteStore,
-		  ProjectStore::Oplog& Oplog,
-		  WorkerThreadPool&	   NetworkWorkerPool,
-		  WorkerThreadPool&	   WorkerPool,
-		  bool				   ForceDownload,
-		  bool				   IgnoreMissingAttachments,
-		  bool				   CleanOplog,
-		  JobContext*		   OptionalContext)
+LoadOplog(CidStore&				   ChunkStore,
+		  RemoteProjectStore&	   RemoteStore,
+		  ProjectStore::Oplog&	   Oplog,
+		  WorkerThreadPool&		   NetworkWorkerPool,
+		  WorkerThreadPool&		   WorkerPool,
+		  bool					   ForceDownload,
+		  bool					   IgnoreMissingAttachments,
+		  bool					   CleanOplog,
+		  EPartialBlockRequestMode PartialBlockRequestMode,
+		  double				   HostLatencySec,
+		  double				   CacheLatencySec,
+		  JobContext*			   OptionalContext)
 {
 	using namespace std::literals;
 
+	std::unique_ptr<OperationLogOutput> LogOutput(std::make_unique<remotestore_impl::JobContextLogOutput>(OptionalContext));
+
 	remotestore_impl::DownloadInfo Info;
 
 	Stopwatch Timer;
@@ -3035,6 +3351,14 @@ LoadOplog(CidStore&			   ChunkStore,
 		return false;
 	};
 
+	struct NeededBlockDownload
+	{
+		ThinChunkBlockDescription ThinBlockDescription;
+		std::vector<uint32_t>	  NeededChunkIndexes;
+	};
+
+	std::vector<NeededBlockDownload> NeededBlockDownloads;
+
 	auto OnNeedBlock = [&RemoteStore,
 						&ChunkStore,
 						&NetworkWorkerPool,
@@ -3047,8 +3371,9 @@ LoadOplog(CidStore&			   ChunkStore,
 						&Info,
 						&LoadAttachmentsTimer,
 						&DownloadStartMS,
+						&NeededBlockDownloads,
 						IgnoreMissingAttachments,
-						OptionalContext](const IoHash& BlockHash, std::vector<IoHash>&& Chunks) {
+						OptionalContext](ThinChunkBlockDescription&& ThinBlockDescription, std::vector<uint32_t>&& NeededChunkIndexes) {
 		if (RemoteResult.IsError())
 		{
 			return;
@@ -3056,7 +3381,7 @@ LoadOplog(CidStore&			   ChunkStore,
 
 		BlockCountToDownload++;
 		AttachmentCount.fetch_add(1);
-		if (BlockHash == IoHash::Zero)
+		if (ThinBlockDescription.BlockHash == IoHash::Zero)
 		{
 			DownloadAndSaveBlockChunks(ChunkStore,
 									   RemoteStore,
@@ -3070,25 +3395,13 @@ LoadOplog(CidStore&			   ChunkStore,
 									   Info,
 									   LoadAttachmentsTimer,
 									   DownloadStartMS,
-									   Chunks);
+									   std::move(ThinBlockDescription),
+									   std::move(NeededChunkIndexes));
 		}
 		else
 		{
-			DownloadAndSaveBlock(ChunkStore,
-								 RemoteStore,
-								 IgnoreMissingAttachments,
-								 OptionalContext,
-								 NetworkWorkerPool,
-								 WorkerPool,
-								 AttachmentsDownloadLatch,
-								 AttachmentsWriteLatch,
-								 RemoteResult,
-								 Info,
-								 LoadAttachmentsTimer,
-								 DownloadStartMS,
-								 BlockHash,
-								 Chunks,
-								 3);
+			NeededBlockDownloads.push_back(NeededBlockDownload{.ThinBlockDescription = std::move(ThinBlockDescription),
+															   .NeededChunkIndexes	 = std::move(NeededChunkIndexes)});
 		}
 	};
 
@@ -3132,12 +3445,7 @@ LoadOplog(CidStore&			   ChunkStore,
 	};
 
 	std::vector<ChunkedInfo> FilesToDechunk;
-	auto					 OnChunkedAttachment = [&Oplog, &ChunkStore, &FilesToDechunk, ForceDownload](const ChunkedInfo& Chunked) {
-		if (ForceDownload || !ChunkStore.ContainsChunk(Chunked.RawHash))
-		{
-			FilesToDechunk.push_back(Chunked);
-		}
-	};
+	auto					 OnChunkedAttachment = [&FilesToDechunk](const ChunkedInfo& Chunked) { FilesToDechunk.push_back(Chunked); };
 
 	auto OnReferencedAttachments = [&Oplog](std::span<IoHash> RawHashes) { Oplog.CaptureAddedAttachments(RawHashes); };
 
@@ -3165,6 +3473,185 @@ LoadOplog(CidStore&			   ChunkStore,
 												BlockCountToDownload,
 												FilesToDechunk.size()));
 
+	std::vector<IoHash> BlockHashes;
+	std::vector<IoHash> AllNeededChunkHashes;
+	BlockHashes.reserve(NeededBlockDownloads.size());
+	for (const NeededBlockDownload& BlockDownload : NeededBlockDownloads)
+	{
+		BlockHashes.push_back(BlockDownload.ThinBlockDescription.BlockHash);
+		for (uint32_t ChunkIndex : BlockDownload.NeededChunkIndexes)
+		{
+			AllNeededChunkHashes.push_back(BlockDownload.ThinBlockDescription.ChunkRawHashes[ChunkIndex]);
+		}
+	}
+
+	tsl::robin_map<IoHash, uint32_t, IoHash::Hasher> AllNeededPartialChunkHashesLookup = BuildHashLookup(AllNeededChunkHashes);
+	std::vector<std::atomic<bool>>					 ChunkDownloadedFlags(AllNeededChunkHashes.size());
+	std::vector<bool>								 DownloadedViaLegacyChunkFlag(AllNeededChunkHashes.size(), false);
+	ChunkBlockAnalyser::BlockResult					 PartialBlocksResult;
+
+	RemoteProjectStore::GetBlockDescriptionsResult BlockDescriptions = RemoteStore.GetBlockDescriptions(BlockHashes);
+	std::vector<IoHash>							   BlocksWithDescription;
+	BlocksWithDescription.reserve(BlockDescriptions.Blocks.size());
+	for (const ChunkBlockDescription& BlockDescription : BlockDescriptions.Blocks)
+	{
+		BlocksWithDescription.push_back(BlockDescription.BlockHash);
+	}
+	{
+		auto WantIt = NeededBlockDownloads.begin();
+		auto FindIt = BlockDescriptions.Blocks.begin();
+		while (WantIt != NeededBlockDownloads.end())
+		{
+			if (FindIt == BlockDescriptions.Blocks.end())
+			{
+				// Fall back to full download as we can't get enough information about the block
+				DownloadAndSaveBlock(ChunkStore,
+									 RemoteStore,
+									 IgnoreMissingAttachments,
+									 OptionalContext,
+									 NetworkWorkerPool,
+									 WorkerPool,
+									 AttachmentsDownloadLatch,
+									 AttachmentsWriteLatch,
+									 RemoteResult,
+									 Info,
+									 LoadAttachmentsTimer,
+									 DownloadStartMS,
+									 WantIt->ThinBlockDescription.BlockHash,
+									 AllNeededPartialChunkHashesLookup,
+									 ChunkDownloadedFlags,
+									 3);
+				for (uint32_t BlockChunkIndex : WantIt->NeededChunkIndexes)
+				{
+					const IoHash& ChunkHash = WantIt->ThinBlockDescription.ChunkRawHashes[BlockChunkIndex];
+					auto		  It		= AllNeededPartialChunkHashesLookup.find(ChunkHash);
+					ZEN_ASSERT(It != AllNeededPartialChunkHashesLookup.end());
+					uint32_t ChunkIndex						 = It->second;
+					DownloadedViaLegacyChunkFlag[ChunkIndex] = true;
+				}
+				WantIt++;
+			}
+			else if (WantIt->ThinBlockDescription.BlockHash == FindIt->BlockHash)
+			{
+				// Found
+				FindIt++;
+				WantIt++;
+			}
+			else
+			{
+				// Not a requested block?
+				ZEN_ASSERT(false);
+			}
+		}
+	}
+	if (!AllNeededChunkHashes.empty())
+	{
+		std::vector<ChunkBlockAnalyser::EPartialBlockDownloadMode> PartialBlockDownloadModes;
+
+		if (PartialBlockRequestMode == EPartialBlockRequestMode::Off)
+		{
+			PartialBlockDownloadModes.resize(BlocksWithDescription.size(), ChunkBlockAnalyser::EPartialBlockDownloadMode::Off);
+		}
+		else
+		{
+			RemoteProjectStore::AttachmentExistsInCacheResult CacheExistsResult =
+				RemoteStore.AttachmentExistsInCache(BlocksWithDescription);
+			if (CacheExistsResult.ErrorCode != 0 || CacheExistsResult.HasBody.size() != BlocksWithDescription.size())
+			{
+				CacheExistsResult.HasBody.resize(BlocksWithDescription.size(), false);
+			}
+
+			PartialBlockDownloadModes.reserve(BlocksWithDescription.size());
+
+			for (bool ExistsInCache : CacheExistsResult.HasBody)
+			{
+				if (PartialBlockRequestMode == EPartialBlockRequestMode::All)
+				{
+					PartialBlockDownloadModes.push_back(ExistsInCache ? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																	  : ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRange);
+				}
+				else if (PartialBlockRequestMode == EPartialBlockRequestMode::ZenCacheOnly)
+				{
+					PartialBlockDownloadModes.push_back(ExistsInCache ? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																	  : ChunkBlockAnalyser::EPartialBlockDownloadMode::Off);
+				}
+				else if (PartialBlockRequestMode == EPartialBlockRequestMode::Mixed)
+				{
+					PartialBlockDownloadModes.push_back(ExistsInCache ? ChunkBlockAnalyser::EPartialBlockDownloadMode::MultiRangeHighSpeed
+																	  : ChunkBlockAnalyser::EPartialBlockDownloadMode::SingleRange);
+				}
+			}
+		}
+
+		ZEN_ASSERT(PartialBlockDownloadModes.size() == BlocksWithDescription.size());
+
+		ChunkBlockAnalyser PartialAnalyser(*LogOutput,
+										   BlockDescriptions.Blocks,
+										   ChunkBlockAnalyser::Options{.IsQuiet					= false,
+																	   .IsVerbose				= false,
+																	   .HostLatencySec			= HostLatencySec,
+																	   .HostHighSpeedLatencySec = CacheLatencySec});
+
+		std::vector<ChunkBlockAnalyser::NeededBlock> NeededBlocks =
+			PartialAnalyser.GetNeeded(AllNeededPartialChunkHashesLookup,
+									  [&](uint32_t ChunkIndex) { return !DownloadedViaLegacyChunkFlag[ChunkIndex]; });
+
+		PartialBlocksResult = PartialAnalyser.CalculatePartialBlockDownloads(NeededBlocks, PartialBlockDownloadModes);
+		for (uint32_t FullBlockIndex : PartialBlocksResult.FullBlockIndexes)
+		{
+			DownloadAndSaveBlock(ChunkStore,
+								 RemoteStore,
+								 IgnoreMissingAttachments,
+								 OptionalContext,
+								 NetworkWorkerPool,
+								 WorkerPool,
+								 AttachmentsDownloadLatch,
+								 AttachmentsWriteLatch,
+								 RemoteResult,
+								 Info,
+								 LoadAttachmentsTimer,
+								 DownloadStartMS,
+								 BlockDescriptions.Blocks[FullBlockIndex].BlockHash,
+								 AllNeededPartialChunkHashesLookup,
+								 ChunkDownloadedFlags,
+								 3);
+		}
+
+		for (size_t BlockRangeIndex = 0; BlockRangeIndex < PartialBlocksResult.BlockRanges.size();)
+		{
+			size_t											RangeCount		  = 1;
+			size_t											RangesLeft		  = PartialBlocksResult.BlockRanges.size() - BlockRangeIndex;
+			const ChunkBlockAnalyser::BlockRangeDescriptor& CurrentBlockRange = PartialBlocksResult.BlockRanges[BlockRangeIndex];
+			while (RangeCount < RangesLeft &&
+				   CurrentBlockRange.BlockIndex == PartialBlocksResult.BlockRanges[BlockRangeIndex + RangeCount].BlockIndex)
+			{
+				RangeCount++;
+			}
+
+			DownloadAndSavePartialBlock(ChunkStore,
+										RemoteStore,
+										IgnoreMissingAttachments,
+										OptionalContext,
+										NetworkWorkerPool,
+										WorkerPool,
+										AttachmentsDownloadLatch,
+										AttachmentsWriteLatch,
+										RemoteResult,
+										Info,
+										LoadAttachmentsTimer,
+										DownloadStartMS,
+										BlockDescriptions.Blocks[CurrentBlockRange.BlockIndex],
+										PartialBlocksResult.BlockRanges,
+										BlockRangeIndex,
+										RangeCount,
+										AllNeededPartialChunkHashesLookup,
+										ChunkDownloadedFlags,
+										3);
+
+			BlockRangeIndex += RangeCount;
+		}
+	}
+
 	AttachmentsDownloadLatch.CountDown();
 	while (!AttachmentsDownloadLatch.Wait(1000))
 	{
@@ -3478,21 +3965,30 @@ LoadOplog(CidStore&			   ChunkStore,
 		}
 	}
 
-	remotestore_impl::ReportMessage(
-		OptionalContext,
-		fmt::format("Loaded oplog '{}' {} in {} ({}), Blocks: {} ({}), Attachments: {} ({}), Stored: {} ({}), Missing: {} {}",
-					RemoteStoreInfo.ContainerName,
-					Result.ErrorCode == 0 ? "SUCCESS" : "FAILURE",
-					NiceTimeSpanMs(static_cast<uint64_t>(Result.ElapsedSeconds * 1000.0)),
-					NiceBytes(Info.OplogSizeBytes),
-					Info.AttachmentBlocksDownloaded.load(),
-					NiceBytes(Info.AttachmentBlockBytesDownloaded.load()),
-					Info.AttachmentsDownloaded.load(),
-					NiceBytes(Info.AttachmentBytesDownloaded.load()),
-					Info.AttachmentsStored.load(),
-					NiceBytes(Info.AttachmentBytesStored.load()),
-					Info.MissingAttachmentCount.load(),
-					remotestore_impl::GetStats(RemoteStore.GetStats(), TransferWallTimeMS)));
+	uint64_t TotalDownloads =
+		1 + Info.AttachmentBlocksDownloaded.load() + Info.AttachmentBlocksRangesDownloaded.load() + Info.AttachmentsDownloaded.load();
+	uint64_t TotalBytesDownloaded = Info.OplogSizeBytes + Info.AttachmentBlockBytesDownloaded.load() +
+									Info.AttachmentBlockRangeBytesDownloaded.load() + Info.AttachmentBytesDownloaded.load();
+
+	remotestore_impl::ReportMessage(OptionalContext,
+									fmt::format("Loaded oplog '{}' {} in {} ({}), Blocks: {} ({}), BlockRanges: {} ({}), Attachments: {} "
+												"({}), Total: {} ({}), Stored: {} ({}), Missing: {} {}",
+												RemoteStoreInfo.ContainerName,
+												Result.ErrorCode == 0 ? "SUCCESS" : "FAILURE",
+												NiceTimeSpanMs(static_cast<uint64_t>(Result.ElapsedSeconds * 1000.0)),
+												NiceBytes(Info.OplogSizeBytes),
+												Info.AttachmentBlocksDownloaded.load(),
+												NiceBytes(Info.AttachmentBlockBytesDownloaded.load()),
+												Info.AttachmentBlocksRangesDownloaded.load(),
+												NiceBytes(Info.AttachmentBlockRangeBytesDownloaded.load()),
+												Info.AttachmentsDownloaded.load(),
+												NiceBytes(Info.AttachmentBytesDownloaded.load()),
+												TotalDownloads,
+												NiceBytes(TotalBytesDownloaded),
+												Info.AttachmentsStored.load(),
+												NiceBytes(Info.AttachmentBytesStored.load()),
+												Info.MissingAttachmentCount.load(),
+												remotestore_impl::GetStats(RemoteStore.GetStats(), TransferWallTimeMS)));
 
 	return Result;
 }
@@ -3697,6 +4193,9 @@ TEST_CASE_TEMPLATE("project.store.export",
 														/*Force*/ false,
 														/*IgnoreMissingAttachments*/ false,
 														/*CleanOplog*/ false,
+														EPartialBlockRequestMode::Mixed,
+														/*HostLatencySec*/ -1.0,
+														/*CacheLatencySec*/ -1.0,
 														nullptr);
 	CHECK(ImportResult.ErrorCode == 0);
 
@@ -3708,6 +4207,9 @@ TEST_CASE_TEMPLATE("project.store.export",
 															 /*Force*/ true,
 															 /*IgnoreMissingAttachments*/ false,
 															 /*CleanOplog*/ false,
+															 EPartialBlockRequestMode::Mixed,
+															 /*HostLatencySec*/ -1.0,
+															 /*CacheLatencySec*/ -1.0,
 															 nullptr);
 	CHECK(ImportForceResult.ErrorCode == 0);
 
@@ -3719,6 +4221,9 @@ TEST_CASE_TEMPLATE("project.store.export",
 															 /*Force*/ false,
 															 /*IgnoreMissingAttachments*/ false,
 															 /*CleanOplog*/ true,
+															 EPartialBlockRequestMode::Mixed,
+															 /*HostLatencySec*/ -1.0,
+															 /*CacheLatencySec*/ -1.0,
 															 nullptr);
 	CHECK(ImportCleanResult.ErrorCode == 0);
 
@@ -3730,6 +4235,9 @@ TEST_CASE_TEMPLATE("project.store.export",
 																  /*Force*/ true,
 																  /*IgnoreMissingAttachments*/ false,
 																  /*CleanOplog*/ true,
+																  EPartialBlockRequestMode::Mixed,
+																  /*HostLatencySec*/ -1.0,
+																  /*CacheLatencySec*/ -1.0,
 																  nullptr);
 	CHECK(ImportForceCleanResult.ErrorCode == 0);
 }
diff --git a/src/zenremotestore/projectstore/zenremoteprojectstore.cpp b/src/zenremotestore/projectstore/zenremoteprojectstore.cpp
index ab82edbef..b4c1156ac 100644
--- a/src/zenremotestore/projectstore/zenremoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/zenremoteprojectstore.cpp
@@ -249,7 +249,18 @@ public:
 		return GetKnownBlocksResult{{.ErrorCode = static_cast<int>(HttpResponseCode::NoContent)}};
 	}
 
-	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
+	virtual GetBlockDescriptionsResult GetBlockDescriptions(std::span<const IoHash> BlockHashes) override
+	{
+		ZEN_UNUSED(BlockHashes);
+		return GetBlockDescriptionsResult{Result{.ErrorCode = int(HttpResponseCode::NotFound)}};
+	}
+
+	virtual AttachmentExistsInCacheResult AttachmentExistsInCache(std::span<const IoHash> RawHashes) override
+	{
+		return AttachmentExistsInCacheResult{Result{.ErrorCode = 0}, std::vector<bool>(RawHashes.size(), false)};
+	}
+
+	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash, const AttachmentRange& Range) override
 	{
 		std::string			 LoadRequest = fmt::format("/{}/oplog/{}/{}"sv, m_Project, m_Oplog, RawHash);
 		HttpClient::Response Response =
@@ -257,12 +268,7 @@ public:
 		AddStats(Response);
 
 		LoadAttachmentResult Result = LoadAttachmentResult{ConvertResult(Response)};
-		if (!Result.ErrorCode)
-		{
-			Result.Bytes = Response.ResponsePayload;
-			Result.Bytes.MakeOwned();
-		}
-		if (!Result.ErrorCode)
+		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed fetching oplog attachment from {}/{}/{}/{}. Reason: '{}'",
 										m_ProjectStoreUrl,
@@ -271,6 +277,15 @@ public:
 										RawHash,
 										Result.Reason);
 		}
+		if (!Result.ErrorCode && Range)
+		{
+			Result.Bytes = IoBuffer(Response.ResponsePayload, Range.Offset, Range.Bytes);
+		}
+		else
+		{
+			Result.Bytes = Response.ResponsePayload;
+		}
+		Result.Bytes.MakeOwned();
 		return Result;
 	}