zenstore bug-fixes from static analysis pass (#815)

**Bug fixes across zenstore, zenremotestore, and related subsystems, primarily surfaced by static analysis.**

## Cache subsystem (cachedisklayer.cpp)

- Fixed tombstone scoping bug: tombstone flag and missing entry were recorded outside the block where data was removed, causing non-missing entries to be incorrectly tombstoned
- Fixed use-after-overwrite: `RemoveMemCachedData`/`RemoveMetaData` were called after `Payload` was overwritten on cache put, leaking stale data
- Fixed incorrect retry sleep formula (`100 - (3 - RetriesLeft) * 100` always produced the same or negative value; corrected to `(3 - RetriesLeft) * 100`)
- Fixed broken `break` missing from sidecar file read loop, causing reads past valid data
- Fixed missing format argument in three `ZEN_WARN`/`ZEN_ERROR` log calls (format string had `{}` placeholders with no corresponding argument, or vice versa)
- Fixed elapsed timer being accumulated inside the wrong scope in `HandleRpcGetCacheRecords`
- Fixed test asserting against unserialized `RecordPolicy` instead of the deserialized `Loaded` copy
- Initialized `AbortFlag`/`PauseFlag` atomics at declaration (UB if read before first write)

## Build store (buildstore.cpp / buildstore.h)

- Fixed wrong variable used in warning log: used loop index `ResultIndex` instead of `Index`/`MetaLocationResultIndexes[Index]`, logging wrong hash values
- Fixed `sizeof(AccessTimesHeader)` used instead of `sizeof(AccessTimeRecord)` when advancing write offset, corrupting the access times file if the sizes differ
- Initialized `m_LastAccessTimeUpdateCount` atomic member (was uninitialized)
- Changed map iteration loops to use `const auto&` to avoid unnecessary copies

## Project store (projectstore.cpp / projectstore.h)

- Fixed wrong iterator dereferenced in `IterateChunks`: used `ChunkIt->second` (from a different map lookup) instead of `MetaIt->second`
- Fixed wrong assert variable: `Sizes[Index]` should be `RawSizes[Index]`
- Fixed `MakeTombstone`/`IsTombstone` inconsistency: `MakeTombstone` was zeroing `OpLsn` but `IsTombstone` checks `OpLsn.Number != 0`; tombstone creation now preserves `OpLsn`
- Fixed uninitialized `InvalidEntries` counter
- Fixed format string mismatch in warning log
- Initialized `AbortFlag`/`PauseFlag` atomics; changed map iteration to `const auto&`

## Workspaces (workspaces.cpp)

- Fixed missing alias registration when a workspace share is updated: alias was deleted but never re-inserted
- Fixed integer overflow in range clamping: `(RequestedOffset + RequestedSize) > Size` could wrap; corrected to `RequestedSize > Size - RequestedOffset`
- Changed map iteration loops to `const auto&`

## CAS subsystem (cas.cpp, caslog.cpp, compactcas.cpp, filecas.cpp)

- Fixed `IterateChunks` passing original `Payload` buffer instead of the modified `Chunk` buffer (content type was set on the copy but the original was sent to the callback)
- Fixed invalid `std::future::get()` call on default-constructed futures
- Fixed sign-comparison in `CasLogFile::Replay` loop (`int i` vs `size_t`)
- Changed `CasLogFile::IsValid` and `Open` to take `const std::filesystem::path&` instead of by value
- Fixed format string in `~CasContainerStrategy` error log

## Remote store (zenremotestore)

- Fixed `FolderContent::operator==` always returning true: loop variable `PathCount` was initialized to 0 instead of `Paths.size()`
- Fixed `GetChunkIndexForRawHash` looking up from wrong map (`RawHashToSequenceIndex` instead of `ChunkHashToChunkIndex`)
- Fixed double-counted `UniqueSequencesFound` stat (incremented in both branches of an if/else)
- Fixed `RawSize` sentinel value truncation: `(uint32_t)-1` assigned to a `uint64_t` field; corrected to `(uint64_t)-1`
- Initialized uninitialized atomic and struct members across `buildstorageoperations.h`, `chunkblock.h`, and `remoteprojectstore.h`

25 files changed, 144 insertions, 138 deletions

diff --git a/src/zenremotestore/chunking/chunkedcontent.cpp b/src/zenremotestore/chunking/chunkedcontent.cpp
index 62c927508..c09ab9d3a 100644
--- a/src/zenremotestore/chunking/chunkedcontent.cpp
+++ b/src/zenremotestore/chunking/chunkedcontent.cpp
@@ -166,7 +166,6 @@ namespace {
 					if (Chunked.Info.ChunkSequence.empty())
 					{
 						AddChunkSequence(Stats, OutChunkedContent.ChunkedContent, ChunkHashToChunkIndex, Chunked.Info.RawHash, RawSize);
-						Stats.UniqueSequencesFound++;
 					}
 					else
 					{
@@ -186,7 +185,6 @@ namespace {
 										 Chunked.Info.ChunkHashes,
 										 ChunkSizes);
 					}
-					Stats.UniqueSequencesFound++;
 				}
 			});
 			Stats.FilesChunked++;
@@ -253,7 +251,7 @@ FolderContent::operator==(const FolderContent& Rhs) const
 	if ((Platform == Rhs.Platform) && (RawSizes == Rhs.RawSizes) && (Attributes == Rhs.Attributes) &&
 		(ModificationTicks == Rhs.ModificationTicks) && (Paths.size() == Rhs.Paths.size()))
 	{
-		size_t PathCount = 0;
+		size_t PathCount = Paths.size();
 		for (size_t PathIndex = 0; PathIndex < PathCount; PathIndex++)
 		{
 			if (Paths[PathIndex].generic_string() != Rhs.Paths[PathIndex].generic_string())
diff --git a/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h b/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
index 875b8593b..0d2eded58 100644
--- a/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
+++ b/src/zenremotestore/include/zenremotestore/builds/buildstorageoperations.h
@@ -161,7 +161,7 @@ public:
 	DownloadStatistics			 m_DownloadStats;
 	WriteChunkStatistics		 m_WriteChunkStats;
 	RebuildFolderStateStatistics m_RebuildFolderStateStats;
-	std::atomic<uint64_t>		 m_WrittenChunkByteCount;
+	std::atomic<uint64_t>		 m_WrittenChunkByteCount = 0;
 
 private:
 	struct BlockWriteOps
@@ -186,7 +186,7 @@ private:
 		uint32_t ScavengedContentIndex = (uint32_t)-1;
 		uint32_t ScavengedPathIndex	   = (uint32_t)-1;
 		uint32_t RemoteSequenceIndex   = (uint32_t)-1;
-		uint64_t RawSize			   = (uint32_t)-1;
+		uint64_t RawSize			   = (uint64_t)-1;
 	};
 
 	struct CopyChunkData
@@ -362,7 +362,7 @@ private:
 	const std::filesystem::path				  m_TempDownloadFolderPath;
 	const std::filesystem::path				  m_TempBlockFolderPath;
 
-	std::atomic<uint64_t> m_ValidatedChunkByteCount;
+	std::atomic<uint64_t> m_ValidatedChunkByteCount = 0;
 };
 
 struct FindBlocksStatistics
diff --git a/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h b/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
index 7aae1442e..20b6fd371 100644
--- a/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
+++ b/src/zenremotestore/include/zenremotestore/chunking/chunkblock.h
@@ -24,7 +24,7 @@ struct ThinChunkBlockDescription
 
 struct ChunkBlockDescription : public ThinChunkBlockDescription
 {
-	uint64_t			  HeaderSize;
+	uint64_t			  HeaderSize = 0;
 	std::vector<uint32_t> ChunkRawLengths;
 	std::vector<uint32_t> ChunkCompressedLengths;
 };
diff --git a/src/zenremotestore/include/zenremotestore/chunking/chunkedcontent.h b/src/zenremotestore/include/zenremotestore/chunking/chunkedcontent.h
index d402bd3f0..f44381e42 100644
--- a/src/zenremotestore/include/zenremotestore/chunking/chunkedcontent.h
+++ b/src/zenremotestore/include/zenremotestore/chunking/chunkedcontent.h
@@ -231,7 +231,7 @@ GetSequenceIndexForRawHash(const ChunkedContentLookup& Lookup, const IoHash& Raw
 inline uint32_t
 GetChunkIndexForRawHash(const ChunkedContentLookup& Lookup, const IoHash& RawHash)
 {
-	return Lookup.RawHashToSequenceIndex.at(RawHash);
+	return Lookup.ChunkHashToChunkIndex.at(RawHash);
 }
 
 inline uint32_t
diff --git a/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h b/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
index 2cf10c664..42786d0f2 100644
--- a/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
+++ b/src/zenremotestore/include/zenremotestore/projectstore/remoteprojectstore.h
@@ -92,22 +92,22 @@ public:
 
 	struct RemoteStoreInfo
 	{
-		bool		CreateBlocks;
-		bool		UseTempBlockFiles;
-		bool		AllowChunking;
+		bool		CreateBlocks	  = false;
+		bool		UseTempBlockFiles = false;
+		bool		AllowChunking	  = false;
 		std::string ContainerName;
 		std::string Description;
 	};
 
 	struct Stats
 	{
-		std::uint64_t m_SentBytes;
-		std::uint64_t m_ReceivedBytes;
-		std::uint64_t m_RequestTimeNS;
-		std::uint64_t m_RequestCount;
-		std::uint64_t m_PeakSentBytes;
-		std::uint64_t m_PeakReceivedBytes;
-		std::uint64_t m_PeakBytesPerSec;
+		std::uint64_t m_SentBytes		  = 0;
+		std::uint64_t m_ReceivedBytes	  = 0;
+		std::uint64_t m_RequestTimeNS	  = 0;
+		std::uint64_t m_RequestCount	  = 0;
+		std::uint64_t m_PeakSentBytes	  = 0;
+		std::uint64_t m_PeakReceivedBytes = 0;
+		std::uint64_t m_PeakBytesPerSec	  = 0;
 	};
 
 	struct ExtendedStats
diff --git a/src/zenstore/buildstore/buildstore.cpp b/src/zenstore/buildstore/buildstore.cpp
index 49ed7cdd2..dff1c3c61 100644
--- a/src/zenstore/buildstore/buildstore.cpp
+++ b/src/zenstore/buildstore/buildstore.cpp
@@ -373,8 +373,8 @@ BuildStore::PutMetadatas(std::span<const IoHash> BlobHashes, std::span<const IoB
 	CompressedMetadataBuffers.resize(Metadatas.size());
 	if (OptionalWorkerPool)
 	{
-		std::atomic<bool> AbortFlag;
-		std::atomic<bool> PauseFlag;
+		std::atomic<bool> AbortFlag{false};
+		std::atomic<bool> PauseFlag{false};
 		ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 		for (size_t Index = 0; Index < Metadatas.size(); Index++)
 		{
@@ -505,8 +505,8 @@ BuildStore::GetMetadatas(std::span<const IoHash> BlobHashes, WorkerThreadPool* O
 					else
 					{
 						ZEN_WARN("Metadata {} for blob {} is malformed (not a compressed binary format)",
-								 MetadataHashes[ResultIndex],
-								 BlobHashes[ResultIndex]);
+								 MetadataHashes[Index],
+								 BlobHashes[MetaLocationResultIndexes[Index]]);
 					}
 				}
 			}
@@ -561,7 +561,7 @@ BuildStore::GetStorageStats() const
 		RwLock::SharedLockScope _(m_Lock);
 		Result.EntryCount = m_BlobLookup.size();
 
-		for (auto LookupIt : m_BlobLookup)
+		for (const auto& LookupIt : m_BlobLookup)
 		{
 			const BlobIndex	 ReadBlobIndex = LookupIt.second;
 			const BlobEntry& ReadBlobEntry = m_BlobEntries[ReadBlobIndex];
@@ -634,7 +634,7 @@ BuildStore::CompactState()
 	const size_t MetadataCount = m_MetadataEntries.size();
 	MetadataEntries.reserve(MetadataCount);
 
-	for (auto LookupIt : m_BlobLookup)
+	for (const auto& LookupIt : m_BlobLookup)
 	{
 		const IoHash&	 BlobHash	   = LookupIt.first;
 		const BlobIndex	 ReadBlobIndex = LookupIt.second;
@@ -955,7 +955,7 @@ BuildStore::WriteAccessTimes(const RwLock::ExclusiveLockScope&, const std::files
 		std::vector<AccessTimeRecord> AccessRecords;
 		AccessRecords.reserve(Header.AccessTimeCount);
 
-		for (auto It : m_BlobLookup)
+		for (const auto& It : m_BlobLookup)
 		{
 			const IoHash&	 Key			   = It.first;
 			const BlobIndex	 Index			   = It.second;
@@ -965,7 +965,7 @@ BuildStore::WriteAccessTimes(const RwLock::ExclusiveLockScope&, const std::files
 		}
 		uint64_t RecordsSize = sizeof(AccessTimeRecord) * Header.AccessTimeCount;
 		TempFile.Write(AccessRecords.data(), RecordsSize, Offset);
-		Offset += sizeof(AccessTimesHeader) * Header.AccessTimeCount;
+		Offset += sizeof(AccessTimeRecord) * Header.AccessTimeCount;
 	}
 	if (TempFile.MoveTemporaryIntoPlace(AccessTimesPath, Ec); Ec)
 	{
diff --git a/src/zenstore/cache/cachedisklayer.cpp b/src/zenstore/cache/cachedisklayer.cpp
index b73b3e6fb..d53f9f369 100644
--- a/src/zenstore/cache/cachedisklayer.cpp
+++ b/src/zenstore/cache/cachedisklayer.cpp
@@ -602,7 +602,7 @@ BucketManifestSerializer::ReadSidecarFile(RwLock::ExclusiveLockScope&								  B
 
 	if (FileSize < sizeof(BucketMetaHeader))
 	{
-		ZEN_WARN("Failed to read sidecar file '{}'. Minimum size {} expected, actual size: ",
+		ZEN_WARN("Failed to read sidecar file '{}'. Minimum size {} expected, actual size: {}",
 				 SidecarPath,
 				 sizeof(BucketMetaHeader),
 				 FileSize);
@@ -654,6 +654,7 @@ BucketManifestSerializer::ReadSidecarFile(RwLock::ExclusiveLockScope&								  B
 					 SidecarPath,
 					 sizeof(ManifestData),
 					 CurrentReadOffset);
+			break;
 		}
 		CurrentReadOffset += sizeof(ManifestData);
 
@@ -1011,7 +1012,7 @@ ZenCacheDiskLayer::CacheBucket::WriteIndexSnapshotLocked(uint64_t						  LogPosi
 				{
 					// This is non-critical, it only means that we will replay the events of the log over the snapshot - inefficent but in
 					// the end it will be the same result
-					ZEN_WARN("snapshot failed to clean log file '{}', reason: '{}'", LogPath, IndexPath, Ec.message());
+					ZEN_WARN("snapshot failed to clean log file '{}', reason: '{}'", LogPath, Ec.message());
 				}
 				m_SlogFile.Open(LogPath, CasLogFile::Mode::kWrite);
 			}
@@ -1267,10 +1268,10 @@ ZenCacheDiskLayer::CacheBucket::InitializeIndexFromDisk(RwLock::ExclusiveLockSco
 				{
 					RemoveMemCachedData(IndexLock, Payload);
 					RemoveMetaData(IndexLock, Payload);
+					Location.Flags |= DiskLocation::kTombStone;
+					MissingEntries.push_back(DiskIndexEntry{.Key = It.first, .Location = Location});
 				}
 			}
-			Location.Flags |= DiskLocation::kTombStone;
-			MissingEntries.push_back(DiskIndexEntry{.Key = It.first, .Location = Location});
 		}
 
 		ZEN_ASSERT(!MissingEntries.empty());
@@ -2812,7 +2813,7 @@ ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, c
 					 m_BucketDir,
 					 Ec.message(),
 					 RetriesLeft);
-			Sleep(100 - (3 - RetriesLeft) * 100);  // Total 600 ms
+			Sleep((3 - RetriesLeft) * 100);	 // Total 600 ms
 			Ec.clear();
 			DataFile.MoveTemporaryIntoPlace(FsPath, Ec);
 			RetriesLeft--;
@@ -2866,11 +2867,12 @@ ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, c
 	{
 		EntryIndex = It.value();
 		ZEN_ASSERT_SLOW(EntryIndex < PayloadIndex(m_AccessTimes.size()));
-		BucketPayload& Payload	  = m_Payloads[EntryIndex];
-		uint64_t	   OldSize	  = Payload.Location.Size();
+		BucketPayload& Payload = m_Payloads[EntryIndex];
+		uint64_t	   OldSize = Payload.Location.Size();
+		RemoveMemCachedData(IndexLock, Payload);
+		RemoveMetaData(IndexLock, Payload);
 		Payload					  = BucketPayload{.Location = Loc};
 		m_AccessTimes[EntryIndex] = GcClock::TickCount();
-		RemoveMemCachedData(IndexLock, Payload);
 		m_StandaloneSize.fetch_sub(OldSize, std::memory_order::relaxed);
 	}
 	if ((Value.RawSize != 0 || Value.RawHash != IoHash::Zero) && Value.RawSize <= std::numeric_limits<std::uint32_t>::max())
@@ -3521,7 +3523,7 @@ ZenCacheDiskLayer::CacheBucket::GetReferences(const LoggerRef&	   Logger,
 		}
 		else
 		{
-			ZEN_WARN("Cache record {} payload is malformed. Reason: ", RawHash, ToString(Error));
+			ZEN_WARN("Cache record {} payload is malformed. Reason: {}", RawHash, ToString(Error));
 		}
 		return false;
 	};
@@ -4282,8 +4284,8 @@ ZenCacheDiskLayer::DiscoverBuckets()
 	RwLock SyncLock;
 
 	WorkerThreadPool& Pool = GetLargeWorkerPool(EWorkloadType::Burst);
-	std::atomic<bool> AbortFlag;
-	std::atomic<bool> PauseFlag;
+	std::atomic<bool> AbortFlag{false};
+	std::atomic<bool> PauseFlag{false};
 	ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 	try
 	{
@@ -4454,8 +4456,8 @@ ZenCacheDiskLayer::Flush()
 	}
 	{
 		WorkerThreadPool& Pool = GetMediumWorkerPool(EWorkloadType::Burst);
-		std::atomic<bool> AbortFlag;
-		std::atomic<bool> PauseFlag;
+		std::atomic<bool> AbortFlag{false};
+		std::atomic<bool> PauseFlag{false};
 		ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 		try
 		{
@@ -4496,8 +4498,8 @@ ZenCacheDiskLayer::Scrub(ScrubContext& Ctx)
 
 	RwLock::SharedLockScope _(m_Lock);
 
-	std::atomic<bool> Abort;
-	std::atomic<bool> Pause;
+	std::atomic<bool> Abort{false};
+	std::atomic<bool> Pause{false};
 	ParallelWork	  Work(Abort, Pause, WorkerThreadPool::EMode::DisableBacklog);
 
 	try
diff --git a/src/zenstore/cache/cachepolicy.cpp b/src/zenstore/cache/cachepolicy.cpp
index ce6a14bd9..c1e7dc5b3 100644
--- a/src/zenstore/cache/cachepolicy.cpp
+++ b/src/zenstore/cache/cachepolicy.cpp
@@ -403,13 +403,13 @@ TEST_CASE("cacherecordpolicy")
 			RecordPolicy.Save(Writer);
 			CbObject		  Saved	 = Writer.Save()->AsObject();
 			CacheRecordPolicy Loaded = CacheRecordPolicy::Load(Saved).Get();
-			CHECK(!RecordPolicy.IsUniform());
-			CHECK(RecordPolicy.GetRecordPolicy() == UnionPolicy);
-			CHECK(RecordPolicy.GetBasePolicy() == DefaultPolicy);
-			CHECK(RecordPolicy.GetValuePolicy(PartialOid) == PartialOverlap);
-			CHECK(RecordPolicy.GetValuePolicy(NoOverlapOid) == NoOverlap);
-			CHECK(RecordPolicy.GetValuePolicy(OtherOid) == DefaultValuePolicy);
-			CHECK(RecordPolicy.GetValuePolicies().size() == 2);
+			CHECK(!Loaded.IsUniform());
+			CHECK(Loaded.GetRecordPolicy() == UnionPolicy);
+			CHECK(Loaded.GetBasePolicy() == DefaultPolicy);
+			CHECK(Loaded.GetValuePolicy(PartialOid) == PartialOverlap);
+			CHECK(Loaded.GetValuePolicy(NoOverlapOid) == NoOverlap);
+			CHECK(Loaded.GetValuePolicy(OtherOid) == DefaultValuePolicy);
+			CHECK(Loaded.GetValuePolicies().size() == 2);
 		}
 	}
 
diff --git a/src/zenstore/cache/cacherpc.cpp b/src/zenstore/cache/cacherpc.cpp
index e1fd0a3e6..90c5a5e60 100644
--- a/src/zenstore/cache/cacherpc.cpp
+++ b/src/zenstore/cache/cacherpc.cpp
@@ -866,8 +866,8 @@ CacheRpcHandler::HandleRpcGetCacheRecords(const CacheRequestContext& Context, Cb
 						Request.Complete = false;
 					}
 				}
-				Request.ElapsedTimeUs += Timer.GetElapsedTimeUs();
 			}
+			Request.ElapsedTimeUs += Timer.GetElapsedTimeUs();
 		};
 
 		m_UpstreamCache.GetCacheRecords(*Namespace, UpstreamRequests, std::move(OnCacheRecordGetComplete));
@@ -934,7 +934,7 @@ CacheRpcHandler::HandleRpcGetCacheRecords(const CacheRequestContext& Context, Cb
 							  *Namespace,
 							  Key.Bucket,
 							  Key.Hash,
-							  Request.RecordObject ? ""sv : " (PARTIAL)"sv,
+							  Request.RecordObject ? " (PARTIAL)"sv : ""sv,
 							  Request.Source ? Request.Source->Url : "LOCAL"sv,
 							  NiceLatencyNs(Request.ElapsedTimeUs * 1000));
 					m_CacheStats.MissCount++;
diff --git a/src/zenstore/cache/structuredcachestore.cpp b/src/zenstore/cache/structuredcachestore.cpp
index 18023e2d6..cff0e9a35 100644
--- a/src/zenstore/cache/structuredcachestore.cpp
+++ b/src/zenstore/cache/structuredcachestore.cpp
@@ -686,8 +686,8 @@ ZenCacheStore::Get(const CacheRequestContext& Context,
 		return false;
 	}
 	ZEN_WARN("request for unknown namespace '{}' in ZenCacheStore::Get [{}], bucket '{}', key '{}'",
-			 Context,
 			 Namespace,
+			 Context,
 			 Bucket,
 			 HashKey.ToHexString());
 
@@ -722,8 +722,8 @@ ZenCacheStore::Get(const CacheRequestContext& Context,
 	}
 
 	ZEN_WARN("request for unknown namespace '{}' in ZenCacheStore::Get [{}], bucket '{}', key '{}'",
-			 Context,
 			 Namespace,
+			 Context,
 			 Bucket,
 			 HashKey.ToHexString());
 
@@ -790,8 +790,8 @@ ZenCacheStore::Put(const CacheRequestContext& Context,
 	}
 
 	ZEN_WARN("request for unknown namespace '{}' in ZenCacheStore::Put [{}] bucket '{}', key '{}'",
-			 Context,
 			 Namespace,
+			 Context,
 			 Bucket,
 			 HashKey.ToHexString());
 
@@ -816,7 +816,7 @@ ZenCacheStore::DropNamespace(std::string_view InNamespace)
 {
 	std::function<void()> PostDropOp;
 	{
-		RwLock::SharedLockScope _(m_NamespacesLock);
+		RwLock::ExclusiveLockScope _(m_NamespacesLock);
 		if (auto It = m_Namespaces.find(std::string(InNamespace)); It != m_Namespaces.end())
 		{
 			ZenCacheNamespace& Namespace = *It->second;
diff --git a/src/zenstore/cas.cpp b/src/zenstore/cas.cpp
index f80952322..8855c87d8 100644
--- a/src/zenstore/cas.cpp
+++ b/src/zenstore/cas.cpp
@@ -153,7 +153,10 @@ CasImpl::Initialize(const CidStoreConfiguration& InConfig)
 		}
 		for (std::future<void>& Result : Work)
 		{
-			Result.get();
+			if (Result.valid())
+			{
+				Result.get();
+			}
 		}
 	}
 }
@@ -426,7 +429,7 @@ CasImpl::IterateChunks(std::span<IoHash>												 DecompressedIds,
 			[&](size_t Index, const IoBuffer& Payload) {
 				IoBuffer Chunk(Payload);
 				Chunk.SetContentType(ZenContentType::kCompressedBinary);
-				return AsyncCallback(Index, Payload);
+				return AsyncCallback(Index, Chunk);
 			},
 			OptionalWorkerPool,
 			LargeSizeLimit == 0 ? m_Config.HugeValueThreshold : Min(LargeSizeLimit, m_Config.HugeValueThreshold)))
@@ -439,7 +442,7 @@ CasImpl::IterateChunks(std::span<IoHash>												 DecompressedIds,
 			[&](size_t Index, const IoBuffer& Payload) {
 				IoBuffer Chunk(Payload);
 				Chunk.SetContentType(ZenContentType::kCompressedBinary);
-				return AsyncCallback(Index, Payload);
+				return AsyncCallback(Index, Chunk);
 			},
 			OptionalWorkerPool,
 			LargeSizeLimit == 0 ? m_Config.TinyValueThreshold : Min(LargeSizeLimit, m_Config.TinyValueThreshold)))
@@ -452,7 +455,7 @@ CasImpl::IterateChunks(std::span<IoHash>												 DecompressedIds,
 			[&](size_t Index, const IoBuffer& Payload) {
 				IoBuffer Chunk(Payload);
 				Chunk.SetContentType(ZenContentType::kCompressedBinary);
-				return AsyncCallback(Index, Payload);
+				return AsyncCallback(Index, Chunk);
 			},
 			OptionalWorkerPool))
 	{
diff --git a/src/zenstore/caslog.cpp b/src/zenstore/caslog.cpp
index 492ce9317..44664dac2 100644
--- a/src/zenstore/caslog.cpp
+++ b/src/zenstore/caslog.cpp
@@ -35,7 +35,7 @@ CasLogFile::~CasLogFile()
 }
 
 bool
-CasLogFile::IsValid(std::filesystem::path FileName, size_t RecordSize)
+CasLogFile::IsValid(const std::filesystem::path& FileName, size_t RecordSize)
 {
 	if (!IsFile(FileName))
 	{
@@ -71,7 +71,7 @@ CasLogFile::IsValid(std::filesystem::path FileName, size_t RecordSize)
 }
 
 void
-CasLogFile::Open(std::filesystem::path FileName, size_t RecordSize, Mode Mode)
+CasLogFile::Open(const std::filesystem::path& FileName, size_t RecordSize, Mode Mode)
 {
 	m_RecordSize = RecordSize;
 
@@ -205,7 +205,7 @@ CasLogFile::Replay(std::function<void(const void*)>&& Handler, uint64_t SkipEntr
 
 		m_File.Read(ReadBuffer.data(), BytesToRead, LogBaseOffset + ReadOffset);
 
-		for (int i = 0; i < int(EntriesToRead); ++i)
+		for (size_t i = 0; i < EntriesToRead; ++i)
 		{
 			Handler(ReadBuffer.data() + (i * m_RecordSize));
 		}
diff --git a/src/zenstore/cidstore.cpp b/src/zenstore/cidstore.cpp
index bedf91287..b20d8f565 100644
--- a/src/zenstore/cidstore.cpp
+++ b/src/zenstore/cidstore.cpp
@@ -48,13 +48,13 @@ struct CidStore::Impl
 
 	std::vector<CidStore::InsertResult> AddChunks(std::span<IoBuffer> ChunkDatas, std::span<IoHash> RawHashes, CidStore::InsertMode Mode)
 	{
+		ZEN_ASSERT(ChunkDatas.size() == RawHashes.size());
 		if (ChunkDatas.size() == 1)
 		{
 			std::vector<CidStore::InsertResult> Result(1);
 			Result[0] = AddChunk(ChunkDatas[0], RawHashes[0], Mode);
 			return Result;
 		}
-		ZEN_ASSERT(ChunkDatas.size() == RawHashes.size());
 		std::vector<IoBuffer> Chunks;
 		Chunks.reserve(ChunkDatas.size());
 #if ZEN_BUILD_DEBUG
@@ -81,6 +81,7 @@ struct CidStore::Impl
 			m_CasStore.InsertChunks(Chunks, RawHashes, static_cast<CasStore::InsertMode>(Mode));
 		ZEN_ASSERT(CasResults.size() == ChunkDatas.size());
 		std::vector<CidStore::InsertResult> Result;
+		Result.reserve(CasResults.size());
 		for (const CasStore::InsertResult& CasResult : CasResults)
 		{
 			if (CasResult.New)
diff --git a/src/zenstore/compactcas.cpp b/src/zenstore/compactcas.cpp
index 21411df59..b09892687 100644
--- a/src/zenstore/compactcas.cpp
+++ b/src/zenstore/compactcas.cpp
@@ -153,7 +153,7 @@ CasContainerStrategy::~CasContainerStrategy()
 	}
 	catch (const std::exception& Ex)
 	{
-		ZEN_ERROR("~CasContainerStrategy failed with: ", Ex.what());
+		ZEN_ERROR("~CasContainerStrategy failed with: {}", Ex.what());
 	}
 	m_Gc.RemoveGcReferenceStore(*this);
 	m_Gc.RemoveGcStorage(this);
@@ -440,9 +440,9 @@ CasContainerStrategy::IterateChunks(std::span<const IoHash>											  ChunkHas
 		return true;
 	}
 
-	std::atomic<bool> AbortFlag;
+	std::atomic<bool> AbortFlag{false};
 	{
-		std::atomic<bool> PauseFlag;
+		std::atomic<bool> PauseFlag{false};
 		ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 		try
 		{
@@ -559,8 +559,8 @@ CasContainerStrategy::ScrubStorage(ScrubContext& Ctx)
 	std::vector<BlockStoreLocation> ChunkLocations;
 	std::vector<IoHash>				ChunkIndexToChunkHash;
 
-	std::atomic<bool> Abort;
-	std::atomic<bool> Pause;
+	std::atomic<bool> Abort{false};
+	std::atomic<bool> Pause{false};
 	ParallelWork	  Work(Abort, Pause, WorkerThreadPool::EMode::DisableBacklog);
 
 	try
@@ -1007,7 +1007,7 @@ CasContainerStrategy::CompactIndex(RwLock::ExclusiveLockScope&)
 	std::vector<BlockStoreDiskLocation> Locations;
 	Locations.reserve(EntryCount);
 	LocationMap.reserve(EntryCount);
-	for (auto It : m_LocationMap)
+	for (const auto& It : m_LocationMap)
 	{
 		size_t EntryIndex = Locations.size();
 		Locations.push_back(m_Locations[It.second]);
@@ -1106,7 +1106,7 @@ CasContainerStrategy::MakeIndexSnapshot(bool ResetLog)
 				{
 					// This is non-critical, it only means that we will replay the events of the log over the snapshot - inefficent but in
 					// the end it will be the same result
-					ZEN_WARN("Snapshot failed to clean log file '{}', reason: '{}'", LogPath, IndexPath, Ec.message());
+					ZEN_WARN("Snapshot failed to clean log file '{}', reason: '{}'", LogPath, Ec.message());
 				}
 				m_CasLog.Open(LogPath, CasLogFile::Mode::kWrite);
 			}
@@ -1136,7 +1136,7 @@ CasContainerStrategy::ReadIndexFile(const std::filesystem::path& IndexPath, uint
 	uint64_t Size = ObjectIndexFile.FileSize();
 	if (Size >= sizeof(CasDiskIndexHeader))
 	{
-		uint64_t		   ExpectedEntryCount = (Size - sizeof(sizeof(CasDiskIndexHeader))) / sizeof(CasDiskIndexEntry);
+		uint64_t		   ExpectedEntryCount = (Size - sizeof(CasDiskIndexHeader)) / sizeof(CasDiskIndexEntry);
 		CasDiskIndexHeader Header;
 		ObjectIndexFile.Read(&Header, sizeof(Header), 0);
 		if ((Header.Magic == CasDiskIndexHeader::ExpectedMagic) && (Header.Version == CasDiskIndexHeader::CurrentVersion) &&
diff --git a/src/zenstore/filecas.cpp b/src/zenstore/filecas.cpp
index 295451818..0088afe6e 100644
--- a/src/zenstore/filecas.cpp
+++ b/src/zenstore/filecas.cpp
@@ -383,7 +383,7 @@ FileCasStrategy::InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash, CasStore::
 		HRESULT WriteRes = PayloadFile.Write(Cursor, Size);
 		if (FAILED(WriteRes))
 		{
-			ThrowSystemException(hRes, fmt::format("failed to write {} bytes to shard file '{}'", ChunkSize, ChunkPath));
+			ThrowSystemException(WriteRes, fmt::format("failed to write {} bytes to shard file '{}'", ChunkSize, ChunkPath));
 		}
 	};
 #else
@@ -669,8 +669,8 @@ FileCasStrategy::IterateChunks(std::span<IoHash>												 ChunkHashes,
 			return true;
 		};
 
-		std::atomic<bool> AbortFlag;
-		std::atomic<bool> PauseFlag;
+		std::atomic<bool> AbortFlag{false};
+		std::atomic<bool> PauseFlag{false};
 		ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 		try
 		{
@@ -823,8 +823,8 @@ FileCasStrategy::ScrubStorage(ScrubContext& Ctx)
 
 	ZEN_INFO("discovered {} files @ '{}' ({} not in index), scrubbing", m_Index.size(), m_RootDirectory, DiscoveredFilesNotInIndex);
 
-	std::atomic<bool> Abort;
-	std::atomic<bool> Pause;
+	std::atomic<bool> Abort{false};
+	std::atomic<bool> Pause{false};
 	ParallelWork	  Work(Abort, Pause, WorkerThreadPool::EMode::DisableBacklog);
 
 	try
@@ -1016,7 +1016,7 @@ FileCasStrategy::MakeIndexSnapshot(bool ResetLog)
 				{
 					// This is non-critical, it only means that we will replay the events of the log over the snapshot - inefficent but in
 					// the end it will be the same result
-					ZEN_WARN("Snapshot failed to clean log file '{}', reason: '{}'", LogPath, IndexPath, Ec.message());
+					ZEN_WARN("Snapshot failed to clean log file '{}', reason: '{}'", LogPath, Ec.message());
 				}
 				m_CasLog.Open(LogPath, CasLogFile::Mode::kWrite);
 			}
@@ -1052,7 +1052,7 @@ FileCasStrategy::ReadIndexFile(const std::filesystem::path& IndexPath, uint32_t&
 		uint64_t Size = ObjectIndexFile.FileSize();
 		if (Size >= sizeof(FileCasIndexHeader))
 		{
-			uint64_t		   ExpectedEntryCount = (Size - sizeof(sizeof(FileCasIndexHeader))) / sizeof(FileCasIndexEntry);
+			uint64_t		   ExpectedEntryCount = (Size - sizeof(FileCasIndexHeader)) / sizeof(FileCasIndexEntry);
 			FileCasIndexHeader Header;
 			ObjectIndexFile.Read(&Header, sizeof(Header), 0);
 			if ((Header.Magic == FileCasIndexHeader::ExpectedMagic) && (Header.Version == FileCasIndexHeader::CurrentVersion) &&
diff --git a/src/zenstore/filecas.h b/src/zenstore/filecas.h
index e93356927..41756b65f 100644
--- a/src/zenstore/filecas.h
+++ b/src/zenstore/filecas.h
@@ -74,7 +74,7 @@ private:
 	{
 		static const uint32_t kTombStone = 0x0000'0001;
 
-		bool IsFlagSet(const uint32_t Flag) const { return (Flags & kTombStone) == Flag; }
+		bool IsFlagSet(const uint32_t Flag) const { return (Flags & Flag) == Flag; }
 
 		IoHash	 Key;
 		uint32_t Flags = 0;
diff --git a/src/zenstore/include/zenstore/buildstore/buildstore.h b/src/zenstore/include/zenstore/buildstore/buildstore.h
index bfc83ba0d..ea2ef7f89 100644
--- a/src/zenstore/include/zenstore/buildstore/buildstore.h
+++ b/src/zenstore/include/zenstore/buildstore/buildstore.h
@@ -223,7 +223,7 @@ private:
 	uint64_t					   m_MetaLogFlushPosition = 0;
 
 	std::unique_ptr<std::vector<IoHash>> m_TrackedBlobKeys;
-	std::atomic<uint64_t>				 m_LastAccessTimeUpdateCount;
+	std::atomic<uint64_t>				 m_LastAccessTimeUpdateCount{0};
 
 	friend class BuildStoreGcReferenceChecker;
 	friend class BuildStoreGcReferencePruner;
diff --git a/src/zenstore/include/zenstore/cache/cachedisklayer.h b/src/zenstore/include/zenstore/cache/cachedisklayer.h
index 3d684587d..393e289ac 100644
--- a/src/zenstore/include/zenstore/cache/cachedisklayer.h
+++ b/src/zenstore/include/zenstore/cache/cachedisklayer.h
@@ -153,14 +153,14 @@ public:
 
 	struct BucketStats
 	{
-		uint64_t					  DiskSize;
-		uint64_t					  MemorySize;
-		uint64_t					  DiskHitCount;
-		uint64_t					  DiskMissCount;
-		uint64_t					  DiskWriteCount;
-		uint64_t					  MemoryHitCount;
-		uint64_t					  MemoryMissCount;
-		uint64_t					  MemoryWriteCount;
+		uint64_t					  DiskSize		   = 0;
+		uint64_t					  MemorySize	   = 0;
+		uint64_t					  DiskHitCount	   = 0;
+		uint64_t					  DiskMissCount	   = 0;
+		uint64_t					  DiskWriteCount   = 0;
+		uint64_t					  MemoryHitCount   = 0;
+		uint64_t					  MemoryMissCount  = 0;
+		uint64_t					  MemoryWriteCount = 0;
 		metrics::RequestStatsSnapshot PutOps;
 		metrics::RequestStatsSnapshot GetOps;
 	};
@@ -174,8 +174,8 @@ public:
 	struct DiskStats
 	{
 		std::vector<NamedBucketStats> BucketStats;
-		uint64_t					  DiskSize;
-		uint64_t					  MemorySize;
+		uint64_t					  DiskSize	 = 0;
+		uint64_t					  MemorySize = 0;
 	};
 
 	struct PutResult
@@ -395,12 +395,12 @@ public:
 		TCasLogFile<DiskIndexEntry> m_SlogFile;
 		uint64_t					m_LogFlushPosition = 0;
 
-		std::atomic<uint64_t> m_DiskHitCount;
-		std::atomic<uint64_t> m_DiskMissCount;
-		std::atomic<uint64_t> m_DiskWriteCount;
-		std::atomic<uint64_t> m_MemoryHitCount;
-		std::atomic<uint64_t> m_MemoryMissCount;
-		std::atomic<uint64_t> m_MemoryWriteCount;
+		std::atomic<uint64_t> m_DiskHitCount{0};
+		std::atomic<uint64_t> m_DiskMissCount{0};
+		std::atomic<uint64_t> m_DiskWriteCount{0};
+		std::atomic<uint64_t> m_MemoryHitCount{0};
+		std::atomic<uint64_t> m_MemoryMissCount{0};
+		std::atomic<uint64_t> m_MemoryWriteCount{0};
 		metrics::RequestStats m_PutOps;
 		metrics::RequestStats m_GetOps;
 
@@ -540,7 +540,7 @@ private:
 	Configuration							  m_Configuration;
 	std::atomic_uint64_t					  m_TotalMemCachedSize{};
 	std::atomic_bool						  m_IsMemCacheTrimming = false;
-	std::atomic<GcClock::Tick>				  m_NextAllowedTrimTick;
+	std::atomic<GcClock::Tick>				  m_NextAllowedTrimTick{};
 	mutable RwLock							  m_Lock;
 	BucketMap_t								  m_Buckets;
 	std::vector<std::unique_ptr<CacheBucket>> m_DroppedBuckets;
diff --git a/src/zenstore/include/zenstore/cache/cacheshared.h b/src/zenstore/include/zenstore/cache/cacheshared.h
index 791720589..8e9cd7fd7 100644
--- a/src/zenstore/include/zenstore/cache/cacheshared.h
+++ b/src/zenstore/include/zenstore/cache/cacheshared.h
@@ -40,12 +40,12 @@ struct CacheValueDetails
 {
 	struct ValueDetails
 	{
-		uint64_t			Size;
-		uint64_t			RawSize;
+		uint64_t			Size	= 0;
+		uint64_t			RawSize = 0;
 		IoHash				RawHash;
 		GcClock::Tick		LastAccess{};
 		std::vector<IoHash> Attachments;
-		ZenContentType		ContentType;
+		ZenContentType		ContentType = ZenContentType::kBinary;
 	};
 
 	struct BucketDetails
diff --git a/src/zenstore/include/zenstore/cache/structuredcachestore.h b/src/zenstore/include/zenstore/cache/structuredcachestore.h
index 5a0a8b069..3722a0d31 100644
--- a/src/zenstore/include/zenstore/cache/structuredcachestore.h
+++ b/src/zenstore/include/zenstore/cache/structuredcachestore.h
@@ -70,9 +70,9 @@ public:
 
 	struct NamespaceStats
 	{
-		uint64_t					  HitCount;
-		uint64_t					  MissCount;
-		uint64_t					  WriteCount;
+		uint64_t					  HitCount	 = 0;
+		uint64_t					  MissCount	 = 0;
+		uint64_t					  WriteCount = 0;
 		metrics::RequestStatsSnapshot PutOps;
 		metrics::RequestStatsSnapshot GetOps;
 		ZenCacheDiskLayer::DiskStats  DiskStats;
@@ -342,11 +342,11 @@ private:
 	void					   LogWorker();
 	RwLock					   m_LogQueueLock;
 	std::vector<AccessLogItem> m_LogQueue;
-	std::atomic_bool		   m_ExitLogging;
+	std::atomic_bool		   m_ExitLogging{false};
 	Event					   m_LogEvent;
 	std::thread				   m_AsyncLoggingThread;
-	std::atomic_bool		   m_WriteLogEnabled;
-	std::atomic_bool		   m_AccessLogEnabled;
+	std::atomic_bool		   m_WriteLogEnabled{false};
+	std::atomic_bool		   m_AccessLogEnabled{false};
 
 	friend class CacheStoreReferenceChecker;
 };
diff --git a/src/zenstore/include/zenstore/caslog.h b/src/zenstore/include/zenstore/caslog.h
index f3dd32fb1..7967d9dae 100644
--- a/src/zenstore/include/zenstore/caslog.h
+++ b/src/zenstore/include/zenstore/caslog.h
@@ -20,8 +20,8 @@ public:
 		kTruncate
 	};
 
-	static bool IsValid(std::filesystem::path FileName, size_t RecordSize);
-	void		Open(std::filesystem::path FileName, size_t RecordSize, Mode Mode);
+	static bool IsValid(const std::filesystem::path& FileName, size_t RecordSize);
+	void		Open(const std::filesystem::path& FileName, size_t RecordSize, Mode Mode);
 	void		Append(const void* DataPointer, uint64_t DataSize);
 	void		Replay(std::function<void(const void*)>&& Handler, uint64_t SkipEntryCount);
 	void		Flush();
@@ -48,7 +48,7 @@ private:
 	static_assert(sizeof(FileHeader) == 64);
 
 private:
-	void Open(std::filesystem::path FileName, size_t RecordSize, BasicFile::Mode Mode);
+	void Open(const std::filesystem::path& FileName, size_t RecordSize, BasicFile::Mode Mode);
 
 	BasicFile			  m_File;
 	FileHeader			  m_Header;
@@ -60,8 +60,8 @@ template<typename T>
 class TCasLogFile : public CasLogFile
 {
 public:
-	static bool IsValid(std::filesystem::path FileName) { return CasLogFile::IsValid(FileName, sizeof(T)); }
-	void		Open(std::filesystem::path FileName, Mode Mode) { CasLogFile::Open(FileName, sizeof(T), Mode); }
+	static bool IsValid(const std::filesystem::path& FileName) { return CasLogFile::IsValid(FileName, sizeof(T)); }
+	void		Open(const std::filesystem::path& FileName, Mode Mode) { CasLogFile::Open(FileName, sizeof(T), Mode); }
 
 	// This should be called before the Replay() is called to do some basic sanity checking
 	bool Initialize() { return true; }
diff --git a/src/zenstore/include/zenstore/gc.h b/src/zenstore/include/zenstore/gc.h
index 794f50d96..67cf852f9 100644
--- a/src/zenstore/include/zenstore/gc.h
+++ b/src/zenstore/include/zenstore/gc.h
@@ -443,8 +443,8 @@ struct GcSchedulerState
 	uint64_t			 DiskFree			  = 0;
 	GcClock::TimePoint	 LastFullGcTime{};
 	GcClock::TimePoint	 LastLightweightGcTime{};
-	std::chrono::seconds RemainingTimeUntilLightweightGc;
-	std::chrono::seconds RemainingTimeUntilFullGc;
+	std::chrono::seconds RemainingTimeUntilLightweightGc{};
+	std::chrono::seconds RemainingTimeUntilFullGc{};
 	uint64_t			 RemainingSpaceUntilFullGC = 0;
 
 	std::chrono::milliseconds LastFullGcDuration{};
@@ -562,7 +562,7 @@ private:
 	GcClock::TimePoint m_LastGcExpireTime{};
 	IoHash			   m_LastFullAttachmentRangeMin = IoHash::Zero;
 	IoHash			   m_LastFullAttachmentRangeMax = IoHash::Max;
-	uint8_t			   m_AttachmentPassIndex;
+	uint8_t			   m_AttachmentPassIndex		= 0;
 
 	std::chrono::milliseconds m_LastFullGcDuration{};
 	GcStorageSize			  m_LastFullGCDiff;
diff --git a/src/zenstore/include/zenstore/projectstore.h b/src/zenstore/include/zenstore/projectstore.h
index 33ef996db..6f49cd024 100644
--- a/src/zenstore/include/zenstore/projectstore.h
+++ b/src/zenstore/include/zenstore/projectstore.h
@@ -67,8 +67,8 @@ public:
 
 	struct OplogEntryAddress
 	{
-		uint32_t Offset;  // note: Multiple of m_OpsAlign!
-		uint32_t Size;
+		uint32_t Offset = 0;  // note: Multiple of m_OpsAlign!
+		uint32_t Size	= 0;
 	};
 
 	struct OplogEntry
@@ -80,11 +80,7 @@ public:
 		uint32_t		  Reserved;
 
 		inline bool IsTombstone() const { return OpCoreAddress.Offset == 0 && OpCoreAddress.Size == 0 && OpLsn.Number; }
-		inline void MakeTombstone()
-		{
-			OpLsn				 = {};
-			OpCoreAddress.Offset = OpCoreAddress.Size = OpCoreHash = Reserved = 0;
-		}
+		inline void MakeTombstone() { OpCoreAddress.Offset = OpCoreAddress.Size = OpCoreHash = Reserved = 0; }
 	};
 
 	static_assert(IsPow2(sizeof(OplogEntry)));
diff --git a/src/zenstore/projectstore.cpp b/src/zenstore/projectstore.cpp
index 217336eec..3f705d12c 100644
--- a/src/zenstore/projectstore.cpp
+++ b/src/zenstore/projectstore.cpp
@@ -1488,7 +1488,7 @@ ProjectStore::Oplog::Read()
 	else
 	{
 		std::vector<OplogEntry> OpLogEntries;
-		uint64_t				InvalidEntries;
+		uint64_t				InvalidEntries = 0;
 		m_Storage->ReadOplogEntriesFromLog(OpLogEntries, InvalidEntries, m_LogFlushPosition);
 		for (const OplogEntry& OpEntry : OpLogEntries)
 		{
@@ -1750,8 +1750,8 @@ ProjectStore::Oplog::Validate(const std::filesystem::path& ProjectRootDir,
 		}
 	};
 
-	std::atomic<bool> AbortFlag;
-	std::atomic<bool> PauseFlag;
+	std::atomic<bool> AbortFlag{false};
+	std::atomic<bool> PauseFlag{false};
 	ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 	try
 	{
@@ -2373,7 +2373,7 @@ ProjectStore::Oplog::IterateChunks(const std::filesystem::path&														  P
 			else if (auto MetaIt = m_MetaMap.find(ChunkId); MetaIt != m_MetaMap.end())
 			{
 				CidChunkIndexes.push_back(ChunkIndex);
-				CidChunkHashes.push_back(ChunkIt->second);
+				CidChunkHashes.push_back(MetaIt->second);
 			}
 			else if (auto FileIt = m_FileMap.find(ChunkId); FileIt != m_FileMap.end())
 			{
@@ -2384,8 +2384,8 @@ ProjectStore::Oplog::IterateChunks(const std::filesystem::path&														  P
 	}
 	if (OptionalWorkerPool)
 	{
-		std::atomic<bool> AbortFlag;
-		std::atomic<bool> PauseFlag;
+		std::atomic<bool> AbortFlag{false};
+		std::atomic<bool> PauseFlag{false};
 		ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 		try
 		{
@@ -3817,7 +3817,7 @@ ProjectStore::Project::OpenOplog(std::string_view OplogId, bool AllowCompact, bo
 					std::filesystem::path DeletePath;
 					if (!RemoveOplog(OplogId, DeletePath))
 					{
-						ZEN_WARN("Failed to clean up deleted oplog {}/{}", Identifier, OplogId, OplogBasePath);
+						ZEN_WARN("Failed to clean up deleted oplog {}/{} at '{}'", Identifier, OplogId, OplogBasePath);
 					}
 
 					ReOpen = true;
@@ -4053,8 +4053,8 @@ ProjectStore::Project::Scrub(ScrubContext& Ctx)
 
 	RwLock::SharedLockScope _(m_ProjectLock);
 
-	std::atomic<bool> Abort;
-	std::atomic<bool> Pause;
+	std::atomic<bool> Abort{false};
+	std::atomic<bool> Pause{false};
 	ParallelWork	  Work(Abort, Pause, WorkerThreadPool::EMode::DisableBacklog);
 
 	try
@@ -4433,8 +4433,8 @@ ProjectStore::Flush()
 	}
 
 	WorkerThreadPool& WorkerPool = GetSmallWorkerPool(EWorkloadType::Burst);
-	std::atomic<bool> AbortFlag;
-	std::atomic<bool> PauseFlag;
+	std::atomic<bool> AbortFlag{false};
+	std::atomic<bool> PauseFlag{false};
 	ParallelWork	  Work(AbortFlag, PauseFlag, WorkerThreadPool::EMode::DisableBacklog);
 	try
 	{
@@ -4974,7 +4974,7 @@ ProjectStore::GetProjectChunkInfos(LoggerRef InLog, Project& Project, Oplog& Opl
 							}
 							if (WantsRawSizeField)
 							{
-								ZEN_ASSERT_SLOW(Sizes[Index] == (uint64_t)-1);
+								ZEN_ASSERT_SLOW(RawSizes[Index] == (uint64_t)-1);
 								RawSizes[Index] = Payload.GetSize();
 							}
 						}
@@ -5762,7 +5762,7 @@ public:
 			}
 		}
 
-		for (auto ProjectIt : m_ProjectStore.m_Projects)
+		for (const auto& ProjectIt : m_ProjectStore.m_Projects)
 		{
 			Ref<ProjectStore::Project> Project		   = ProjectIt.second;
 			std::vector<std::string>   OplogsToCompact = Project->GetOplogsToCompact();
diff --git a/src/zenstore/workspaces.cpp b/src/zenstore/workspaces.cpp
index df3cd31ef..ad21bbc68 100644
--- a/src/zenstore/workspaces.cpp
+++ b/src/zenstore/workspaces.cpp
@@ -383,7 +383,7 @@ Workspace::GetShares() const
 {
 	std::vector<Ref<WorkspaceShare>> Shares;
 	Shares.reserve(m_Shares.size());
-	for (auto It : m_Shares)
+	for (const auto& It : m_Shares)
 	{
 		Shares.push_back(It.second);
 	}
@@ -435,7 +435,7 @@ Workspaces::RefreshWorkspaceShares(const Oid& WorkspaceId)
 		Workspace = FindWorkspace(Lock, WorkspaceId);
 		if (Workspace)
 		{
-			for (auto Share : Workspace->GetShares())
+			for (const auto& Share : Workspace->GetShares())
 			{
 				DeletedShares.insert(Share->GetConfig().Id);
 			}
@@ -482,6 +482,12 @@ Workspaces::RefreshWorkspaceShares(const Oid& WorkspaceId)
 										m_ShareAliases.erase(Share->GetConfig().Alias);
 									}
 									Workspace->SetShare(Configuration.Id, std::move(NewShare));
+									if (!Configuration.Alias.empty())
+									{
+										m_ShareAliases.insert_or_assign(
+											Configuration.Alias,
+											ShareAlias{.WorkspaceId = WorkspaceId, .ShareId = Configuration.Id});
+									}
 								}
 							}
 							else
@@ -602,7 +608,7 @@ Workspaces::GetWorkspaceShareChunks(const Oid&							WorkspaceId,
 				{
 					RequestedOffset = Size;
 				}
-				if ((RequestedOffset + RequestedSize) > Size)
+				if (RequestedSize > Size - RequestedOffset)
 				{
 					RequestedSize = Size - RequestedOffset;
 				}
@@ -649,7 +655,7 @@ Workspaces::GetWorkspaces() const
 {
 	std::vector<Oid>		Workspaces;
 	RwLock::SharedLockScope Lock(m_Lock);
-	for (auto It : m_Workspaces)
+	for (const auto& It : m_Workspaces)
 	{
 		Workspaces.push_back(It.first);
 	}
@@ -679,7 +685,7 @@ Workspaces::GetWorkspaceShares(const Oid& WorkspaceId) const
 	if (Workspace)
 	{
 		std::vector<Oid> Shares;
-		for (auto Share : Workspace->GetShares())
+		for (const auto& Share : Workspace->GetShares())
 		{
 			Shares.push_back(Share->GetConfig().Id);
 		}