Merge branch 'main' into de/zen-service-command

22 files changed, 2113 insertions, 563 deletions

diff --git a/src/zencore/basicfile.cpp b/src/zencore/basicfile.cpp
index 95876cff4..6989da67e 100644
--- a/src/zencore/basicfile.cpp
+++ b/src/zencore/basicfile.cpp
@@ -181,58 +181,18 @@ BasicFile::ReadRange(uint64_t FileOffset, uint64_t ByteCount)
 void
 BasicFile::Read(void* Data, uint64_t BytesToRead, uint64_t FileOffset)
 {
-	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;
-
-	while (BytesToRead)
+	const uint64_t	MaxChunkSize = 2u * 1024 * 1024 * 1024;
+	std::error_code Ec;
+	ReadFile(m_FileHandle, Data, BytesToRead, FileOffset, MaxChunkSize, Ec);
+	if (Ec)
 	{
-		const uint64_t NumberOfBytesToRead = Min(BytesToRead, MaxChunkSize);
-		int32_t		   Error			   = 0;
-		size_t		   BytesRead		   = 0;
-
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
-
-		DWORD dwNumberOfBytesRead = 0;
-		BOOL  Success			  = ::ReadFile(m_FileHandle, Data, DWORD(NumberOfBytesToRead), &dwNumberOfBytesRead, &Ovl);
-		if (Success)
-		{
-			BytesRead = size_t(dwNumberOfBytesRead);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int		Fd		   = int(uintptr_t(m_FileHandle));
-		ssize_t ReadResult = pread(Fd, Data, NumberOfBytesToRead, FileOffset);
-		if (ReadResult != -1)
-		{
-			BytesRead = size_t(ReadResult);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#endif
-
-		if (Error || (BytesRead != NumberOfBytesToRead))
-		{
-			std::error_code DummyEc;
-			throw std::system_error(std::error_code(Error, std::system_category()),
-									fmt::format("ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
-												FileOffset,
-												NumberOfBytesToRead,
-												PathFromHandle(m_FileHandle, DummyEc),
-												FileSizeFromHandle(m_FileHandle)));
-		}
-
-		BytesToRead -= NumberOfBytesToRead;
-		FileOffset += NumberOfBytesToRead;
-		Data = reinterpret_cast<uint8_t*>(Data) + NumberOfBytesToRead;
+		std::error_code DummyEc;
+		throw std::system_error(Ec,
+								fmt::format("BasicFile::Read: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
+											FileOffset,
+											BytesToRead,
+											PathFromHandle(m_FileHandle, DummyEc),
+											FileSizeFromHandle(m_FileHandle)));
 	}
 }
 
@@ -323,43 +283,9 @@ BasicFile::Write(MemoryView Data, uint64_t FileOffset, std::error_code& Ec)
 void
 BasicFile::Write(const void* Data, uint64_t Size, uint64_t FileOffset, std::error_code& Ec)
 {
-	ZEN_ASSERT(m_FileHandle != nullptr);
+	const uint64_t MaxChunkSize = 2u * 1024 * 1024;
 
-	Ec.clear();
-
-	const uint64_t MaxChunkSize = 2u * 1024 * 1024 * 1024;
-
-	while (Size)
-	{
-		const uint64_t NumberOfBytesToWrite = Min(Size, MaxChunkSize);
-
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
-
-		DWORD dwNumberOfBytesWritten = 0;
-
-		BOOL Success = ::WriteFile(m_FileHandle, Data, DWORD(NumberOfBytesToWrite), &dwNumberOfBytesWritten, &Ovl);
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int	 Fd			  = int(uintptr_t(m_FileHandle));
-		int	 BytesWritten = pwrite(Fd, Data, NumberOfBytesToWrite, FileOffset);
-		bool Success	  = (BytesWritten > 0);
-#endif
-
-		if (!Success)
-		{
-			Ec = MakeErrorCodeFromLastError();
-
-			return;
-		}
-
-		Size -= NumberOfBytesToWrite;
-		FileOffset += NumberOfBytesToWrite;
-		Data = reinterpret_cast<const uint8_t*>(Data) + NumberOfBytesToWrite;
-	}
+	WriteFile(m_FileHandle, Data, Size, FileOffset, MaxChunkSize, Ec);
 }
 
 void
@@ -405,59 +331,20 @@ BasicFile::Flush()
 uint64_t
 BasicFile::FileSize() const
 {
-#if ZEN_PLATFORM_WINDOWS
-	ULARGE_INTEGER liFileSize;
-	liFileSize.LowPart = ::GetFileSize(m_FileHandle, &liFileSize.HighPart);
-	if (liFileSize.LowPart == INVALID_FILE_SIZE)
-	{
-		int Error = zen::GetLastError();
-		if (Error)
-		{
-			std::error_code Dummy;
-			ThrowSystemError(Error, fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
-		}
-	}
-	return uint64_t(liFileSize.QuadPart);
-#else
-	int Fd = int(uintptr_t(m_FileHandle));
-	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
-	struct stat Stat;
-	if (fstat(Fd, &Stat) == -1)
+	std::error_code Ec;
+	uint64_t		FileSize = FileSizeFromHandle(m_FileHandle, Ec);
+	if (Ec)
 	{
 		std::error_code Dummy;
-		ThrowSystemError(GetLastError(), fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
+		ThrowSystemError(Ec.value(), fmt::format("Failed to get file size from file '{}'", PathFromHandle(m_FileHandle, Dummy)));
 	}
-	return uint64_t(Stat.st_size);
-#endif
+	return FileSize;
 }
 
 uint64_t
 BasicFile::FileSize(std::error_code& Ec) const
 {
-#if ZEN_PLATFORM_WINDOWS
-	ULARGE_INTEGER liFileSize;
-	liFileSize.LowPart = ::GetFileSize(m_FileHandle, &liFileSize.HighPart);
-	if (liFileSize.LowPart == INVALID_FILE_SIZE)
-	{
-		int Error = zen::GetLastError();
-		if (Error)
-		{
-			Ec = MakeErrorCode(Error);
-			return 0;
-		}
-	}
-	return uint64_t(liFileSize.QuadPart);
-#else
-	int Fd = int(uintptr_t(m_FileHandle));
-	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
-	struct stat Stat;
-	if (fstat(Fd, &Stat) == -1)
-	{
-		Ec = MakeErrorCodeFromLastError();
-		return 0;
-	}
-	return uint64_t(Stat.st_size);
-#endif
+	return FileSizeFromHandle(m_FileHandle, Ec);
 }
 
 void
@@ -590,7 +477,7 @@ TemporaryFile::MoveTemporaryIntoPlace(std::filesystem::path FinalFileName, std::
 	// deleting the temporary file
 	BasicFile::Close();
 
-	std::filesystem::rename(m_TempPath, FinalFileName, Ec);
+	RenameFile(m_TempPath, FinalFileName, Ec);
 
 	if (Ec)
 	{
@@ -792,10 +679,45 @@ BasicFileWriter::~BasicFileWriter()
 }
 
 void
+BasicFileWriter::AddPadding(uint64_t Padding)
+{
+	while (Padding)
+	{
+		const uint64_t BufferOffset			   = m_BufferEnd - m_BufferStart;
+		const uint64_t RemainingBufferCapacity = m_BufferSize - BufferOffset;
+		const uint64_t BlockPadBytes		   = Min(RemainingBufferCapacity, Padding);
+
+		memset(m_Buffer + BufferOffset, 0, BlockPadBytes);
+		m_BufferEnd += BlockPadBytes;
+		Padding -= BlockPadBytes;
+
+		if ((BufferOffset + BlockPadBytes) == m_BufferSize)
+		{
+			Flush();
+		}
+	}
+}
+
+uint64_t
+BasicFileWriter::AlignTo(uint64_t Alignment)
+{
+	uint64_t AlignedPos = RoundUp(m_BufferEnd, Alignment);
+	uint64_t Padding	= AlignedPos - m_BufferEnd;
+	AddPadding(Padding);
+	return AlignedPos;
+}
+
+void
 BasicFileWriter::Write(const void* Data, uint64_t Size, uint64_t FileOffset)
 {
 	if (m_Buffer == nullptr || (Size >= m_BufferSize))
 	{
+		if (FileOffset == m_BufferEnd)
+		{
+			Flush();
+			m_BufferStart = m_BufferEnd = FileOffset + Size;
+		}
+
 		m_Base.Write(Data, Size, FileOffset);
 		return;
 	}
@@ -872,7 +794,7 @@ WriteToTempFile(CompositeBuffer&& Buffer, const std::filesystem::path& Path)
 	{
 		uint64_t			  Offset		= 0;
 		static const uint64_t BufferingSize = 256u * 1024u;
-		//		BasicFileWriter		  BufferedOutput(BlockFile, BufferingSize / 2);
+		BasicFileWriter		  BufferedOutput(Temp, Min(BufferingSize, BufferSize));
 		for (const SharedBuffer& Segment : Buffer.GetSegments())
 		{
 			size_t SegmentSize = Segment.GetSize();
@@ -884,14 +806,14 @@ WriteToTempFile(CompositeBuffer&& Buffer, const std::filesystem::path& Path)
 						 FileRef.FileChunkOffset,
 						 FileRef.FileChunkSize,
 						 BufferingSize,
-						 [&Temp, &Offset](const void* Data, size_t Size) {
-							 Temp.Write(Data, Size, Offset);
+						 [&BufferedOutput, &Offset](const void* Data, size_t Size) {
+							 BufferedOutput.Write(Data, Size, Offset);
 							 Offset += Size;
 						 });
 			}
 			else
 			{
-				Temp.Write(Segment.GetData(), SegmentSize, Offset);
+				BufferedOutput.Write(Segment.GetData(), SegmentSize, Offset);
 				Offset += SegmentSize;
 			}
 		}
@@ -978,9 +900,9 @@ TEST_CASE("TemporaryFile")
 			TmpFile.CreateTemporary(std::filesystem::current_path(), Ec);
 			CHECK(!Ec);
 			Path = TmpFile.GetPath();
-			CHECK(std::filesystem::exists(Path));
+			CHECK(IsFile(Path));
 		}
-		CHECK(std::filesystem::exists(Path) == false);
+		CHECK(IsFile(Path) == false);
 	}
 
 	SUBCASE("MoveIntoPlace")
@@ -991,11 +913,11 @@ TEST_CASE("TemporaryFile")
 		CHECK(!Ec);
 		std::filesystem::path TempPath	= TmpFile.GetPath();
 		std::filesystem::path FinalPath = std::filesystem::current_path() / "final";
-		CHECK(std::filesystem::exists(TempPath));
+		CHECK(IsFile(TempPath));
 		TmpFile.MoveTemporaryIntoPlace(FinalPath, Ec);
 		CHECK(!Ec);
-		CHECK(std::filesystem::exists(TempPath) == false);
-		CHECK(std::filesystem::exists(FinalPath));
+		CHECK(IsFile(TempPath) == false);
+		CHECK(IsFile(FinalPath));
 	}
 }
 
diff --git a/src/zencore/blake3.cpp b/src/zencore/blake3.cpp
index 4a77aa49a..054f0d3a0 100644
--- a/src/zencore/blake3.cpp
+++ b/src/zencore/blake3.cpp
@@ -151,6 +151,28 @@ BLAKE3Stream::Append(const void* data, size_t byteCount)
 	return *this;
 }
 
+BLAKE3Stream&
+BLAKE3Stream::Append(const IoBuffer& Buffer)
+{
+	blake3_hasher* b3h = reinterpret_cast<blake3_hasher*>(m_HashState);
+
+	size_t				  BufferSize	= Buffer.GetSize();
+	static const uint64_t BufferingSize = 256u * 1024u;
+	IoBufferFileReference FileRef;
+	if (BufferSize >= (BufferingSize + BufferingSize / 2) && Buffer.GetFileReference(FileRef))
+	{
+		ScanFile(FileRef.FileHandle, FileRef.FileChunkOffset, FileRef.FileChunkSize, BufferingSize, [&b3h](const void* Data, size_t Size) {
+			blake3_hasher_update(b3h, Data, Size);
+		});
+	}
+	else
+	{
+		blake3_hasher_update(b3h, Buffer.GetData(), BufferSize);
+	}
+
+	return *this;
+}
+
 BLAKE3
 BLAKE3Stream::GetHash()
 {
diff --git a/src/zencore/compactbinaryjson.cpp b/src/zencore/compactbinaryjson.cpp
index d8c8a8584..68ed09549 100644
--- a/src/zencore/compactbinaryjson.cpp
+++ b/src/zencore/compactbinaryjson.cpp
@@ -293,6 +293,7 @@ private:
 		const uint32_t EncodedSize	= Base64::GetEncodedDataSize(uint32_t(Value.GetSize()));
 		const size_t   EncodedIndex = Builder.AddUninitialized(size_t(EncodedSize));
 		Base64::Encode(static_cast<const uint8_t*>(Value.GetData()), uint32_t(Value.GetSize()), Builder.Data() + EncodedIndex);
+		Builder << '"';
 	}
 
 private:
diff --git a/src/zencore/compactbinaryvalidation.cpp b/src/zencore/compactbinaryvalidation.cpp
index 6f53bba69..833649b88 100644
--- a/src/zencore/compactbinaryvalidation.cpp
+++ b/src/zencore/compactbinaryvalidation.cpp
@@ -135,6 +135,37 @@ ValidateCbFloat64(MemoryView& View, CbValidateMode Mode, CbValidateError& Error)
 }
 
 /**
+ * Validate and read a fixed-size value from the view.
+ *
+ * Modifies the view to start at the end of the value, and adds error flags if applicable.
+ */
+static MemoryView
+ValidateCbFixedValue(MemoryView& View, CbValidateMode Mode, CbValidateError& Error, uint64_t Size)
+{
+	ZEN_UNUSED(Mode);
+
+	const MemoryView Value = View.Left(Size);
+	View += Size;
+	if (Value.GetSize() < Size)
+	{
+		AddError(Error, CbValidateError::OutOfBounds);
+	}
+	return Value;
+};
+
+/**
+ * Validate and read a value from the view where the view begins with the value size.
+ *
+ * Modifies the view to start at the end of the value, and adds error flags if applicable.
+ */
+static MemoryView
+ValidateCbDynamicValue(MemoryView& View, CbValidateMode Mode, CbValidateError& Error)
+{
+	const uint64_t ValueSize = ValidateCbUInt(View, Mode, Error);
+	return ValidateCbFixedValue(View, Mode, Error, ValueSize);
+}
+
+/**
  * Validate and read a string from the view.
  *
  * Modifies the view to start at the end of the string, and adds error flags if applicable.
@@ -378,8 +409,20 @@ ValidateCbField(MemoryView& View, CbValidateMode Mode, CbValidateError& Error, c
 			ValidateFixedPayload(12);
 			break;
 		case CbFieldType::CustomById:
+			{
+				MemoryView Value = ValidateCbDynamicValue(View, Mode, Error);
+				ValidateCbUInt(Value, Mode, Error);
+			}
+			break;
 		case CbFieldType::CustomByName:
-			ZEN_NOT_IMPLEMENTED();	// TODO: FIX!
+			{
+				MemoryView			   Value	= ValidateCbDynamicValue(View, Mode, Error);
+				const std::string_view TypeName = ValidateCbString(Value, Mode, Error);
+				if (TypeName.empty() && !EnumHasAnyFlags(Error, CbValidateError::OutOfBounds))
+				{
+					AddError(Error, CbValidateError::InvalidType);
+				}
+			}
 			break;
 	}
 
diff --git a/src/zencore/compress.cpp b/src/zencore/compress.cpp
index 88c3bb5b9..d9f381811 100644
--- a/src/zencore/compress.cpp
+++ b/src/zencore/compress.cpp
@@ -7,6 +7,7 @@
 #include <zencore/compositebuffer.h>
 #include <zencore/crc32.h>
 #include <zencore/endian.h>
+#include <zencore/filesystem.h>
 #include <zencore/intmath.h>
 #include <zencore/iohash.h>
 #include <zencore/stream.h>
@@ -158,9 +159,10 @@ class BaseEncoder
 {
 public:
 	[[nodiscard]] virtual CompositeBuffer Compress(const CompositeBuffer& RawData, uint64_t BlockSize = DefaultBlockSize) const = 0;
-	[[nodiscard]] virtual bool			  CompressToStream(const CompositeBuffer&												RawData,
-														   std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-														   uint64_t BlockSize = DefaultBlockSize) const							= 0;
+	[[nodiscard]] virtual bool			  CompressToStream(
+				   const CompositeBuffer&																							RawData,
+				   std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+				   uint64_t BlockSize = DefaultBlockSize) const = 0;
 };
 
 class BaseDecoder
@@ -189,11 +191,13 @@ public:
 												  uint64_t			   RawOffset,
 												  uint64_t			   RawSize) const = 0;
 
-	virtual bool DecompressToStream(const BufferHeader&													 Header,
-									const CompositeBuffer&												 CompressedData,
-									uint64_t															 RawOffset,
-									uint64_t															 RawSize,
-									std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const = 0;
+	virtual bool DecompressToStream(
+		const BufferHeader&																								 Header,
+		const CompositeBuffer&																							 CompressedData,
+		uint64_t																										 RawOffset,
+		uint64_t																										 RawSize,
+		std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback)
+		const = 0;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -207,13 +211,50 @@ public:
 		return CompositeBuffer(HeaderData.MoveToShared(), RawData.MakeOwned());
 	}
 
-	[[nodiscard]] virtual bool CompressToStream(const CompositeBuffer&												 RawData,
-												std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-												uint64_t /* BlockSize */) const final
+	[[nodiscard]] virtual bool CompressToStream(
+		const CompositeBuffer&																							 RawData,
+		std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+		uint64_t /* BlockSize */) const final
 	{
-		UniqueBuffer HeaderData = CompressedBuffer::CreateHeaderForNoneEncoder(RawData.GetSize(), BLAKE3::HashBuffer(RawData));
-		Callback(0, CompositeBuffer(IoBuffer(IoBuffer::Wrap, HeaderData.GetData(), HeaderData.GetSize())));
-		Callback(HeaderData.GetSize(), RawData);
+		const uint64_t HeaderSize = CompressedBuffer::GetHeaderSizeForNoneEncoder();
+
+		uint64_t	 RawOffset = 0;
+		BLAKE3Stream HashStream;
+
+		for (const SharedBuffer& Segment : RawData.GetSegments())
+		{
+			IoBufferFileReference FileRef		= {nullptr, 0, 0};
+			IoBuffer			  SegmentBuffer = Segment.AsIoBuffer();
+			if (SegmentBuffer.GetFileReference(FileRef))
+			{
+				ZEN_ASSERT(FileRef.FileHandle != nullptr);
+
+				ScanFile(FileRef.FileHandle,
+						 FileRef.FileChunkOffset,
+						 FileRef.FileChunkSize,
+						 512u * 1024u,
+						 [&](const void* Data, size_t Size) {
+							 HashStream.Append(Data, Size);
+							 CompositeBuffer Tmp(SharedBuffer::MakeView(Data, Size));
+							 Callback(RawOffset, Size, HeaderSize + RawOffset, Tmp);
+							 RawOffset += Size;
+						 });
+			}
+			else
+			{
+				const uint64_t Size = SegmentBuffer.GetSize();
+				HashStream.Append(SegmentBuffer);
+				Callback(RawOffset, Size, HeaderSize + RawOffset, CompositeBuffer(Segment));
+				RawOffset += Size;
+			}
+		}
+
+		ZEN_ASSERT(RawOffset == RawData.GetSize());
+
+		UniqueBuffer HeaderData = CompressedBuffer::CreateHeaderForNoneEncoder(RawData.GetSize(), HashStream.GetHash());
+		ZEN_ASSERT(HeaderData.GetSize() == HeaderSize);
+		Callback(0, 0, 0, CompositeBuffer(HeaderData.MoveToShared()));
+
 		return true;
 	}
 };
@@ -283,21 +324,41 @@ public:
 
 	[[nodiscard]] uint64_t GetHeaderSize(const BufferHeader&) const final { return sizeof(BufferHeader); }
 
-	virtual bool DecompressToStream(const BufferHeader&													 Header,
-									const CompositeBuffer&												 CompressedData,
-									uint64_t															 RawOffset,
-									uint64_t															 RawSize,
-									std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const final
+	virtual bool DecompressToStream(
+		const BufferHeader&																								 Header,
+		const CompositeBuffer&																							 CompressedData,
+		uint64_t																										 RawOffset,
+		uint64_t																										 RawSize,
+		std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback)
+		const final
 	{
 		if (Header.Method == CompressionMethod::None && Header.TotalCompressedSize == CompressedData.GetSize() &&
 			Header.TotalCompressedSize == Header.TotalRawSize + sizeof(BufferHeader) && RawOffset < Header.TotalRawSize &&
 			(RawOffset + RawSize) <= Header.TotalRawSize)
 		{
-			if (!Callback(0, CompressedData.Mid(sizeof(BufferHeader) + RawOffset, RawSize)))
+			bool				  Result  = true;
+			IoBufferFileReference FileRef = {nullptr, 0, 0};
+			if ((CompressedData.GetSegments().size() == 1) && CompressedData.GetSegments()[0].AsIoBuffer().GetFileReference(FileRef))
 			{
-				return false;
+				ZEN_ASSERT(FileRef.FileHandle != nullptr);
+				uint64_t CallbackOffset = 0;
+				ScanFile(FileRef.FileHandle, sizeof(BufferHeader) + RawOffset, RawSize, 512u * 1024u, [&](const void* Data, size_t Size) {
+					if (Result)
+					{
+						CompositeBuffer Tmp(SharedBuffer::MakeView(Data, Size));
+						Result = Callback(sizeof(BufferHeader) + RawOffset + CallbackOffset, Size, CallbackOffset, Tmp);
+					}
+					CallbackOffset += Size;
+				});
+				return Result;
+			}
+			else
+			{
+				return Callback(sizeof(BufferHeader) + RawOffset,
+								RawSize,
+								0,
+								CompressedData.Mid(sizeof(BufferHeader) + RawOffset, RawSize));
 			}
-			return true;
 		}
 		return false;
 	}
@@ -309,9 +370,10 @@ class BlockEncoder : public BaseEncoder
 {
 public:
 	virtual CompositeBuffer Compress(const CompositeBuffer& RawData, uint64_t BlockSize) const final;
-	virtual bool			CompressToStream(const CompositeBuffer&												  RawData,
-											 std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-											 uint64_t															  BlockSize) const final;
+	virtual bool			CompressToStream(
+				   const CompositeBuffer&																							RawData,
+				   std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+				   uint64_t BlockSize) const final;
 
 protected:
 	virtual CompressionMethod GetMethod() const															 = 0;
@@ -460,9 +522,10 @@ BlockEncoder::Compress(const CompositeBuffer& RawData, const uint64_t BlockSize)
 }
 
 bool
-BlockEncoder::CompressToStream(const CompositeBuffer&												RawData,
-							   std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-							   uint64_t																BlockSize = DefaultBlockSize) const
+BlockEncoder::CompressToStream(
+	const CompositeBuffer&																							 RawData,
+	std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+	uint64_t BlockSize = DefaultBlockSize) const
 {
 	ZEN_ASSERT(IsPow2(BlockSize) && (BlockSize <= (1u << 31)));
 
@@ -504,13 +567,17 @@ BlockEncoder::CompressToStream(const CompositeBuffer&												RawData,
 				uint64_t CompressedBlockSize = CompressedBlock.GetSize();
 				if (RawBlockSize <= CompressedBlockSize)
 				{
-					Callback(FullHeaderSize + CompressedSize,
+					Callback(FileRef.FileChunkOffset + RawOffset,
+							 RawBlockSize,
+							 FullHeaderSize + CompressedSize,
 							 CompositeBuffer(IoBuffer(IoBuffer::Wrap, RawBlockCopy.GetView().GetData(), RawBlockSize)));
 					CompressedBlockSize = RawBlockSize;
 				}
 				else
 				{
-					Callback(FullHeaderSize + CompressedSize,
+					Callback(FileRef.FileChunkOffset + RawOffset,
+							 RawBlockSize,
+							 FullHeaderSize + CompressedSize,
 							 CompositeBuffer(IoBuffer(IoBuffer::Wrap, CompressedBlock.GetData(), CompressedBlockSize)));
 				}
 
@@ -540,12 +607,17 @@ BlockEncoder::CompressToStream(const CompositeBuffer&												RawData,
 				uint64_t CompressedBlockSize = CompressedBlock.GetSize();
 				if (RawBlockSize <= CompressedBlockSize)
 				{
-					Callback(FullHeaderSize + CompressedSize, CompositeBuffer(IoBuffer(IoBuffer::Wrap, RawBlock.GetData(), RawBlockSize)));
+					Callback(RawOffset,
+							 RawBlockSize,
+							 FullHeaderSize + CompressedSize,
+							 CompositeBuffer(IoBuffer(IoBuffer::Wrap, RawBlock.GetData(), RawBlockSize)));
 					CompressedBlockSize = RawBlockSize;
 				}
 				else
 				{
-					Callback(FullHeaderSize + CompressedSize,
+					Callback(RawOffset,
+							 RawBlockSize,
+							 FullHeaderSize + CompressedSize,
 							 CompositeBuffer(IoBuffer(IoBuffer::Wrap, CompressedBlock.GetData(), CompressedBlockSize)));
 				}
 
@@ -582,7 +654,7 @@ BlockEncoder::CompressToStream(const CompositeBuffer&												RawData,
 	HeaderBuffer.GetMutableView().Mid(sizeof(BufferHeader), MetaSize).CopyFrom(MakeMemoryView(CompressedBlockSizes));
 	Header.Write(HeaderBuffer.GetMutableView());
 
-	Callback(0, CompositeBuffer(IoBuffer(IoBuffer::Wrap, HeaderBuffer.GetData(), HeaderBuffer.GetSize())));
+	Callback(0, 0, 0, CompositeBuffer(IoBuffer(IoBuffer::Wrap, HeaderBuffer.GetData(), HeaderBuffer.GetSize())));
 	return true;
 }
 
@@ -615,11 +687,13 @@ public:
 									   MutableMemoryView	  RawView,
 									   uint64_t				  RawOffset) const final;
 
-	virtual bool DecompressToStream(const BufferHeader&													 Header,
-									const CompositeBuffer&												 CompressedData,
-									uint64_t															 RawOffset,
-									uint64_t															 RawSize,
-									std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const final;
+	virtual bool DecompressToStream(
+		const BufferHeader&																								 Header,
+		const CompositeBuffer&																							 CompressedData,
+		uint64_t																										 RawOffset,
+		uint64_t																										 RawSize,
+		std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback)
+		const final;
 
 protected:
 	virtual bool DecompressBlock(MutableMemoryView RawData, MemoryView CompressedData) const = 0;
@@ -743,11 +817,12 @@ BlockDecoder::DecompressToComposite(const BufferHeader& Header, const CompositeB
 }
 
 bool
-BlockDecoder::DecompressToStream(const BufferHeader&												  Header,
-								 const CompositeBuffer&												  CompressedData,
-								 uint64_t															  RawOffset,
-								 uint64_t															  RawSize,
-								 std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const
+BlockDecoder::DecompressToStream(
+	const BufferHeader&																								 Header,
+	const CompositeBuffer&																							 CompressedData,
+	uint64_t																										 RawOffset,
+	uint64_t																										 RawSize,
+	std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const
 {
 	if (Header.TotalCompressedSize != CompressedData.GetSize())
 	{
@@ -817,7 +892,9 @@ BlockDecoder::DecompressToStream(const BufferHeader&												  Header,
 					Source.Detach();
 					return false;
 				}
-				if (!Callback(BlockIndex * BlockSize + OffsetInFirstBlock,
+				if (!Callback(FileRef.FileChunkOffset + CompressedOffset,
+							  CompressedBlockSize,
+							  BlockIndex * BlockSize + OffsetInFirstBlock,
 							  CompositeBuffer(IoBuffer(IoBuffer::Wrap, RawDataBuffer.GetData(), BytesToUncompress))))
 				{
 					Source.Detach();
@@ -827,6 +904,8 @@ BlockDecoder::DecompressToStream(const BufferHeader&												  Header,
 			else
 			{
 				if (!Callback(
+						FileRef.FileChunkOffset + CompressedOffset,
+						BytesToUncompress,
 						BlockIndex * BlockSize + OffsetInFirstBlock,
 						CompositeBuffer(
 							IoBuffer(IoBuffer::Wrap, CompressedBlockCopy.GetView().Mid(OffsetInFirstBlock).GetData(), BytesToUncompress))))
@@ -870,7 +949,9 @@ BlockDecoder::DecompressToStream(const BufferHeader&												  Header,
 				{
 					return false;
 				}
-				if (!Callback(BlockIndex * BlockSize + OffsetInFirstBlock,
+				if (!Callback(CompressedOffset,
+							  UncompressedBlockSize,
+							  BlockIndex * BlockSize + OffsetInFirstBlock,
 							  CompositeBuffer(IoBuffer(IoBuffer::Wrap, RawDataBuffer.GetData(), BytesToUncompress))))
 				{
 					return false;
@@ -879,6 +960,8 @@ BlockDecoder::DecompressToStream(const BufferHeader&												  Header,
 			else
 			{
 				if (!Callback(
+						CompressedOffset,
+						BytesToUncompress,
 						BlockIndex * BlockSize + OffsetInFirstBlock,
 						CompositeBuffer(
 							IoBuffer(IoBuffer::Wrap, CompressedBlockCopy.GetView().Mid(OffsetInFirstBlock).GetData(), BytesToUncompress))))
@@ -1778,11 +1861,12 @@ CompressedBuffer::Compress(const SharedBuffer&	 RawData,
 }
 
 bool
-CompressedBuffer::CompressToStream(const CompositeBuffer&												RawData,
-								   std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-								   OodleCompressor														Compressor,
-								   OodleCompressionLevel												CompressionLevel,
-								   uint64_t																BlockSize)
+CompressedBuffer::CompressToStream(
+	const CompositeBuffer&																							 RawData,
+	std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+	OodleCompressor																									 Compressor,
+	OodleCompressionLevel																							 CompressionLevel,
+	uint64_t																										 BlockSize)
 {
 	using namespace detail;
 
@@ -1995,9 +2079,10 @@ CompressedBuffer::DecompressToComposite() const
 }
 
 bool
-CompressedBuffer::DecompressToStream(uint64_t															  RawOffset,
-									 uint64_t															  RawSize,
-									 std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const
+CompressedBuffer::DecompressToStream(
+	uint64_t																										 RawOffset,
+	uint64_t																										 RawSize,
+	std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const
 {
 	using namespace detail;
 	if (CompressedData)
diff --git a/src/zencore/except.cpp b/src/zencore/except.cpp
index d5eabea9d..610b0ced5 100644
--- a/src/zencore/except.cpp
+++ b/src/zencore/except.cpp
@@ -47,7 +47,7 @@ ThrowSystemException([[maybe_unused]] HRESULT hRes, [[maybe_unused]] std::string
 {
 	if (HRESULT_FACILITY(hRes) == FACILITY_WIN32)
 	{
-		throw std::system_error(std::error_code(hRes & 0xffff, std::system_category()), std::string(Message));
+		throw std::system_error(std::error_code(HRESULT_CODE(hRes), std::system_category()), std::string(Message));
 	}
 	else
 	{
diff --git a/src/zencore/filesystem.cpp b/src/zencore/filesystem.cpp
index 05e2bf049..46337ffc8 100644
--- a/src/zencore/filesystem.cpp
+++ b/src/zencore/filesystem.cpp
@@ -33,6 +33,7 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #	include <dirent.h>
 #	include <fcntl.h>
 #	include <sys/resource.h>
+#	include <sys/mman.h>
 #	include <sys/stat.h>
 #	include <pwd.h>
 #	include <unistd.h>
@@ -43,6 +44,7 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #	include <fcntl.h>
 #	include <libproc.h>
 #	include <sys/resource.h>
+#	include <sys/mman.h>
 #	include <sys/stat.h>
 #	include <sys/syslimits.h>
 #	include <pwd.h>
@@ -86,16 +88,9 @@ DeleteReparsePoint(const wchar_t* Path, DWORD dwReparseTag)
 }
 
 bool
-CreateDirectories(const wchar_t* Dir)
+CreateDirectories(const wchar_t* Path)
 {
-	// This may be suboptimal, in that it appears to try and create directories
-	// from the root on up instead of from some directory which is known to
-	// be present
-	//
-	// We should implement a smarter version at some point since this can be
-	// pretty expensive in aggregate
-
-	return std::filesystem::create_directories(Dir);
+	return CreateDirectories(std::filesystem::path(Path));
 }
 
 // Erase all files and directories in a given directory, leaving an empty directory
@@ -212,75 +207,377 @@ DeleteDirectoriesInternal(const wchar_t* DirPath)
 bool
 CleanDirectory(const wchar_t* DirPath, bool KeepDotFiles)
 {
-	if (std::filesystem::exists(DirPath))
+	if (IsDir(DirPath))
 	{
 		return WipeDirectory(DirPath, KeepDotFiles);
 	}
 
 	return CreateDirectories(DirPath);
 }
+
+#endif	// ZEN_PLATFORM_WINDOWS
+
+#if ZEN_PLATFORM_WINDOWS
+const uint32_t FileAttributesSystemReadOnlyFlag = FILE_ATTRIBUTE_READONLY;
+#else
+const uint32_t FileAttributesSystemReadOnlyFlag = 0x00000001;
 #endif	// ZEN_PLATFORM_WINDOWS
 
+const uint32_t FileModeWriteEnableFlags = 0222;
+
 bool
-CreateDirectories(const std::filesystem::path& Dir)
+IsFileAttributeReadOnly(uint32_t FileAttributes)
 {
-	if (Dir.string().ends_with(":"))
+#if ZEN_PLATFORM_WINDOWS
+	return (FileAttributes & FileAttributesSystemReadOnlyFlag) != 0;
+#else
+	return (FileAttributes & 0x00000001) != 0;
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+bool
+IsFileModeReadOnly(uint32_t FileMode)
+{
+	return (FileMode & FileModeWriteEnableFlags) == 0;
+}
+
+uint32_t
+MakeFileAttributeReadOnly(uint32_t FileAttributes, bool ReadOnly)
+{
+	return ReadOnly ? (FileAttributes | FileAttributesSystemReadOnlyFlag) : (FileAttributes & ~FileAttributesSystemReadOnlyFlag);
+}
+
+uint32_t
+MakeFileModeReadOnly(uint32_t FileMode, bool ReadOnly)
+{
+	return ReadOnly ? (FileMode & ~FileModeWriteEnableFlags) : (FileMode | FileModeWriteEnableFlags);
+}
+
+#if ZEN_PLATFORM_WINDOWS
+
+static DWORD
+WinGetFileAttributes(const std::filesystem::path& Path, std::error_code& Ec)
+{
+	DWORD Attributes = ::GetFileAttributes(Path.native().c_str());
+	if (Attributes == INVALID_FILE_ATTRIBUTES)
 	{
+		DWORD LastError = GetLastError();
+		switch (LastError)
+		{
+			case ERROR_FILE_NOT_FOUND:
+			case ERROR_PATH_NOT_FOUND:
+			case ERROR_BAD_NETPATH:
+			case ERROR_INVALID_DRIVE:
+				break;
+			case ERROR_ACCESS_DENIED:
+				{
+					WIN32_FIND_DATA FindData;
+					HANDLE			FindHandle = ::FindFirstFile(Path.native().c_str(), &FindData);
+					if (FindHandle == INVALID_HANDLE_VALUE)
+					{
+						DWORD LastFindError = GetLastError();
+						if (LastFindError != ERROR_FILE_NOT_FOUND)
+						{
+							Ec = MakeErrorCode(LastError);
+						}
+					}
+					else
+					{
+						FindClose(FindHandle);
+						Attributes = FindData.dwFileAttributes;
+					}
+				}
+				break;
+			default:
+				Ec = MakeErrorCode(LastError);
+				break;
+		}
+	}
+	return Attributes;
+}
+
+#endif	// ZEN_PLATFORM_WINDOWS
+
+bool
+RemoveDirNative(const std::filesystem::path& Path, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	BOOL Success = ::RemoveDirectory(Path.native().c_str());
+	if (!Success)
+	{
+		DWORD LastError = GetLastError();
+		switch (LastError)
+		{
+			case ERROR_FILE_NOT_FOUND:
+			case ERROR_PATH_NOT_FOUND:
+				break;
+			default:
+				Ec = MakeErrorCode(LastError);
+				break;
+		}
 		return false;
 	}
-	while (!std::filesystem::is_directory(Dir))
+	return true;
+#else
+	return std::filesystem::remove(Path, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+bool
+RemoveFileNative(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	const std::filesystem::path::value_type* NativePath = Path.native().c_str();
+	BOOL									 Success	= ::DeleteFile(NativePath);
+	if (!Success)
 	{
-		if (Dir.has_parent_path())
+		if (ForceRemoveReadOnlyFiles)
 		{
-			CreateDirectories(Dir.parent_path());
+			DWORD FileAttributes = WinGetFileAttributes(NativePath, Ec);
+			if (Ec)
+			{
+				return false;
+			}
+
+			if ((FileAttributes != INVALID_FILE_ATTRIBUTES) && IsFileAttributeReadOnly(FileAttributes) != 0)
+			{
+				::SetFileAttributes(NativePath, MakeFileAttributeReadOnly(FileAttributes, false));
+				Success = ::DeleteFile(NativePath);
+			}
 		}
-		std::error_code ErrorCode;
-		std::filesystem::create_directory(Dir, ErrorCode);
-		if (ErrorCode)
+		if (!Success)
 		{
-			throw std::system_error(ErrorCode, fmt::format("Failed to create directories for '{}'", Dir.string()));
+			DWORD LastError = GetLastError();
+			switch (LastError)
+			{
+				case ERROR_FILE_NOT_FOUND:
+				case ERROR_PATH_NOT_FOUND:
+					break;
+				default:
+					Ec = MakeErrorCode(LastError);
+					break;
+			}
+			return false;
+		}
+	}
+	return true;
+#else
+	if (!ForceRemoveReadOnlyFiles)
+	{
+		struct stat Stat;
+		int			err = stat(Path.native().c_str(), &Stat);
+		if (err != 0)
+		{
+			int32_t err = errno;
+			if (err == ENOENT)
+			{
+				Ec.clear();
+				return false;
+			}
+		}
+		const uint32_t Mode = (uint32_t)Stat.st_mode;
+		if (IsFileModeReadOnly(Mode))
+		{
+			Ec = MakeErrorCode(EACCES);
+			return false;
+		}
+	}
+	return std::filesystem::remove(Path, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+static void
+WipeDirectoryContentInternal(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles, std::error_code& Ec)
+{
+	DirectoryContent LocalDirectoryContent;
+	GetDirectoryContent(Path, DirectoryContentFlags::IncludeDirs | DirectoryContentFlags::IncludeFiles, LocalDirectoryContent);
+	for (const std::filesystem::path& LocalFilePath : LocalDirectoryContent.Files)
+	{
+		RemoveFileNative(LocalFilePath, ForceRemoveReadOnlyFiles, Ec);
+		for (size_t Retries = 0; Ec && Retries < 3; Retries++)
+		{
+			Sleep(100 + int(Retries * 50));
+			Ec.clear();
+			if (IsFile(LocalFilePath))
+			{
+				RemoveFileNative(LocalFilePath, ForceRemoveReadOnlyFiles, Ec);
+			}
+		}
+		if (Ec)
+		{
+			return;
+		}
+	}
+
+	for (std::filesystem::path& LocalDirPath : LocalDirectoryContent.Directories)
+	{
+		WipeDirectoryContentInternal(LocalDirPath, ForceRemoveReadOnlyFiles, Ec);
+		if (Ec)
+		{
+			return;
+		}
+
+		RemoveDirNative(LocalDirPath, Ec);
+		for (size_t Retries = 0; Ec && Retries < 3; Retries++)
+		{
+			Sleep(100 + int(Retries * 50));
+			Ec.clear();
+			if (IsDir(LocalDirPath))
+			{
+				RemoveDirNative(LocalDirPath, Ec);
+			}
+		}
+		if (Ec)
+		{
+			return;
 		}
-		return true;
 	}
-	return false;
 }
 
 bool
-DeleteDirectories(const std::filesystem::path& Dir)
+CreateDirectory(const std::filesystem::path& Path, std::error_code& Ec)
 {
-	std::error_code ErrorCode;
-	return std::filesystem::remove_all(Dir, ErrorCode);
+#if ZEN_PLATFORM_WINDOWS
+	BOOL Success = ::CreateDirectory(Path.native().c_str(), nullptr);
+	if (!Success)
+	{
+		DWORD LastError = GetLastError();
+		switch (LastError)
+		{
+			case ERROR_FILE_EXISTS:
+			case ERROR_ALREADY_EXISTS:
+				break;
+			default:
+				Ec = MakeErrorCode(LastError);
+				break;
+		}
+		return false;
+	}
+	return Success;
+#else
+	return std::filesystem::create_directory(Path, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
 }
 
 bool
-CleanDirectory(const std::filesystem::path& Dir)
+CreateDirectories(const std::filesystem::path& Path)
 {
-	if (std::filesystem::exists(Dir))
+	std::error_code Ec;
+	bool			Success = CreateDirectories(Path, Ec);
+	if (Ec)
 	{
-		bool Success = true;
+		throw std::system_error(Ec, fmt::format("Failed to create directories for '{}'", Path.string()));
+	}
+	return Success;
+}
 
-		for (const auto& Item : std::filesystem::directory_iterator(Dir))
-		{
-			std::error_code ErrorCode;
-			const uintmax_t RemovedCount = std::filesystem::remove_all(Item, ErrorCode);
+bool
+CreateDirectories(const std::filesystem::path& Path, std::error_code& Ec)
+{
+	if (Path.string().ends_with(":"))
+	{
+		return false;
+	}
+	bool Exists = IsDir(Path, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	if (Exists)
+	{
+		return false;
+	}
 
-			Success = Success && !ErrorCode && RemovedCount;
+	if (Path.has_parent_path())
+	{
+		bool Result = CreateDirectories(Path.parent_path(), Ec);
+		if (Ec)
+		{
+			return Result;
 		}
+	}
+	return CreateDirectory(Path, Ec);
+}
 
-		return Success;
+bool
+CleanDirectory(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles)
+{
+	std::error_code Ec;
+	bool			Result = CleanDirectory(Path, ForceRemoveReadOnlyFiles, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to clean directory for '{}'", Path.string()));
 	}
+	return Result;
+}
 
-	return CreateDirectories(Dir);
+bool
+CleanDirectory(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles, std::error_code& Ec)
+{
+	bool Exists = IsDir(Path, Ec);
+	if (Ec)
+	{
+		return Exists;
+	}
+	if (Exists)
+	{
+		WipeDirectoryContentInternal(Path, ForceRemoveReadOnlyFiles, Ec);
+		return false;
+	}
+	return CreateDirectory(Path, Ec);
+}
+
+bool
+DeleteDirectories(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	bool			Result = DeleteDirectories(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to delete directories for '{}'", Path.string()));
+	}
+	return Result;
+}
+
+bool
+DeleteDirectories(const std::filesystem::path& Path, std::error_code& Ec)
+{
+	bool Exists = IsDir(Path, Ec);
+	if (Ec)
+	{
+		return Exists;
+	}
+
+	if (Exists)
+	{
+		WipeDirectoryContentInternal(Path, false, Ec);
+		if (Ec)
+		{
+			return false;
+		}
+		bool Result = RemoveDirNative(Path, Ec);
+		for (size_t Retries = 0; Ec && Retries < 3; Retries++)
+		{
+			Sleep(100 + int(Retries * 50));
+			Ec.clear();
+			if (IsDir(Path))
+			{
+				Result = RemoveDirNative(Path, Ec);
+			}
+		}
+		return Result;
+	}
+	return false;
 }
 
 bool
-CleanDirectoryExceptDotFiles(const std::filesystem::path& Dir)
+CleanDirectoryExceptDotFiles(const std::filesystem::path& Path)
 {
 #if ZEN_PLATFORM_WINDOWS
 	const bool KeepDotFiles = true;
-	return CleanDirectory(Dir.c_str(), KeepDotFiles);
+	return CleanDirectory(Path.c_str(), KeepDotFiles);
 #else
-	ZEN_UNUSED(Dir);
+	ZEN_UNUSED(Path);
 
 	ZEN_NOT_IMPLEMENTED();
 #endif
@@ -637,7 +934,7 @@ CopyTree(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 {
 	// Validate arguments
 
-	if (FromPath.empty() || !std::filesystem::is_directory(FromPath))
+	if (FromPath.empty() || !IsDir(FromPath))
 		throw std::runtime_error("invalid CopyTree source directory specified");
 
 	if (ToPath.empty())
@@ -646,16 +943,13 @@ CopyTree(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 	if (Options.MustClone && !SupportsBlockRefCounting(FromPath))
 		throw std::runtime_error(fmt::format("cloning not possible from '{}'", FromPath));
 
-	if (std::filesystem::exists(ToPath))
+	if (IsFile(ToPath))
 	{
-		if (!std::filesystem::is_directory(ToPath))
-		{
-			throw std::runtime_error(fmt::format("specified CopyTree target '{}' is not a directory", ToPath));
-		}
+		throw std::runtime_error(fmt::format("specified CopyTree target '{}' is not a directory", ToPath));
 	}
-	else
+	if (!IsDir(ToPath))
 	{
-		std::filesystem::create_directories(ToPath);
+		CreateDirectories(ToPath);
 	}
 
 	if (Options.MustClone && !SupportsBlockRefCounting(ToPath))
@@ -760,6 +1054,100 @@ CopyTree(std::filesystem::path FromPath, std::filesystem::path ToPath, const Cop
 }
 
 void
+WriteFile(void* NativeHandle, const void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec)
+{
+	ZEN_ASSERT(NativeHandle != nullptr);
+
+	Ec.clear();
+
+	while (Size)
+	{
+		const uint64_t NumberOfBytesToWrite = Min(Size, ChunkSize);
+
+#if ZEN_PLATFORM_WINDOWS
+		OVERLAPPED Ovl{};
+
+		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
+		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
+
+		DWORD dwNumberOfBytesWritten = 0;
+
+		BOOL Success = ::WriteFile(NativeHandle, Data, DWORD(NumberOfBytesToWrite), &dwNumberOfBytesWritten, &Ovl);
+#else
+		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
+		int	 Fd			  = int(uintptr_t(NativeHandle));
+		int	 BytesWritten = pwrite(Fd, Data, NumberOfBytesToWrite, FileOffset);
+		bool Success	  = (BytesWritten > 0);
+#endif
+
+		if (!Success)
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+
+		Size -= NumberOfBytesToWrite;
+		FileOffset += NumberOfBytesToWrite;
+		Data = reinterpret_cast<const uint8_t*>(Data) + NumberOfBytesToWrite;
+	}
+}
+
+void
+ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec)
+{
+	while (Size)
+	{
+		const uint64_t NumberOfBytesToRead = Min(Size, ChunkSize);
+		size_t		   BytesRead		   = 0;
+
+#if ZEN_PLATFORM_WINDOWS
+		OVERLAPPED Ovl{};
+
+		Ovl.Offset	   = DWORD(FileOffset & 0xffff'ffffu);
+		Ovl.OffsetHigh = DWORD(FileOffset >> 32);
+
+		DWORD dwNumberOfBytesRead = 0;
+		BOOL  Success			  = ::ReadFile(NativeHandle, Data, DWORD(NumberOfBytesToRead), &dwNumberOfBytesRead, &Ovl);
+		if (Success)
+		{
+			BytesRead = size_t(dwNumberOfBytesRead);
+		}
+		else if ((BytesRead != NumberOfBytesToRead))
+		{
+			Ec = MakeErrorCode(ERROR_HANDLE_EOF);
+			return;
+		}
+		else
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+#else
+		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
+		int		Fd		   = int(uintptr_t(NativeHandle));
+		ssize_t ReadResult = pread(Fd, Data, NumberOfBytesToRead, FileOffset);
+		if (ReadResult != -1)
+		{
+			BytesRead = size_t(ReadResult);
+		}
+		else if ((BytesRead != NumberOfBytesToRead))
+		{
+			Ec = MakeErrorCode(EIO);
+			return;
+		}
+		else
+		{
+			Ec = MakeErrorCodeFromLastError();
+			return;
+		}
+#endif
+		Size -= NumberOfBytesToRead;
+		FileOffset += NumberOfBytesToRead;
+		Data = reinterpret_cast<uint8_t*>(Data) + NumberOfBytesToRead;
+	}
+}
+
+void
 WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t BufferCount)
 {
 #if ZEN_PLATFORM_WINDOWS
@@ -811,7 +1199,7 @@ WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t Buffer
 			{
 				Outfile.Close();
 				std::error_code DummyEc;
-				std::filesystem::remove(Path, DummyEc);
+				RemoveFile(Path, DummyEc);
 				ThrowSystemException(hRes, fmt::format("File write failed for '{}'", Path).c_str());
 			}
 #else
@@ -819,7 +1207,7 @@ WriteFile(std::filesystem::path Path, const IoBuffer* const* Data, size_t Buffer
 			{
 				close(Fd);
 				std::error_code DummyEc;
-				std::filesystem::remove(Path, DummyEc);
+				RemoveFile(Path, DummyEc);
 				ThrowLastError(fmt::format("File write failed for '{}'", Path));
 			}
 #endif	// ZEN_PLATFORM_WINDOWS
@@ -1172,7 +1560,7 @@ void
 FileSystemTraversal::TraverseFileSystem(const std::filesystem::path& RootDir, TreeVisitor& Visitor)
 {
 #if ZEN_PLATFORM_WINDOWS
-	uint64_t FileInfoBuffer[8 * 1024];
+	std::vector<uint64_t> FileInfoBuffer(8 * 1024);
 
 	FILE_INFO_BY_HANDLE_CLASS FibClass = FileIdBothDirectoryRestartInfo;
 	bool					  Continue = true;
@@ -1183,7 +1571,7 @@ FileSystemTraversal::TraverseFileSystem(const std::filesystem::path& RootDir, Tr
 
 	if (FAILED(hRes))
 	{
-		if (hRes == ERROR_FILE_NOT_FOUND || hRes == ERROR_PATH_NOT_FOUND)
+		if (HRESULT_CODE(hRes) == ERROR_FILE_NOT_FOUND || HRESULT_CODE(hRes) == ERROR_PATH_NOT_FOUND)
 		{
 			// Directory no longer exist, treat it as empty
 			return;
@@ -1193,8 +1581,9 @@ FileSystemTraversal::TraverseFileSystem(const std::filesystem::path& RootDir, Tr
 
 	while (Continue)
 	{
-		BOOL Success = GetFileInformationByHandleEx(RootDirHandle, FibClass, FileInfoBuffer, sizeof FileInfoBuffer);
-		FibClass	 = FileIdBothDirectoryInfo;	 // Set up for next iteration
+		BOOL Success =
+			GetFileInformationByHandleEx(RootDirHandle, FibClass, FileInfoBuffer.data(), (DWORD)(FileInfoBuffer.size() * sizeof(uint64_t)));
+		FibClass = FileIdBothDirectoryInfo;	 // Set up for next iteration
 
 		uint64_t EntryOffset = 0;
 
@@ -1213,7 +1602,7 @@ FileSystemTraversal::TraverseFileSystem(const std::filesystem::path& RootDir, Tr
 		for (;;)
 		{
 			const FILE_ID_BOTH_DIR_INFO* DirInfo =
-				reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(reinterpret_cast<const uint8_t*>(FileInfoBuffer) + EntryOffset);
+				reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(reinterpret_cast<const uint8_t*>(FileInfoBuffer.data()) + EntryOffset);
 
 			std::wstring_view FileName(DirInfo->FileName, DirInfo->FileNameLength / sizeof(wchar_t));
 
@@ -1338,6 +1727,156 @@ CanonicalPath(std::filesystem::path InPath, std::error_code& Ec)
 #endif
 }
 
+bool
+IsFile(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	bool			Result = IsFile(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to test if path '{}' is a file", Path.string()));
+	}
+	return Result;
+}
+
+bool
+IsFile(const std::filesystem::path& Path, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	DWORD Attributes = WinGetFileAttributes(Path, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	if (Attributes == INVALID_FILE_ATTRIBUTES)
+	{
+		return false;
+	}
+	return (Attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
+#else
+	struct stat Stat;
+	int			err = stat(Path.native().c_str(), &Stat);
+	if (err != 0)
+	{
+		int32_t err = errno;
+		if (err == ENOENT)
+		{
+			Ec.clear();
+			return false;
+		}
+	}
+	if (S_ISREG(Stat.st_mode))
+	{
+		return true;
+	}
+	return false;
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+bool
+IsDir(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	bool			Result = IsDir(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to test if path '{}' is a directory", Path.string()));
+	}
+	return Result;
+}
+
+bool
+IsDir(const std::filesystem::path& Path, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	DWORD Attributes = WinGetFileAttributes(Path, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	if (Attributes == INVALID_FILE_ATTRIBUTES)
+	{
+		return false;
+	}
+	return (Attributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY;
+#else
+	struct stat Stat;
+	int			err = stat(Path.native().c_str(), &Stat);
+	if (err != 0)
+	{
+		int32_t err = errno;
+		if (err == ENOENT)
+		{
+			Ec.clear();
+			return false;
+		}
+	}
+	if (S_ISDIR(Stat.st_mode))
+	{
+		return true;
+	}
+	return false;
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+bool
+RemoveFile(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	bool			Success = RemoveFile(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to remove file '{}'", Path.string()));
+	}
+	return Success;
+}
+
+bool
+RemoveFile(const std::filesystem::path& Path, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	return RemoveFileNative(Path, false, Ec);
+#else
+	bool IsDirectory = std::filesystem::is_directory(Path, Ec);
+	if (IsDirectory)
+	{
+		Ec = MakeErrorCode(EPERM);
+		return false;
+	}
+	Ec.clear();
+	return RemoveFileNative(Path, false, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+bool
+RemoveDir(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	bool			Success = RemoveDir(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to remove directory '{}'", Path.string()));
+	}
+	return Success;
+}
+
+bool
+RemoveDir(const std::filesystem::path& Path, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	return RemoveDirNative(Path, Ec);
+#else
+	bool IsFile = std::filesystem::is_regular_file(Path, Ec);
+	if (IsFile)
+	{
+		Ec = MakeErrorCode(EPERM);
+		return false;
+	}
+	Ec.clear();
+	return RemoveDirNative(Path, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
 std::filesystem::path
 PathFromHandle(void* NativeHandle, std::error_code& Ec)
 {
@@ -1435,23 +1974,84 @@ PathFromHandle(void* NativeHandle, std::error_code& Ec)
 }
 
 uint64_t
-FileSizeFromHandle(void* NativeHandle)
+FileSizeFromPath(const std::filesystem::path& Path)
+{
+	std::error_code Ec;
+	uint64_t		Size = FileSizeFromPath(Path, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to get file size for path '{}'", Path.string()));
+	}
+	return Size;
+}
+
+uint64_t
+FileSizeFromPath(const std::filesystem::path& Path, std::error_code& Ec)
 {
-	uint64_t FileSize = ~0ull;
+#if ZEN_PLATFORM_WINDOWS
+	void* Handle = ::CreateFile(Path.native().c_str(),
+								GENERIC_READ,
+								FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+								nullptr,
+								OPEN_EXISTING,
+								0,
+								nullptr);
+	if (Handle == INVALID_HANDLE_VALUE)
+	{
+		DWORD LastError = GetLastError();
+		Ec				= MakeErrorCode(LastError);
+		return 0;
+	}
+	auto		  _ = MakeGuard([Handle]() { CloseHandle(Handle); });
+	LARGE_INTEGER FileSize;
+	BOOL		  Success = GetFileSizeEx(Handle, &FileSize);
+	if (!Success)
+	{
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
+	}
+	return FileSize.QuadPart;
+#else
+	return std::filesystem::file_size(Path, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
 
+uint64_t
+FileSizeFromHandle(void* NativeHandle, std::error_code& Ec)
+{
 #if ZEN_PLATFORM_WINDOWS
 	BY_HANDLE_FILE_INFORMATION Bhfh = {};
 	if (GetFileInformationByHandle(NativeHandle, &Bhfh))
 	{
-		FileSize = uint64_t(Bhfh.nFileSizeHigh) << 32 | Bhfh.nFileSizeLow;
+		return uint64_t(Bhfh.nFileSizeHigh) << 32 | Bhfh.nFileSizeLow;
+	}
+	else
+	{
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
 	}
 #else
-	int			Fd = int(intptr_t(NativeHandle));
+	int Fd = int(intptr_t(NativeHandle));
+	static_assert(sizeof(decltype(stat::st_size)) == sizeof(uint64_t), "fstat() doesn't support large files");
 	struct stat Stat;
-	fstat(Fd, &Stat);
-	FileSize	   = size_t(Stat.st_size);
+	if (fstat(Fd, &Stat) == -1)
+	{
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
+	}
+	return uint64_t(Stat.st_size);
 #endif
+}
 
+uint64_t
+FileSizeFromHandle(void* NativeHandle)
+{
+	std::error_code Ec;
+	uint64_t		FileSize = FileSizeFromHandle(NativeHandle, Ec);
+	if (Ec)
+	{
+		return ~0ull;
+	}
 	return FileSize;
 }
 
@@ -1483,7 +2083,13 @@ GetModificationTickFromPath(const std::filesystem::path& Filename)
 	// PathFromHandle
 	void* Handle;
 #if ZEN_PLATFORM_WINDOWS
-	Handle = CreateFileW(Filename.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, nullptr);
+	Handle = CreateFileW(Filename.c_str(),
+						 GENERIC_READ,
+						 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+						 nullptr,
+						 OPEN_EXISTING,
+						 0,
+						 nullptr);
 	if (Handle == INVALID_HANDLE_VALUE)
 	{
 		ThrowLastError(fmt::format("Failed to open file {} to check modification tick.", Filename));
@@ -1493,7 +2099,7 @@ GetModificationTickFromPath(const std::filesystem::path& Filename)
 	uint64_t		ModificatonTick = GetModificationTickFromHandle(Handle, Ec);
 	if (Ec)
 	{
-		ThrowSystemError(Ec.value(), Ec.message());
+		throw std::system_error(Ec, fmt::format("Failed to get modification tick for path '{}'", Filename.string()));
 	}
 	return ModificatonTick;
 #else
@@ -1507,6 +2113,102 @@ GetModificationTickFromPath(const std::filesystem::path& Filename)
 #endif
 }
 
+bool
+TryGetFileProperties(const std::filesystem::path& Path,
+					 uint64_t&					  OutSize,
+					 uint64_t&					  OutModificationTick,
+					 uint32_t&					  OutNativeModeOrAttributes)
+{
+#if ZEN_PLATFORM_WINDOWS
+	const std::filesystem::path::value_type* NativePath = Path.native().c_str();
+	{
+		void* Handle = CreateFileW(NativePath,
+								   GENERIC_READ,
+								   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+								   nullptr,
+								   OPEN_EXISTING,
+								   0,
+								   nullptr);
+		if (Handle == INVALID_HANDLE_VALUE)
+		{
+			return false;
+		}
+		auto _ = MakeGuard([Handle]() { CloseHandle(Handle); });
+
+		BY_HANDLE_FILE_INFORMATION Bhfh = {};
+		if (!GetFileInformationByHandle(Handle, &Bhfh))
+		{
+			return false;
+		}
+		OutSize					  = uint64_t(Bhfh.nFileSizeHigh) << 32 | Bhfh.nFileSizeLow;
+		OutModificationTick		  = ((uint64_t(Bhfh.ftLastWriteTime.dwHighDateTime) << 32) | Bhfh.ftLastWriteTime.dwLowDateTime);
+		OutNativeModeOrAttributes = Bhfh.dwFileAttributes;
+		return true;
+	}
+#else
+	struct stat Stat;
+	int			err = stat(Path.native().c_str(), &Stat);
+	if (err)
+	{
+		return false;
+	}
+	OutModificationTick		  = gsl::narrow<uint64_t>(Stat.st_mtime);
+	OutSize					  = size_t(Stat.st_size);
+	OutNativeModeOrAttributes = (uint32_t)Stat.st_mode;
+	return true;
+#endif
+}
+
+void
+RenameFile(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath)
+{
+	std::error_code Ec;
+	RenameFile(SourcePath, TargetPath, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to rename path from '{}' to '{}'", SourcePath.string(), TargetPath.string()));
+	}
+}
+
+void
+RenameFile(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	BOOL Success = ::MoveFileEx(SourcePath.native().c_str(), TargetPath.native().c_str(), MOVEFILE_REPLACE_EXISTING);
+	if (!Success)
+	{
+		Ec = MakeErrorCodeFromLastError();
+	}
+#else
+	return std::filesystem::rename(SourcePath, TargetPath, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
+void
+RenameDirectory(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath)
+{
+	std::error_code Ec;
+	RenameDirectory(SourcePath, TargetPath, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to rename directory from '{}' to '{}'", SourcePath.string(), TargetPath.string()));
+	}
+}
+
+void
+RenameDirectory(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath, std::error_code& Ec)
+{
+#if ZEN_PLATFORM_WINDOWS
+	BOOL Success = ::MoveFile(SourcePath.native().c_str(), TargetPath.native().c_str());
+	if (!Success)
+	{
+		Ec = MakeErrorCodeFromLastError();
+	}
+#else
+	return std::filesystem::rename(SourcePath, TargetPath, Ec);
+#endif	// ZEN_PLATFORM_WINDOWS
+}
+
 std::filesystem::path
 GetRunningExecutablePath()
 {
@@ -1570,6 +2272,43 @@ MaximizeOpenFileCount()
 #endif
 }
 
+bool
+PrepareFileForScatteredWrite(void* FileHandle, uint64_t FinalSize)
+{
+	bool Result = true;
+#if ZEN_PLATFORM_WINDOWS
+
+	BY_HANDLE_FILE_INFORMATION Information;
+	if (GetFileInformationByHandle(FileHandle, &Information))
+	{
+		if ((Information.dwFileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) == 0)
+		{
+			DWORD _	 = 0;
+			BOOL  Ok = DeviceIoControl(FileHandle, FSCTL_SET_SPARSE, nullptr, 0, nullptr, 0, &_, nullptr);
+			if (!Ok)
+			{
+				std::error_code DummyEc;
+				ZEN_DEBUG("Unable to set sparse mode for file '{}'", PathFromHandle(FileHandle, DummyEc));
+				Result = false;
+			}
+		}
+	}
+
+	FILE_ALLOCATION_INFO AllocationInfo	   = {};
+	AllocationInfo.AllocationSize.QuadPart = LONGLONG(FinalSize);
+	if (!SetFileInformationByHandle(FileHandle, FileAllocationInfo, &AllocationInfo, DWORD(sizeof(AllocationInfo))))
+	{
+		std::error_code DummyEc;
+		ZEN_DEBUG("Unable to set file allocation size to {} for file '{}'", FinalSize, PathFromHandle(FileHandle, DummyEc));
+		Result = false;
+	}
+
+#else	// ZEN_PLATFORM_WINDOWS
+	ZEN_UNUSED(FileHandle, FinalSize);
+#endif	// ZEN_PLATFORM_WINDOWS
+	return Result;
+}
+
 void
 GetDirectoryContent(const std::filesystem::path& RootDir, DirectoryContentFlags Flags, DirectoryContent& OutContent)
 {
@@ -1706,12 +2445,17 @@ GetDirectoryContent(const std::filesystem::path& RootDir,
 											 RelativeRoot	  = RelativeRoot / DirectoryName]() {
 						ZEN_ASSERT(Visitor);
 						auto _ = MakeGuard([&]() { PendingWorkCount->CountDown(); });
+						try
 						{
 							MultithreadedVisitor SubVisitor(*WorkerPool, *PendingWorkCount, RelativeRoot, Flags, Visitor);
 							FileSystemTraversal	 Traversal;
 							Traversal.TraverseFileSystem(Path, SubVisitor);
 							Visitor->AsyncVisitDirectory(SubVisitor.RelativeRoot, std::move(SubVisitor.Content));
 						}
+						catch (const std::exception& Ex)
+						{
+							ZEN_ERROR("Failed scheduling work to scan subfolder '{}'. Reason: '{}'", Path / RelativeRoot, Ex.what());
+						}
 					});
 				}
 				catch (const std::exception Ex)
@@ -1793,7 +2537,7 @@ RotateFiles(const std::filesystem::path& Filename, std::size_t MaxFiles)
 	};
 
 	auto IsEmpty = [](const std::filesystem::path& Path, std::error_code& Ec) -> bool {
-		bool Exists = std::filesystem::exists(Path, Ec);
+		bool Exists = IsFile(Path, Ec);
 		if (Ec)
 		{
 			return false;
@@ -1802,7 +2546,7 @@ RotateFiles(const std::filesystem::path& Filename, std::size_t MaxFiles)
 		{
 			return true;
 		}
-		uintmax_t Size = std::filesystem::file_size(Path, Ec);
+		uintmax_t Size = FileSizeFromPath(Path, Ec);
 		if (Ec)
 		{
 			return false;
@@ -1821,17 +2565,17 @@ RotateFiles(const std::filesystem::path& Filename, std::size_t MaxFiles)
 		for (auto i = MaxFiles; i > 0; i--)
 		{
 			std::filesystem::path src = GetFileName(i - 1);
-			if (!std::filesystem::exists(src))
+			if (!IsFile(src))
 			{
 				continue;
 			}
 			std::error_code		  DummyEc;
 			std::filesystem::path target = GetFileName(i);
-			if (std::filesystem::exists(target, DummyEc))
+			if (IsFile(target, DummyEc))
 			{
-				std::filesystem::remove(target, DummyEc);
+				RemoveFile(target, DummyEc);
 			}
-			std::filesystem::rename(src, target, DummyEc);
+			RenameFile(src, target, DummyEc);
 		}
 	}
 
@@ -1868,16 +2612,16 @@ RotateDirectories(const std::filesystem::path& DirectoryName, std::size_t MaxDir
 	{
 		const std::filesystem::path SourcePath = GetPathForIndex(i - 1);
 
-		if (std::filesystem::exists(SourcePath))
+		if (IsDir(SourcePath))
 		{
 			std::filesystem::path TargetPath = GetPathForIndex(i);
 
 			std::error_code DummyEc;
-			if (std::filesystem::exists(TargetPath, DummyEc))
+			if (IsDir(TargetPath, DummyEc))
 			{
-				std::filesystem::remove_all(TargetPath, DummyEc);
+				DeleteDirectories(TargetPath, DummyEc);
 			}
-			std::filesystem::rename(SourcePath, TargetPath, DummyEc);
+			RenameDirectory(SourcePath, TargetPath, DummyEc);
 		}
 	}
 
@@ -1936,22 +2680,40 @@ PickDefaultSystemRootDirectory()
 #if ZEN_PLATFORM_WINDOWS
 
 uint32_t
+GetFileAttributes(const std::filesystem::path& Filename, std::error_code& Ec)
+{
+	return WinGetFileAttributes(Filename, Ec);
+}
+
+uint32_t
 GetFileAttributes(const std::filesystem::path& Filename)
 {
-	DWORD Attributes = ::GetFileAttributes(Filename.native().c_str());
-	if (Attributes == INVALID_FILE_ATTRIBUTES)
+	std::error_code Ec;
+	uint32_t		Result = zen::GetFileAttributes(Filename, Ec);
+	if (Ec)
 	{
-		ThrowLastError(fmt::format("failed to get attributes of file {}", Filename));
+		throw std::system_error(Ec, fmt::format("failed to get attributes of file '{}'", Filename.string()));
 	}
-	return (uint32_t)Attributes;
+	return Result;
 }
 
 void
-SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes)
+SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes, std::error_code& Ec)
 {
 	if (::SetFileAttributes(Filename.native().c_str(), Attributes) == 0)
 	{
-		ThrowLastError(fmt::format("failed to set attributes of file {}", Filename));
+		Ec = MakeErrorCodeFromLastError();
+	}
+}
+
+void
+SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes)
+{
+	std::error_code Ec;
+	zen::SetFileAttributes(Filename, Attributes, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("failed to set attributes of file {}", Filename.string()));
 	}
 }
 
@@ -1962,98 +2724,318 @@ SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes)
 uint32_t
 GetFileMode(const std::filesystem::path& Filename)
 {
+	std::error_code Ec;
+	uint32_t		Result = GetFileMode(Filename, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to get mode of file {}", Filename));
+	}
+	return Result;
+}
+
+uint32_t
+GetFileMode(const std::filesystem::path& Filename, std::error_code& Ec)
+{
 	struct stat Stat;
 	int			err = stat(Filename.native().c_str(), &Stat);
 	if (err)
 	{
-		ThrowLastError(fmt::format("Failed to get mode of file {}", Filename));
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
 	}
 	return (uint32_t)Stat.st_mode;
 }
 
 void
-SetFileMode(const std::filesystem::path& Filename, uint32_t Attributes)
+SetFileMode(const std::filesystem::path& Filename, uint32_t Mode)
+{
+	std::error_code Ec;
+	SetFileMode(Filename, Mode, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("Failed to set mode of file {}", Filename));
+	}
+}
+
+void
+SetFileMode(const std::filesystem::path& Filename, uint32_t Mode, std::error_code& Ec)
 {
-	int err = chmod(Filename.native().c_str(), (mode_t)Attributes);
+	int err = chmod(Filename.native().c_str(), (mode_t)Mode);
 	if (err)
 	{
-		ThrowLastError(fmt::format("Failed to set mode of file {}", Filename));
+		Ec = MakeErrorCodeFromLastError();
 	}
 }
 
 #endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 
-#if ZEN_PLATFORM_WINDOWS
-const uint32_t FileAttributesSystemReadOnlyFlag = FILE_ATTRIBUTE_READONLY;
-#else
-const uint32_t FileAttributesSystemReadOnlyFlag = 0x00000001;
-#endif	// ZEN_PLATFORM_WINDOWS
-
-const uint32_t FileModeWriteEnableFlags = 0222;
-
 bool
-IsFileAttributeReadOnly(uint32_t FileAttributes)
+SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly, std::error_code& Ec)
 {
 #if ZEN_PLATFORM_WINDOWS
-	return (FileAttributes & FileAttributesSystemReadOnlyFlag) != 0;
-#else
-	return (FileAttributes & 0x00000001) != 0;
+	uint32_t CurrentAttributes = GetFileAttributes(Filename, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	if (CurrentAttributes == INVALID_FILE_ATTRIBUTES)
+	{
+		Ec = MakeErrorCode(ERROR_FILE_NOT_FOUND);
+		return false;
+	}
+	uint32_t NewAttributes = MakeFileAttributeReadOnly(CurrentAttributes, ReadOnly);
+	if (CurrentAttributes != NewAttributes)
+	{
+		SetFileAttributes(Filename, NewAttributes, Ec);
+		if (Ec)
+		{
+			return false;
+		}
+		return true;
+	}
 #endif	// ZEN_PLATFORM_WINDOWS
+#if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	uint32_t CurrentMode = GetFileMode(Filename, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	uint32_t NewMode = MakeFileModeReadOnly(CurrentMode, ReadOnly);
+	if (CurrentMode != NewMode)
+	{
+		SetFileMode(Filename, NewMode, Ec);
+		if (Ec)
+		{
+			return false;
+		}
+		return true;
+	}
+#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	return false;
 }
 
 bool
-IsFileModeReadOnly(uint32_t FileMode)
-{
-	return (FileMode & FileModeWriteEnableFlags) == 0;
-}
-
-uint32_t
-MakeFileAttributeReadOnly(uint32_t FileAttributes, bool ReadOnly)
+SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly)
 {
-	return ReadOnly ? (FileAttributes | FileAttributesSystemReadOnlyFlag) : (FileAttributes & ~FileAttributesSystemReadOnlyFlag);
+	std::error_code Ec;
+	bool			Result = SetFileReadOnly(Filename, ReadOnly, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("failed to set read only mode of file '{}'", Filename.string()));
+	}
+	return Result;
 }
 
-uint32_t
-MakeFileModeReadOnly(uint32_t FileMode, bool ReadOnly)
+class SharedMemoryImpl : public SharedMemory
 {
-	return ReadOnly ? (FileMode & ~FileModeWriteEnableFlags) : (FileMode | FileModeWriteEnableFlags);
-}
+public:
+	struct Data
+	{
+		void*		Handle	= nullptr;
+		void*		DataPtr = nullptr;
+		size_t		Size	= 0;
+		std::string Name;
+	};
 
-bool
-SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly)
-{
+	static Data Open(std::string_view Name, size_t Size, bool SystemGlobal)
+	{
 #if ZEN_PLATFORM_WINDOWS
-	uint32_t CurrentAttributes = GetFileAttributes(Filename);
-	uint32_t NewAttributes	   = MakeFileAttributeReadOnly(CurrentAttributes, ReadOnly);
-	if (CurrentAttributes != NewAttributes)
+		std::wstring InstanceMapName = Utf8ToWide(fmt::format("{}\\{}", SystemGlobal ? "Global" : "Local", Name));
+
+		HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, InstanceMapName.c_str());
+		if (hMap == NULL)
+		{
+			return {};
+		}
+		void* pBuf = MapViewOfFile(hMap,				 // handle to map object
+								   FILE_MAP_ALL_ACCESS,	 // read/write permission
+								   0,					 // offset high
+								   0,					 // offset low
+								   DWORD(Size));		 // size
+
+		if (pBuf == NULL)
+		{
+			CloseHandle(hMap);
+		}
+		return Data{.Handle = hMap, .DataPtr = pBuf, .Size = Size, .Name = std::string(Name)};
+#endif	// ZEN_PLATFORM_WINDOWS
+#if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+		ZEN_UNUSED(SystemGlobal);
+		std::string InstanceMapName = fmt::format("/{}", Name);
+
+		int Fd = shm_open(InstanceMapName.c_str(), O_RDWR, 0666);
+		if (Fd < 0)
+		{
+			return {};
+		}
+		void* hMap = (void*)intptr_t(Fd);
+
+		struct stat Stat;
+		fstat(Fd, &Stat);
+
+		if (size_t(Stat.st_size) < Size)
+		{
+			close(Fd);
+			return {};
+		}
+
+		void* pBuf = mmap(nullptr, Size, PROT_READ | PROT_WRITE, MAP_SHARED, Fd, 0);
+		if (pBuf == MAP_FAILED)
+		{
+			close(Fd);
+			return {};
+		}
+		return Data{.Handle = hMap, .DataPtr = pBuf, .Size = Size, .Name = std::string(Name)};
+#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	}
+
+	static Data Create(std::string_view Name, size_t Size, bool SystemGlobal)
 	{
-		SetFileAttributes(Filename, NewAttributes);
-		return true;
+#if ZEN_PLATFORM_WINDOWS
+		std::wstring InstanceMapName = Utf8ToWide(fmt::format("{}\\{}", SystemGlobal ? "Global" : "Local", Name));
+
+		SECURITY_ATTRIBUTES m_Attributes{};
+		SECURITY_DESCRIPTOR m_Sd{};
+
+		m_Attributes.nLength		= sizeof m_Attributes;
+		m_Attributes.bInheritHandle = false;  // Disable inheritance
+
+		const BOOL Success = InitializeSecurityDescriptor(&m_Sd, SECURITY_DESCRIPTOR_REVISION);
+
+		if (Success)
+		{
+			if (!SetSecurityDescriptorDacl(&m_Sd, TRUE, (PACL)NULL, FALSE))
+			{
+				ThrowLastError("SetSecurityDescriptorDacl failed");
+			}
+
+			m_Attributes.lpSecurityDescriptor = &m_Sd;
+		}
+
+		HANDLE hMap = CreateFileMapping(INVALID_HANDLE_VALUE,  // use paging file
+										&m_Attributes,		   // allow anyone to access
+										PAGE_READWRITE,		   // read/write access
+										0,					   // maximum object size (high-order DWORD)
+										DWORD(Size),		   // maximum object size (low-order DWORD)
+										InstanceMapName.c_str());
+		if (hMap == NULL)
+		{
+			return {};
+		}
+		void* pBuf = MapViewOfFile(hMap,				 // handle to map object
+								   FILE_MAP_ALL_ACCESS,	 // read/write permission
+								   0,					 // offset high
+								   0,					 // offset low
+								   DWORD(Size));		 // size
+
+		if (pBuf == NULL)
+		{
+			CloseHandle(hMap);
+			return {};
+		}
+		return Data{.Handle = hMap, .DataPtr = pBuf, .Size = Size, .Name = std::string(Name)};
+#endif	// ZEN_PLATFORM_WINDOWS
+#if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+		ZEN_UNUSED(SystemGlobal);
+		std::string InstanceMapName = fmt::format("/{}", Name);
+
+		int Fd = shm_open(InstanceMapName.c_str(), O_RDWR | O_CREAT | O_CLOEXEC, 0666);
+		if (Fd < 0)
+		{
+			return {};
+		}
+		fchmod(Fd, 0666);
+		void* hMap = (void*)intptr_t(Fd);
+
+		int Result = ftruncate(Fd, Size);
+		ZEN_UNUSED(Result);
+
+		void* pBuf = mmap(nullptr, Size, PROT_READ | PROT_WRITE, MAP_SHARED, Fd, 0);
+		if (pBuf == MAP_FAILED)
+		{
+			close(Fd);
+			return {};
+		}
+		return Data{.Handle = hMap, .DataPtr = pBuf, .Size = Size, .Name = std::string(Name)};
+#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 	}
+
+	static void Close(Data&& MemMap, bool Delete)
+	{
+#if ZEN_PLATFORM_WINDOWS
+		ZEN_UNUSED(Delete);
+		if (MemMap.DataPtr != nullptr)
+		{
+			UnmapViewOfFile(MemMap.DataPtr);
+			MemMap.DataPtr = nullptr;
+		}
+		if (MemMap.Handle != nullptr)
+		{
+			CloseHandle(MemMap.Handle);
+			MemMap.Handle = nullptr;
+		}
 #endif	// ZEN_PLATFORM_WINDOWS
 #if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
-	uint32_t CurrentMode = GetFileMode(Filename);
-	uint32_t NewMode	 = MakeFileModeReadOnly(CurrentMode, ReadOnly);
-	if (CurrentMode != NewMode)
+		if (MemMap.DataPtr != nullptr)
+		{
+			munmap(MemMap.DataPtr, MemMap.Size);
+			MemMap.DataPtr = nullptr;
+		}
+
+		if (MemMap.Handle != nullptr)
+		{
+			int Fd = int(intptr_t(MemMap.Handle));
+			close(Fd);
+			MemMap.Handle = nullptr;
+		}
+		if (Delete)
+		{
+			std::string InstanceMapName = fmt::format("/{}", MemMap.Name);
+			shm_unlink(InstanceMapName.c_str());
+		}
+#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
+	}
+
+	SharedMemoryImpl(Data&& MemMap, bool IsOwned) : m_MemMap(std::move(MemMap)), m_IsOwned(IsOwned) {}
+	virtual ~SharedMemoryImpl()
 	{
-		SetFileMode(Filename, NewMode);
-		return true;
+		try
+		{
+			Close(std::move(m_MemMap), /*Delete*/ m_IsOwned);
+		}
+		catch (const std::exception& Ex)
+		{
+			ZEN_ERROR("SharedMemoryImpl::~SharedMemoryImpl threw exception: {}", Ex.what());
+		}
 	}
-#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
-	return false;
-}
 
-std::filesystem::path
-StringToPath(const std::string_view& Path)
+	virtual void* GetData() override { return m_MemMap.DataPtr; }
+
+private:
+	Data	   m_MemMap;
+	const bool m_IsOwned = false;
+};
+
+std::unique_ptr<SharedMemory>
+OpenSharedMemory(std::string_view Name, size_t Size, bool SystemGlobal)
 {
-	if (Path.length() > 2 && Path.front() == '\"' && Path.back() == '\"')
+	SharedMemoryImpl::Data MemMap = SharedMemoryImpl::Open(Name, Size, SystemGlobal);
+	if (MemMap.DataPtr)
 	{
-		return std::filesystem::path(Path.substr(1, Path.length() - 2)).make_preferred();
+		return std::make_unique<SharedMemoryImpl>(std::move(MemMap), /*IsOwned*/ false);
 	}
-	else
+	return {};
+}
+
+std::unique_ptr<SharedMemory>
+CreateSharedMemory(std::string_view Name, size_t Size, bool SystemGlobal)
+{
+	SharedMemoryImpl::Data MemMap = SharedMemoryImpl::Create(Name, Size, SystemGlobal);
+	if (MemMap.DataPtr)
 	{
-		return std::filesystem::path(Path).make_preferred();
+		return std::make_unique<SharedMemoryImpl>(std::move(MemMap), /*IsOwned*/ true);
 	}
+	return {};
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -2076,7 +3058,7 @@ TEST_CASE("filesystem")
 	path	   BinPath	   = GetRunningExecutablePath();
 	const bool ExpectedExe = PathToUtf8(BinPath.stem().native()).ends_with("-test"sv) || BinPath.stem() == "zenserver";
 	CHECK(ExpectedExe);
-	CHECK(is_regular_file(BinPath));
+	CHECK(IsFile(BinPath));
 
 	// PathFromHandle
 	void* Handle;
@@ -2129,6 +3111,80 @@ TEST_CASE("filesystem")
 	CHECK_EQ(BinScan.size(), BinRead.Data[0].GetSize());
 }
 
+TEST_CASE("Filesystem.Basics")
+{
+	std::filesystem::path TestBaseDir = GetRunningExecutablePath().parent_path() / ".test";
+	CleanDirectory(TestBaseDir, true);
+	DeleteDirectories(TestBaseDir);
+	CHECK(!IsDir(TestBaseDir));
+	CHECK(CleanDirectory(TestBaseDir, false));
+	CHECK(IsDir(TestBaseDir));
+	CHECK(!CleanDirectory(TestBaseDir, false));
+	CHECK(!IsDir(TestBaseDir / "no_such_thing"));
+	CHECK(!IsDir("hgjda/cev_/q12"));
+	CHECK(!IsFile(TestBaseDir));
+	CHECK(!IsFile(TestBaseDir / "no_such_thing"));
+	CHECK(!IsFile("hgjda/cev_/q12"));
+	CHECK_THROWS(FileSizeFromPath(TestBaseDir) == 0);
+	CHECK_THROWS(FileSizeFromPath(TestBaseDir / "no_such_file"));
+	CHECK(!CreateDirectories(TestBaseDir));
+	CHECK(CreateDirectories(TestBaseDir / "nested" / "a" / "bit" / "deep"));
+	CHECK(!CreateDirectories(TestBaseDir / "nested" / "a" / "bit" / "deep"));
+	CHECK(IsDir(TestBaseDir / "nested" / "a" / "bit" / "deep"));
+	CHECK(IsDir(TestBaseDir / "nested" / "a" / "bit"));
+	CHECK(!IsDir(TestBaseDir / "nested" / "a" / "bit" / "deep" / "no"));
+	CHECK_THROWS(WriteFile(TestBaseDir / "nested" / "a", IoBuffer(20)));
+	CHECK_NOTHROW(WriteFile(TestBaseDir / "nested" / "a" / "yo", IoBuffer(20)));
+	CHECK(IsFile(TestBaseDir / "nested" / "a" / "yo"));
+	CHECK(FileSizeFromPath(TestBaseDir / "nested" / "a" / "yo") == 20);
+	CHECK(!IsFile(TestBaseDir / "nested" / "a"));
+	CHECK(DeleteDirectories(TestBaseDir / "nested" / "a" / "bit"));
+	CHECK(IsFile(TestBaseDir / "nested" / "a" / "yo"));
+	CHECK(!IsDir(TestBaseDir / "nested" / "a" / "bit"));
+	CHECK(!DeleteDirectories(TestBaseDir / "nested" / "a" / "bit"));
+	CHECK(IsDir(TestBaseDir / "nested" / "a"));
+	CHECK(DeleteDirectories(TestBaseDir / "nested"));
+	CHECK(!IsFile(TestBaseDir / "nested" / "a" / "yo"));
+	CHECK(CreateDirectories(TestBaseDir / "nested" / "deeper"));
+	CHECK_NOTHROW(WriteFile(TestBaseDir / "nested" / "deeper" / "yo", IoBuffer(20)));
+	CHECK_NOTHROW(RenameDirectory(TestBaseDir / "nested" / "deeper", TestBaseDir / "new_place"));
+	CHECK(IsFile(TestBaseDir / "new_place" / "yo"));
+	CHECK(FileSizeFromPath(TestBaseDir / "new_place" / "yo") == 20);
+	CHECK(IsDir(TestBaseDir / "new_place"));
+	CHECK(!IsFile(TestBaseDir / "new_place"));
+	CHECK_THROWS(RenameDirectory(TestBaseDir / "nested" / "deeper", TestBaseDir / "new_place"));
+	CHECK(!RemoveDir(TestBaseDir / "nested" / "deeper"));
+	CHECK(RemoveFile(TestBaseDir / "new_place" / "yo"));
+	CHECK(!IsFile(TestBaseDir / "new_place" / "yo"));
+	CHECK_THROWS(FileSizeFromPath(TestBaseDir / "new_place" / "yo"));
+	CHECK(!RemoveFile(TestBaseDir / "new_place" / "yo"));
+	CHECK_THROWS(RemoveFile(TestBaseDir / "nested"));
+	CHECK_THROWS(RemoveDir(TestBaseDir));
+	CHECK_NOTHROW(WriteFile(TestBaseDir / "yo", IoBuffer(20)));
+	CHECK_NOTHROW(RenameFile(TestBaseDir / "yo", TestBaseDir / "new_place" / "yo"));
+	CHECK(!IsFile(TestBaseDir / "yo"));
+	CHECK(IsFile(TestBaseDir / "new_place" / "yo"));
+	CHECK(FileSizeFromPath(TestBaseDir / "new_place" / "yo") == 20);
+	CHECK_THROWS(RemoveDir(TestBaseDir / "new_place" / "yo"));
+	CHECK(DeleteDirectories(TestBaseDir));
+	CHECK(!IsFile(TestBaseDir / "new_place" / "yo"));
+	CHECK(!IsDir(TestBaseDir));
+	CHECK(!IsDir(TestBaseDir / "nested"));
+	CHECK(CreateDirectories(TestBaseDir / "nested"));
+	CHECK_NOTHROW(WriteFile(TestBaseDir / "nested" / "readonly", IoBuffer(20)));
+	CHECK(SetFileReadOnly(TestBaseDir / "nested" / "readonly", true));
+	CHECK_THROWS(RemoveFile(TestBaseDir / "nested" / "readonly"));
+	CHECK_THROWS(CleanDirectory(TestBaseDir, false));
+	CHECK(SetFileReadOnly(TestBaseDir / "nested" / "readonly", false));
+	CHECK(RemoveFile(TestBaseDir / "nested" / "readonly"));
+	CHECK(!CleanDirectory(TestBaseDir, false));
+	CHECK_NOTHROW(WriteFile(TestBaseDir / "nested" / "readonly", IoBuffer(20)));
+	CHECK(SetFileReadOnly(TestBaseDir / "nested" / "readonly", true));
+	CHECK(!CleanDirectory(TestBaseDir / "nested", true));
+	CHECK(!CleanDirectory(TestBaseDir, false));
+	CHECK(RemoveDir(TestBaseDir));
+}
+
 TEST_CASE("WriteFile")
 {
 	std::filesystem::path TempFile = GetRunningExecutablePath().parent_path();
@@ -2163,7 +3219,7 @@ TEST_CASE("WriteFile")
 		CHECK_EQ(memcmp(MagicTest.Data, MagicsReadback.Data[0].Data(), MagicTest.Size), 0);
 	}
 
-	std::filesystem::remove(TempFile);
+	RemoveFile(TempFile);
 }
 
 TEST_CASE("DiskSpaceInfo")
@@ -2220,7 +3276,7 @@ TEST_CASE("PathBuilder")
 TEST_CASE("RotateDirectories")
 {
 	std::filesystem::path TestBaseDir = GetRunningExecutablePath().parent_path() / ".test";
-	CleanDirectory(TestBaseDir);
+	CleanDirectory(TestBaseDir, false);
 	std::filesystem::path RotateDir		= TestBaseDir / "rotate_dir" / "dir_to_rotate";
 	IoBuffer			  DummyFileData = IoBufferBuilder::MakeCloneFromMemory("blubb", 5);
 
@@ -2234,16 +3290,16 @@ TEST_CASE("RotateDirectories")
 	const int RotateMax = 10;
 
 	NewDir();
-	CHECK(std::filesystem::exists(RotateDir));
+	CHECK(IsDir(RotateDir));
 	RotateDirectories(RotateDir, RotateMax);
-	CHECK(!std::filesystem::exists(RotateDir));
-	CHECK(std::filesystem::exists(DirWithSuffix(1)));
+	CHECK(!IsDir(RotateDir));
+	CHECK(IsDir(DirWithSuffix(1)));
 	NewDir();
-	CHECK(std::filesystem::exists(RotateDir));
+	CHECK(IsDir(RotateDir));
 	RotateDirectories(RotateDir, RotateMax);
-	CHECK(!std::filesystem::exists(RotateDir));
-	CHECK(std::filesystem::exists(DirWithSuffix(1)));
-	CHECK(std::filesystem::exists(DirWithSuffix(2)));
+	CHECK(!IsDir(RotateDir));
+	CHECK(IsDir(DirWithSuffix(1)));
+	CHECK(IsDir(DirWithSuffix(2)));
 
 	for (int i = 0; i < RotateMax; ++i)
 	{
@@ -2253,19 +3309,35 @@ TEST_CASE("RotateDirectories")
 		CHECK_EQ(IsError, false);
 	}
 
-	CHECK(!std::filesystem::exists(RotateDir));
+	CHECK(!IsDir(RotateDir));
 
 	for (int i = 0; i < RotateMax; ++i)
 	{
-		CHECK(std::filesystem::exists(DirWithSuffix(i + 1)));
+		CHECK(IsDir(DirWithSuffix(i + 1)));
 	}
 
 	for (int i = RotateMax; i < RotateMax + 5; ++i)
 	{
-		CHECK(!std::filesystem::exists(DirWithSuffix(RotateMax + i + 1)));
+		CHECK(!IsDir(DirWithSuffix(RotateMax + i + 1)));
 	}
 }
 
+TEST_CASE("SharedMemory")
+{
+	CHECK(!OpenSharedMemory("SharedMemoryTest0", 482, false));
+	CHECK(!OpenSharedMemory("SharedMemoryTest0", 482, true));
+
+	{
+		auto Mem0 = CreateSharedMemory("SharedMemoryTest0", 482, false);
+		CHECK(Mem0);
+		strcpy((char*)Mem0->GetData(), "this is the string we are looking for");
+		auto Mem1 = OpenSharedMemory("SharedMemoryTest0", 482, false);
+		CHECK_EQ(std::string((char*)Mem0->GetData()), std::string((char*)Mem1->GetData()));
+	}
+
+	CHECK(!OpenSharedMemory("SharedMemoryTest0", 482, false));
+}
+
 #endif
 
 }  // namespace zen
diff --git a/src/zencore/include/zencore/basicfile.h b/src/zencore/include/zencore/basicfile.h
index 57798b6f4..465499d2b 100644
--- a/src/zencore/include/zencore/basicfile.h
+++ b/src/zencore/include/zencore/basicfile.h
@@ -174,9 +174,11 @@ public:
 	BasicFileWriter(BasicFile& Base, uint64_t BufferSize);
 	~BasicFileWriter();
 
-	void Write(const void* Data, uint64_t Size, uint64_t FileOffset);
-	void Write(const CompositeBuffer& Data, uint64_t FileOffset);
-	void Flush();
+	void	 Write(const void* Data, uint64_t Size, uint64_t FileOffset);
+	void	 Write(const CompositeBuffer& Data, uint64_t FileOffset);
+	void	 AddPadding(uint64_t Padding);
+	uint64_t AlignTo(uint64_t Alignment);
+	void	 Flush();
 
 private:
 	BasicFile&	   m_Base;
diff --git a/src/zencore/include/zencore/blake3.h b/src/zencore/include/zencore/blake3.h
index 28bb348c0..f01e45266 100644
--- a/src/zencore/include/zencore/blake3.h
+++ b/src/zencore/include/zencore/blake3.h
@@ -53,6 +53,7 @@ struct BLAKE3Stream
 	void		  Reset();									   // Begin streaming hash compute (not needed on freshly constructed instance)
 	BLAKE3Stream& Append(const void* data, size_t byteCount);  // Append another chunk
 	BLAKE3Stream& Append(MemoryView DataView) { return Append(DataView.GetData(), DataView.GetSize()); }  // Append another chunk
+	BLAKE3Stream& Append(const IoBuffer& Buffer);														  // Append another chunk
 	BLAKE3		  GetHash();  // Obtain final hash. If you wish to reuse the instance call reset()
 
 private:
diff --git a/src/zencore/include/zencore/compactbinaryfmt.h b/src/zencore/include/zencore/compactbinaryfmt.h
index ae0c3eb42..b03683db4 100644
--- a/src/zencore/include/zencore/compactbinaryfmt.h
+++ b/src/zencore/include/zencore/compactbinaryfmt.h
@@ -14,7 +14,8 @@ template<typename T>
 requires DerivedFrom<T, zen::CbObjectView>
 struct fmt::formatter<T> : fmt::formatter<std::string_view>
 {
-	auto format(const zen::CbObject& a, format_context& ctx) const
+	template<typename FormatContext>
+	auto format(const zen::CbObject& a, FormatContext& ctx) const
 	{
 		zen::ExtendableStringBuilder<1024> ObjStr;
 		zen::CompactBinaryToJson(a, ObjStr);
diff --git a/src/zencore/include/zencore/compress.h b/src/zencore/include/zencore/compress.h
index 74fd5f767..09fa6249d 100644
--- a/src/zencore/include/zencore/compress.h
+++ b/src/zencore/include/zencore/compress.h
@@ -74,11 +74,12 @@ public:
 															   OodleCompressor		 Compressor		  = OodleCompressor::Mermaid,
 															   OodleCompressionLevel CompressionLevel = OodleCompressionLevel::VeryFast,
 															   uint64_t				 BlockSize		  = 0);
-	[[nodiscard]] ZENCORE_API static bool			  CompressToStream(const CompositeBuffer&												RawData,
-																	   std::function<void(uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
-																	   OodleCompressor		 Compressor		  = OodleCompressor::Mermaid,
-																	   OodleCompressionLevel CompressionLevel = OodleCompressionLevel::VeryFast,
-																	   uint64_t				 BlockSize		  = 0);
+	[[nodiscard]] ZENCORE_API static bool			  CompressToStream(
+					const CompositeBuffer&																							 RawData,
+					std::function<void(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback,
+					OodleCompressor		  Compressor	   = OodleCompressor::Mermaid,
+					OodleCompressionLevel CompressionLevel = OodleCompressionLevel::VeryFast,
+					uint64_t			  BlockSize		   = 0);
 
 	/**
 	 * Construct from a compressed buffer previously created by Compress().
@@ -207,9 +208,10 @@ public:
 	 *
 	 * @return True if the buffer is valid and can be decompressed.
 	 */
-	[[nodiscard]] ZENCORE_API bool DecompressToStream(uint64_t															   RawOffset,
-													  uint64_t															   RawSize,
-													  std::function<bool(uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const;
+	[[nodiscard]] ZENCORE_API bool DecompressToStream(
+		uint64_t																										 RawOffset,
+		uint64_t																										 RawSize,
+		std::function<bool(uint64_t SourceOffset, uint64_t SourceSize, uint64_t Offset, const CompositeBuffer& Range)>&& Callback) const;
 
 	/** A null compressed buffer. */
 	static const CompressedBuffer Null;
diff --git a/src/zencore/include/zencore/filesystem.h b/src/zencore/include/zencore/filesystem.h
index 9a2b15d1d..36d4d1b68 100644
--- a/src/zencore/include/zencore/filesystem.h
+++ b/src/zencore/include/zencore/filesystem.h
@@ -20,21 +20,35 @@ class WorkerThreadPool;
 
 /** Delete directory (after deleting any contents)
  */
-ZENCORE_API bool DeleteDirectories(const std::filesystem::path& dir);
+ZENCORE_API bool DeleteDirectories(const std::filesystem::path& Path);
+
+/** Delete directory (after deleting any contents)
+ */
+ZENCORE_API bool DeleteDirectories(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Ensure directory exists.
+
+	Will also create any required parent direCleanDirectoryctories
+ */
+ZENCORE_API bool CreateDirectories(const std::filesystem::path& Path);
 
 /** Ensure directory exists.
 
 	Will also create any required parent directories
  */
-ZENCORE_API bool CreateDirectories(const std::filesystem::path& dir);
+ZENCORE_API bool CreateDirectories(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Ensure directory exists and delete contents (if any) before returning
+ */
+ZENCORE_API bool CleanDirectory(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles);
 
 /** Ensure directory exists and delete contents (if any) before returning
  */
-ZENCORE_API bool CleanDirectory(const std::filesystem::path& dir);
+ZENCORE_API bool CleanDirectory(const std::filesystem::path& Path, bool ForceRemoveReadOnlyFiles, std::error_code& Ec);
 
 /** Ensure directory exists and delete contents (if any) before returning
  */
-ZENCORE_API bool CleanDirectoryExceptDotFiles(const std::filesystem::path& dir);
+ZENCORE_API bool CleanDirectoryExceptDotFiles(const std::filesystem::path& Path);
 
 /** Map native file handle to a path
  */
@@ -44,10 +58,54 @@ ZENCORE_API std::filesystem::path PathFromHandle(void* NativeHandle, std::error_
  */
 ZENCORE_API std::filesystem::path CanonicalPath(std::filesystem::path InPath, std::error_code& Ec);
 
+/** Query file size
+ */
+ZENCORE_API bool IsFile(const std::filesystem::path& Path);
+
+/** Query file size
+ */
+ZENCORE_API bool IsFile(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Query file size
+ */
+ZENCORE_API bool IsDir(const std::filesystem::path& Path);
+
+/** Query file size
+ */
+ZENCORE_API bool IsDir(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Query file size
+ */
+ZENCORE_API bool RemoveFile(const std::filesystem::path& Path);
+
+/** Query file size
+ */
+ZENCORE_API bool RemoveFile(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Query file size
+ */
+ZENCORE_API bool RemoveDir(const std::filesystem::path& Path);
+
+/** Query file size
+ */
+ZENCORE_API bool RemoveDir(const std::filesystem::path& Path, std::error_code& Ec);
+
+/** Query file size
+ */
+ZENCORE_API uint64_t FileSizeFromPath(const std::filesystem::path& Path);
+
+/** Query file size
+ */
+ZENCORE_API uint64_t FileSizeFromPath(const std::filesystem::path& Path, std::error_code& Ec);
+
 /** Query file size from native file handle
  */
 ZENCORE_API uint64_t FileSizeFromHandle(void* NativeHandle);
 
+/** Query file size from native file handle
+ */
+ZENCORE_API uint64_t FileSizeFromHandle(void* NativeHandle, std::error_code& Ec);
+
 /** Get a native time tick of last modification time
  */
 ZENCORE_API uint64_t GetModificationTickFromHandle(void* NativeHandle, std::error_code& Ec);
@@ -56,12 +114,35 @@ ZENCORE_API uint64_t GetModificationTickFromHandle(void* NativeHandle, std::erro
  */
 ZENCORE_API uint64_t GetModificationTickFromPath(const std::filesystem::path& Filename);
 
+ZENCORE_API bool TryGetFileProperties(const std::filesystem::path& Path,
+									  uint64_t&					   OutSize,
+									  uint64_t&					   OutModificationTick,
+									  uint32_t&					   OutNativeModeOrAttributes);
+
+/** Move a file, if the files are not on the same drive the function will fail
+ */
+ZENCORE_API void RenameFile(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath);
+
+/** Move a file, if the files are not on the same drive the function will fail
+ */
+ZENCORE_API void RenameFile(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath, std::error_code& Ec);
+
+/** Move a directory, if the files are not on the same drive the function will fail
+ */
+ZENCORE_API void RenameDirectory(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath);
+
+/** Move a directory, if the files are not on the same drive the function will fail
+ */
+ZENCORE_API void RenameDirectory(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath, std::error_code& Ec);
+
 ZENCORE_API std::filesystem::path GetRunningExecutablePath();
 
 /** Set the max open file handle count to max allowed for the current process on Linux and MacOS
  */
 ZENCORE_API void MaximizeOpenFileCount();
 
+ZENCORE_API bool PrepareFileForScatteredWrite(void* FileHandle, uint64_t FinalSize);
+
 struct FileContents
 {
 	std::vector<IoBuffer> Data;
@@ -90,6 +171,13 @@ ZENCORE_API void ScanFile(void*												   NativeHandle,
 						  uint64_t											   Size,
 						  uint64_t											   ChunkSize,
 						  std::function<void(const void* Data, size_t Size)>&& ProcessFunc);
+ZENCORE_API void WriteFile(void*			NativeHandle,
+						   const void*		Data,
+						   uint64_t			Size,
+						   uint64_t			FileOffset,
+						   uint64_t			ChunkSize,
+						   std::error_code& Ec);
+ZENCORE_API void ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uint64_t ChunkSize, std::error_code& Ec);
 
 struct CopyFileOptions
 {
@@ -277,12 +365,16 @@ std::filesystem::path PickDefaultSystemRootDirectory();
 
 #if ZEN_PLATFORM_WINDOWS
 uint32_t GetFileAttributes(const std::filesystem::path& Filename);
+uint32_t GetFileAttributes(const std::filesystem::path& Filename, std::error_code& Ec);
 void	 SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes);
+void	 SetFileAttributes(const std::filesystem::path& Filename, uint32_t Attributes, std::error_code& Ec);
 #endif	// ZEN_PLATFORM_WINDOWS
 
 #if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 uint32_t GetFileMode(const std::filesystem::path& Filename);
-void	 SetFileMode(const std::filesystem::path& Filename, uint32_t Attributes);
+uint32_t GetFileMode(const std::filesystem::path& Filename, std::error_code& Ec);
+void	 SetFileMode(const std::filesystem::path& Filename, uint32_t Mode);
+void	 SetFileMode(const std::filesystem::path& Filename, uint32_t Mode, std::error_code& Ec);
 #endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 
 bool	 IsFileAttributeReadOnly(uint32_t FileAttributes);
@@ -290,9 +382,18 @@ bool	 IsFileModeReadOnly(uint32_t FileMode);
 uint32_t MakeFileAttributeReadOnly(uint32_t FileAttributes, bool ReadOnly);
 uint32_t MakeFileModeReadOnly(uint32_t FileMode, bool ReadOnly);
 
+bool SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly, std::error_code& Ec);
 bool SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly);
 
-std::filesystem::path StringToPath(const std::string_view& Path);
+class SharedMemory
+{
+public:
+	virtual ~SharedMemory() {}
+	virtual void* GetData() = 0;
+};
+
+std::unique_ptr<SharedMemory> OpenSharedMemory(std::string_view Name, size_t Size, bool SystemGlobal);
+std::unique_ptr<SharedMemory> CreateSharedMemory(std::string_view Name, size_t Size, bool SystemGlobal);
 
 //////////////////////////////////////////////////////////////////////////
 
diff --git a/src/zencore/include/zencore/fmtutils.h b/src/zencore/include/zencore/fmtutils.h
index 8482157fb..404e570fd 100644
--- a/src/zencore/include/zencore/fmtutils.h
+++ b/src/zencore/include/zencore/fmtutils.h
@@ -12,6 +12,7 @@ ZEN_THIRD_PARTY_INCLUDES_START
 #include <fmt/format.h>
 ZEN_THIRD_PARTY_INCLUDES_END
 
+#include <chrono>
 #include <string_view>
 
 // Custom formatting for some zencore types
@@ -20,7 +21,8 @@ template<typename T>
 requires DerivedFrom<T, zen::StringBuilderBase>
 struct fmt::formatter<T> : fmt::formatter<std::string_view>
 {
-	auto format(const zen::StringBuilderBase& a, format_context& ctx) const
+	template<typename FormatContext>
+	auto format(const zen::StringBuilderBase& a, FormatContext& ctx) const
 	{
 		return fmt::formatter<std::string_view>::format(a.ToView(), ctx);
 	}
@@ -30,7 +32,8 @@ template<typename T>
 requires DerivedFrom<T, zen::NiceBase>
 struct fmt::formatter<T> : fmt::formatter<std::string_view>
 {
-	auto format(const zen::NiceBase& a, format_context& ctx) const
+	template<typename FormatContext>
+	auto format(const zen::NiceBase& a, FormatContext& ctx) const
 	{
 		return fmt::formatter<std::string_view>::format(std::string_view(a), ctx);
 	}
@@ -97,8 +100,22 @@ template<typename T>
 requires DerivedFrom<T, zen::PathBuilderBase>
 struct fmt::formatter<T> : fmt::formatter<std::string_view>
 {
-	auto format(const zen::PathBuilderBase& a, format_context& ctx) const
+	template<typename FormatContext>
+	auto format(const zen::PathBuilderBase& a, FormatContext& ctx) const
 	{
 		return fmt::formatter<std::string_view>::format(a.ToView(), ctx);
 	}
 };
+
+template<>
+struct fmt::formatter<std::chrono::system_clock::time_point> : formatter<string_view>
+{
+	template<typename FormatContext>
+	auto format(const std::chrono::system_clock::time_point& TimePoint, FormatContext& ctx) const
+	{
+		std::time_t Time = std::chrono::system_clock::to_time_t(TimePoint);
+		char		TimeString[std::size("yyyy-mm-ddThh:mm:ss")];
+		std::strftime(std::data(TimeString), std::size(TimeString), "%FT%T", std::localtime(&Time));
+		return fmt::format_to(ctx.out(), "{}", TimeString);
+	}
+};
diff --git a/src/zencore/include/zencore/iohash.h b/src/zencore/include/zencore/iohash.h
index 7443e17b7..a619b0053 100644
--- a/src/zencore/include/zencore/iohash.h
+++ b/src/zencore/include/zencore/iohash.h
@@ -102,6 +102,12 @@ struct IoHashStream
 		return *this;
 	}
 
+	IoHashStream& Append(const IoBuffer& Buffer)
+	{
+		m_Blake3Stream.Append(Buffer);
+		return *this;
+	}
+
 	/// Append another chunk
 	IoHashStream& Append(MemoryView Data)
 	{
diff --git a/src/zencore/include/zencore/process.h b/src/zencore/include/zencore/process.h
index 335e3d909..98d352db6 100644
--- a/src/zencore/include/zencore/process.h
+++ b/src/zencore/include/zencore/process.h
@@ -99,10 +99,7 @@ ZENCORE_API int	 GetCurrentProcessId();
 int				 GetProcessId(CreateProcResult ProcId);
 
 std::filesystem::path GetProcessExecutablePath(int Pid, std::error_code& OutEc);
-std::error_code		  FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle);
-
-std::vector<std::string> ParseCommandLine(std::string_view CommandLine);
-std::vector<char*>		 StripCommandlineQuotes(std::vector<std::string>& InOutArgs);
+std::error_code		  FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle, bool IncludeSelf = true);
 
 #if ZEN_PLATFORM_LINUX
 void IgnoreChildSignals();
diff --git a/src/zencore/include/zencore/sentryintegration.h b/src/zencore/include/zencore/sentryintegration.h
new file mode 100644
index 000000000..faf1238b7
--- /dev/null
+++ b/src/zencore/include/zencore/sentryintegration.h
@@ -0,0 +1,60 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/intmath.h>
+#include <zencore/zencore.h>
+
+#if !defined(ZEN_USE_SENTRY)
+#	define ZEN_USE_SENTRY 1
+#endif
+
+#if ZEN_USE_SENTRY
+
+#	include <memory>
+
+ZEN_THIRD_PARTY_INCLUDES_START
+#	include <spdlog/logger.h>
+ZEN_THIRD_PARTY_INCLUDES_END
+
+namespace sentry {
+
+struct SentryAssertImpl;
+
+}  // namespace sentry
+
+namespace zen {
+
+class SentryIntegration
+{
+public:
+	SentryIntegration();
+	~SentryIntegration();
+
+	struct Config
+	{
+		std::string DatabasePath;
+		std::string AttachmentsPath;
+		std::string Dsn;
+		std::string Environment;
+		bool		AllowPII = false;
+		bool		Debug	 = false;
+	};
+
+	void		Initialize(const Config& Conf, const std::string& CommandLine);
+	void		LogStartupInformation();
+	static void ClearCaches();
+
+private:
+	int										  m_SentryErrorCode = 0;
+	bool									  m_IsInitialized	= false;
+	bool									  m_AllowPII		= false;
+	std::unique_ptr<sentry::SentryAssertImpl> m_SentryAssert;
+	std::string								  m_SentryUserName;
+	std::string								  m_SentryHostName;
+	std::string								  m_SentryId;
+	std::shared_ptr<spdlog::logger>			  m_SentryLogger;
+};
+
+}  // namespace zen
+#endif
diff --git a/src/zencore/include/zencore/thread.h b/src/zencore/include/zencore/thread.h
index 8fb781571..d9fb5c023 100644
--- a/src/zencore/include/zencore/thread.h
+++ b/src/zencore/include/zencore/thread.h
@@ -183,6 +183,7 @@ public:
 	void CountDown()
 	{
 		std::ptrdiff_t Old = Counter.fetch_sub(1);
+		ZEN_ASSERT(Old > 0);
 		if (Old == 1)
 		{
 			Complete.Set();
@@ -197,8 +198,7 @@ public:
 	void AddCount(std::ptrdiff_t Count)
 	{
 		std::atomic_ptrdiff_t Old = Counter.fetch_add(Count);
-		ZEN_UNUSED(Old);
-		ZEN_ASSERT_SLOW(Old > 0);
+		ZEN_ASSERT(Old > 0);
 	}
 
 	bool Wait(int TimeoutMs = -1)
diff --git a/src/zencore/iobuffer.cpp b/src/zencore/iobuffer.cpp
index 3b5c89c3e..8e9a37a27 100644
--- a/src/zencore/iobuffer.cpp
+++ b/src/zencore/iobuffer.cpp
@@ -297,49 +297,21 @@ IoBufferExtendedCore::Materialize() const
 
 		AllocateBuffer(m_DataBytes, sizeof(void*));
 		NewFlags |= kIsOwnedByThis;
-		int32_t Error	  = 0;
-		size_t	BytesRead = 0;
 
-#if ZEN_PLATFORM_WINDOWS
-		OVERLAPPED Ovl{};
-
-		Ovl.Offset	   = DWORD(m_FileOffset & 0xffff'ffffu);
-		Ovl.OffsetHigh = DWORD(m_FileOffset >> 32);
-
-		DWORD dwNumberOfBytesRead = 0;
-		BOOL  Success			  = ::ReadFile(m_FileHandle, (void*)m_DataPtr, DWORD(m_DataBytes), &dwNumberOfBytesRead, &Ovl) == TRUE;
-		if (Success)
-		{
-			BytesRead = size_t(dwNumberOfBytesRead);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#else
-		static_assert(sizeof(off_t) >= sizeof(uint64_t), "sizeof(off_t) does not support large files");
-		int		Fd		   = int(uintptr_t(m_FileHandle));
-		ssize_t ReadResult = pread(Fd, (void*)m_DataPtr, m_DataBytes, m_FileOffset);
-		if (ReadResult != -1)
-		{
-			BytesRead = size_t(ReadResult);
-		}
-		else
-		{
-			Error = zen::GetLastError();
-		}
-#endif	// ZEN_PLATFORM_WINDOWS
-		if (Error || (BytesRead != m_DataBytes))
+		std::error_code Ec;
+		ReadFile(m_FileHandle, (void*)m_DataPtr, m_DataBytes, m_FileOffset, DisableMMapSizeLimit, Ec);
+		if (Ec)
 		{
 			std::error_code DummyEc;
-			ZEN_WARN("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x}), {}",
+			ZEN_WARN("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x}), {} ({})",
 					 m_FileOffset,
 					 m_DataBytes,
 					 zen::PathFromHandle(m_FileHandle, DummyEc),
 					 zen::FileSizeFromHandle(m_FileHandle),
-					 GetSystemErrorAsString(Error));
+					 Ec.message(),
+					 Ec.value());
 			throw std::system_error(
-				std::error_code(Error, std::system_category()),
+				Ec,
 				fmt::format("IoBufferExtendedCore::Materialize: ReadFile/pread failed (offset {:#x}, size {:#x}) file: '{}' (size {:#x})",
 							m_FileOffset,
 							m_DataBytes,
diff --git a/src/zencore/process.cpp b/src/zencore/process.cpp
index 147b00966..f62731d94 100644
--- a/src/zencore/process.cpp
+++ b/src/zencore/process.cpp
@@ -60,7 +60,7 @@ GetPidStatus(int Pid, std::error_code& OutEc)
 {
 	std::filesystem::path EntryPath = std::filesystem::path("/proc") / fmt::format("{}", Pid);
 	std::filesystem::path StatPath	= EntryPath / "stat";
-	if (std::filesystem::is_regular_file(StatPath))
+	if (IsFile(StatPath))
 	{
 		FILE* StatFile = fopen(StatPath.c_str(), "r");
 		if (StatFile)
@@ -946,7 +946,7 @@ GetProcessExecutablePath(int Pid, std::error_code& OutEc)
 }
 
 std::error_code
-FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle)
+FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle, bool IncludeSelf)
 {
 #if ZEN_PLATFORM_WINDOWS
 	HANDLE ProcessSnapshotHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
@@ -956,13 +956,15 @@ FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHand
 	}
 	auto _ = MakeGuard([&]() { CloseHandle(ProcessSnapshotHandle); });
 
+	const DWORD ThisProcessId = ::GetCurrentProcessId();
+
 	PROCESSENTRY32 Entry;
 	Entry.dwSize = sizeof(PROCESSENTRY32);
 	if (Process32First(ProcessSnapshotHandle, (LPPROCESSENTRY32)&Entry))
 	{
 		do
 		{
-			if (ExecutableImage.filename() == Entry.szExeFile)
+			if ((IncludeSelf || (Entry.th32ProcessID != ThisProcessId)) && (ExecutableImage.filename() == Entry.szExeFile))
 			{
 				std::error_code		  Ec;
 				std::filesystem::path EntryPath = GetProcessExecutablePath(Entry.th32ProcessID, Ec);
@@ -987,6 +989,7 @@ FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHand
 				}
 			}
 		} while (::Process32Next(ProcessSnapshotHandle, (LPPROCESSENTRY32)&Entry));
+		return {};
 	}
 	return MakeErrorCodeFromLastError();
 #endif	// ZEN_PLATFORM_WINDOWS
@@ -997,6 +1000,8 @@ FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHand
 	struct kinfo_proc* Processes = nullptr;
 	uint32_t		   ProcCount = 0;
 
+	const pid_t ThisProcessId = getpid();
+
 	if (sysctl(Mib, 4, NULL, &BufferSize, NULL, 0) != -1 && BufferSize > 0)
 	{
 		struct kinfo_proc* Processes = (struct kinfo_proc*)malloc(BufferSize);
@@ -1007,36 +1012,46 @@ FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHand
 			char Buffer[PROC_PIDPATHINFO_MAXSIZE];
 			for (uint32_t ProcIndex = 0; ProcIndex < ProcCount; ProcIndex++)
 			{
-				pid_t				  Pid = Processes[ProcIndex].kp_proc.p_pid;
-				std::error_code		  Ec;
-				std::filesystem::path EntryPath = GetProcessExecutablePath(Pid, Ec);
-				if (!Ec)
+				pid_t Pid = Processes[ProcIndex].kp_proc.p_pid;
+				if (IncludeSelf || (Pid != ThisProcessId))
 				{
-					if (EntryPath == ExecutableImage)
+					std::error_code		  Ec;
+					std::filesystem::path EntryPath = GetProcessExecutablePath(Pid, Ec);
+					if (!Ec)
 					{
-						if (Processes[ProcIndex].kp_proc.p_stat != SZOMB)
+						if (EntryPath == ExecutableImage)
 						{
-							OutHandle.Initialize(Pid, Ec);
-							return Ec;
+							if (Processes[ProcIndex].kp_proc.p_stat != SZOMB)
+							{
+								OutHandle.Initialize(Pid, Ec);
+								return Ec;
+							}
 						}
 					}
+					Ec.clear();
 				}
 			}
+			return {};
 		}
 	}
 	return MakeErrorCodeFromLastError();
 #endif	// ZEN_PLATFORM_MAC
 #if ZEN_PLATFORM_LINUX
+	const pid_t ThisProcessId = getpid();
+
 	std::vector<uint32_t> RunningPids;
 	DirectoryContent	  ProcList;
 	GetDirectoryContent("/proc", DirectoryContentFlags::IncludeDirs, ProcList);
 	for (const std::filesystem::path& EntryPath : ProcList.Directories)
 	{
 		std::string				EntryName = EntryPath.stem();
-		std::optional<uint32_t> Pid		  = ParseInt<uint32_t>(EntryName);
-		if (Pid.has_value())
+		std::optional<uint32_t> PidMaybe  = ParseInt<uint32_t>(EntryName);
+		if (PidMaybe.has_value())
 		{
-			RunningPids.push_back(Pid.value());
+			if (pid_t Pid = PidMaybe.value(); IncludeSelf || (Pid != ThisProcessId))
+			{
+				RunningPids.push_back(Pid);
+			}
 		}
 	}
 
@@ -1059,123 +1074,12 @@ FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHand
 				}
 			}
 		}
+		Ec.clear();
 	}
 	return {};
 #endif	// ZEN_PLATFORM_LINUX
 }
 
-std::vector<std::string>
-ParseCommandLine(std::string_view CommandLine)
-{
-	auto IsWhitespaceOrEnd = [](std::string_view CommandLine, std::string::size_type Pos) {
-		if (Pos == CommandLine.length())
-		{
-			return true;
-		}
-		if (CommandLine[Pos] == ' ')
-		{
-			return true;
-		}
-		return false;
-	};
-
-	bool IsParsingArg = false;
-	bool IsInQuote	  = false;
-
-	std::string::size_type	 Pos	  = 0;
-	std::string::size_type	 ArgStart = 0;
-	std::vector<std::string> Args;
-	while (Pos < CommandLine.length())
-	{
-		if (IsInQuote)
-		{
-			if (CommandLine[Pos] == '"' && IsWhitespaceOrEnd(CommandLine, Pos + 1))
-			{
-				Args.push_back(std::string(CommandLine.substr(ArgStart, Pos - ArgStart + 1)));
-				Pos++;
-				IsInQuote	 = false;
-				IsParsingArg = false;
-			}
-			else
-			{
-				Pos++;
-			}
-		}
-		else if (IsParsingArg)
-		{
-			ZEN_ASSERT(Pos > ArgStart);
-			if (CommandLine[Pos] == ' ')
-			{
-				Args.push_back(std::string(CommandLine.substr(ArgStart, Pos - ArgStart)));
-				Pos++;
-				IsParsingArg = false;
-			}
-			else if (CommandLine[Pos] == '"')
-			{
-				IsInQuote = true;
-				Pos++;
-			}
-			else
-			{
-				Pos++;
-			}
-		}
-		else if (CommandLine[Pos] == '"')
-		{
-			IsInQuote	 = true;
-			IsParsingArg = true;
-			ArgStart	 = Pos;
-			Pos++;
-		}
-		else if (CommandLine[Pos] != ' ')
-		{
-			IsParsingArg = true;
-			ArgStart	 = Pos;
-			Pos++;
-		}
-		else
-		{
-			Pos++;
-		}
-	}
-	if (IsParsingArg)
-	{
-		ZEN_ASSERT(Pos > ArgStart);
-		Args.push_back(std::string(CommandLine.substr(ArgStart)));
-	}
-
-	return Args;
-}
-
-std::vector<char*>
-StripCommandlineQuotes(std::vector<std::string>& InOutArgs)
-{
-	std::vector<char*> RawArgs;
-	RawArgs.reserve(InOutArgs.size());
-	for (std::string& Arg : InOutArgs)
-	{
-		std::string::size_type EscapedQuotePos = Arg.find("\\\"", 1);
-		while (EscapedQuotePos != std::string::npos && Arg.rfind('\"', EscapedQuotePos - 1) != std::string::npos)
-		{
-			Arg.erase(EscapedQuotePos, 1);
-			EscapedQuotePos = Arg.find("\\\"", EscapedQuotePos);
-		}
-
-		if (Arg.starts_with("\""))
-		{
-			if (Arg.find('"', 1) == Arg.length() - 1)
-			{
-				if (Arg.find(' ', 1) == std::string::npos)
-				{
-					Arg = Arg.substr(1, Arg.length() - 2);
-				}
-			}
-		}
-		RawArgs.push_back(const_cast<char*>(Arg.c_str()));
-	}
-	return RawArgs;
-}
-
 #if ZEN_WITH_TESTS
 
 void
@@ -1194,10 +1098,24 @@ TEST_CASE("Process")
 
 TEST_CASE("FindProcess")
 {
-	ProcessHandle	Process;
-	std::error_code Ec = FindProcess(GetRunningExecutablePath(), Process);
-	CHECK(!Ec);
-	CHECK(Process.IsValid());
+	{
+		ProcessHandle	Process;
+		std::error_code Ec = FindProcess(GetRunningExecutablePath(), Process, /*IncludeSelf*/ true);
+		CHECK(!Ec);
+		CHECK(Process.IsValid());
+	}
+	{
+		ProcessHandle	Process;
+		std::error_code Ec = FindProcess(GetRunningExecutablePath(), Process, /*IncludeSelf*/ false);
+		CHECK(!Ec);
+		CHECK(!Process.IsValid());
+	}
+	{
+		ProcessHandle	Process;
+		std::error_code Ec = FindProcess("this/does\\not/exist\\123914921929412312312312asdad\\12134.no", Process, /*IncludeSelf*/ false);
+		CHECK(!Ec);
+		CHECK(!Process.IsValid());
+	}
 }
 
 TEST_CASE("BuildArgV")
@@ -1252,36 +1170,6 @@ TEST_CASE("BuildArgV")
 	}
 }
 
-TEST_CASE("CommandLine")
-{
-	std::vector<std::string> v1 = ParseCommandLine("c:\\my\\exe.exe \"quoted arg\" \"one\",two,\"three\\\"");
-	CHECK_EQ(v1[0], "c:\\my\\exe.exe");
-	CHECK_EQ(v1[1], "\"quoted arg\"");
-	CHECK_EQ(v1[2], "\"one\",two,\"three\\\"");
-
-	std::vector<std::string> v2 = ParseCommandLine(
-		"--tracehost 127.0.0.1 builds download --url=https://jupiter.devtools.epicgames.com --namespace=ue.oplog "
-		"--bucket=citysample.packaged-build.fortnite-main.windows \"c:\\just\\a\\path\" "
-		"--access-token-path=\"C:\\Users\\dan.engelbrecht\\jupiter-token.json\" \"D:\\Dev\\Spaced Folder\\Target\\\" "
-		"--alt-path=\"D:\\Dev\\Spaced Folder2\\Target\\\" 07dn23ifiwesnvoasjncasab --build-part-name win64,linux,ps5");
-
-	std::vector<char*> v2Stripped = StripCommandlineQuotes(v2);
-	CHECK_EQ(v2Stripped[0], std::string("--tracehost"));
-	CHECK_EQ(v2Stripped[1], std::string("127.0.0.1"));
-	CHECK_EQ(v2Stripped[2], std::string("builds"));
-	CHECK_EQ(v2Stripped[3], std::string("download"));
-	CHECK_EQ(v2Stripped[4], std::string("--url=https://jupiter.devtools.epicgames.com"));
-	CHECK_EQ(v2Stripped[5], std::string("--namespace=ue.oplog"));
-	CHECK_EQ(v2Stripped[6], std::string("--bucket=citysample.packaged-build.fortnite-main.windows"));
-	CHECK_EQ(v2Stripped[7], std::string("c:\\just\\a\\path"));
-	CHECK_EQ(v2Stripped[8], std::string("--access-token-path=\"C:\\Users\\dan.engelbrecht\\jupiter-token.json\""));
-	CHECK_EQ(v2Stripped[9], std::string("\"D:\\Dev\\Spaced Folder\\Target\""));
-	CHECK_EQ(v2Stripped[10], std::string("--alt-path=\"D:\\Dev\\Spaced Folder2\\Target\""));
-	CHECK_EQ(v2Stripped[11], std::string("07dn23ifiwesnvoasjncasab"));
-	CHECK_EQ(v2Stripped[12], std::string("--build-part-name"));
-	CHECK_EQ(v2Stripped[13], std::string("win64,linux,ps5"));
-}
-
 TEST_SUITE_END(/* core.process */);
 
 #endif
diff --git a/src/zencore/sentryintegration.cpp b/src/zencore/sentryintegration.cpp
new file mode 100644
index 000000000..118c4158a
--- /dev/null
+++ b/src/zencore/sentryintegration.cpp
@@ -0,0 +1,336 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zencore/sentryintegration.h>
+
+#include <zencore/config.h>
+#include <zencore/logging.h>
+#include <zencore/session.h>
+#include <zencore/uid.h>
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#if ZEN_PLATFORM_LINUX
+#	include <pwd.h>
+#endif
+
+#if ZEN_PLATFORM_MAC
+#	include <pwd.h>
+#endif
+
+ZEN_THIRD_PARTY_INCLUDES_START
+#include <spdlog/spdlog.h>
+ZEN_THIRD_PARTY_INCLUDES_END
+
+#if ZEN_USE_SENTRY
+#	define SENTRY_BUILD_STATIC 1
+ZEN_THIRD_PARTY_INCLUDES_START
+#	include <sentry.h>
+#	include <spdlog/sinks/base_sink.h>
+ZEN_THIRD_PARTY_INCLUDES_END
+
+namespace sentry {
+
+namespace {
+	static const std::string DefaultDsn("https://[email protected]/5919284");
+}
+
+struct SentryAssertImpl : zen::AssertImpl
+{
+	virtual void ZEN_FORCENOINLINE ZEN_DEBUG_SECTION
+	OnAssert(const char* Filename, int LineNumber, const char* FunctionName, const char* Msg, zen::CallstackFrames* Callstack) override;
+};
+
+class sentry_sink final : public spdlog::sinks::base_sink<spdlog::details::null_mutex>
+{
+public:
+	sentry_sink();
+	~sentry_sink();
+
+protected:
+	void sink_it_(const spdlog::details::log_msg& msg) override;
+	void flush_() override;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+static constexpr sentry_level_t MapToSentryLevel[spdlog::level::level_enum::n_levels] = {SENTRY_LEVEL_DEBUG,
+																						 SENTRY_LEVEL_DEBUG,
+																						 SENTRY_LEVEL_INFO,
+																						 SENTRY_LEVEL_WARNING,
+																						 SENTRY_LEVEL_ERROR,
+																						 SENTRY_LEVEL_FATAL,
+																						 SENTRY_LEVEL_DEBUG};
+
+sentry_sink::sentry_sink()
+{
+}
+sentry_sink::~sentry_sink()
+{
+}
+
+void
+sentry_sink::sink_it_(const spdlog::details::log_msg& msg)
+{
+	if (msg.level != spdlog::level::err && msg.level != spdlog::level::critical)
+	{
+		return;
+	}
+	try
+	{
+		std::string	   Message = fmt::format("{}\n{}({}) [{}]", msg.payload, msg.source.filename, msg.source.line, msg.source.funcname);
+		sentry_value_t event   = sentry_value_new_message_event(
+			  /*   level */ MapToSentryLevel[msg.level],
+			  /*  logger */ nullptr,
+			  /* message */ Message.c_str());
+		sentry_event_value_add_stacktrace(event, NULL, 0);
+		sentry_capture_event(event);
+	}
+	catch (const std::exception&)
+	{
+		// If our logging with Message formatting fails we do a non-allocating version and just post the msg.payload raw
+		char   TmpBuffer[256];
+		size_t MaxCopy = zen::Min<size_t>(msg.payload.size(), size_t(255));
+		memcpy(TmpBuffer, msg.payload.data(), MaxCopy);
+		TmpBuffer[MaxCopy]	 = '\0';
+		sentry_value_t event = sentry_value_new_message_event(
+			/*   level */ SENTRY_LEVEL_ERROR,
+			/*  logger */ nullptr,
+			/* message */ TmpBuffer);
+		sentry_event_value_add_stacktrace(event, NULL, 0);
+		sentry_capture_event(event);
+	}
+}
+void
+sentry_sink::flush_()
+{
+}
+
+void
+SentryAssertImpl::OnAssert(const char* Filename, int LineNumber, const char* FunctionName, const char* Msg, zen::CallstackFrames* Callstack)
+{
+	// Sentry will provide its own callstack
+	ZEN_UNUSED(Callstack);
+	try
+	{
+		std::string	   Message = fmt::format("ASSERT {}:({}) [{}]\n\"{}\"", Filename, LineNumber, FunctionName, Msg);
+		sentry_value_t event   = sentry_value_new_message_event(
+			  /*   level */ SENTRY_LEVEL_ERROR,
+			  /*  logger */ nullptr,
+			  /* message */ Message.c_str());
+		sentry_event_value_add_stacktrace(event, NULL, 0);
+		sentry_capture_event(event);
+	}
+	catch (const std::exception&)
+	{
+		// If our logging with Message formatting fails we do a non-allocating version and just post the Msg raw
+		sentry_value_t event = sentry_value_new_message_event(
+			/*   level */ SENTRY_LEVEL_ERROR,
+			/*  logger */ nullptr,
+			/* message */ Msg);
+		sentry_event_value_add_stacktrace(event, NULL, 0);
+		sentry_capture_event(event);
+	}
+}
+
+}  // namespace sentry
+
+namespace zen {
+
+#	if ZEN_USE_SENTRY
+static void
+SentryLogFunction(sentry_level_t Level, const char* Message, va_list Args, [[maybe_unused]] void* Userdata)
+{
+	char		LogMessageBuffer[160];
+	std::string LogMessage;
+	const char* MessagePtr = LogMessageBuffer;
+
+	int n = vsnprintf(LogMessageBuffer, sizeof LogMessageBuffer, Message, Args);
+
+	if (n >= int(sizeof LogMessageBuffer))
+	{
+		LogMessage.resize(n + 1);
+
+		n = vsnprintf(LogMessage.data(), LogMessage.size(), Message, Args);
+
+		MessagePtr = LogMessage.c_str();
+	}
+
+	switch (Level)
+	{
+		case SENTRY_LEVEL_DEBUG:
+			ZEN_CONSOLE_DEBUG("sentry: {}", MessagePtr);
+			break;
+
+		case SENTRY_LEVEL_INFO:
+			ZEN_CONSOLE_INFO("sentry: {}", MessagePtr);
+			break;
+
+		case SENTRY_LEVEL_WARNING:
+			ZEN_CONSOLE_WARN("sentry: {}", MessagePtr);
+			break;
+
+		case SENTRY_LEVEL_ERROR:
+			ZEN_CONSOLE_ERROR("sentry: {}", MessagePtr);
+			break;
+
+		case SENTRY_LEVEL_FATAL:
+			ZEN_CONSOLE_CRITICAL("sentry: {}", MessagePtr);
+			break;
+	}
+}
+#	endif
+
+SentryIntegration::SentryIntegration()
+{
+}
+
+SentryIntegration::~SentryIntegration()
+{
+	if (m_IsInitialized && m_SentryErrorCode == 0)
+	{
+		logging::SetErrorLog("");
+		m_SentryAssert.reset();
+		sentry_close();
+	}
+}
+
+void
+SentryIntegration::Initialize(const Config& Conf, const std::string& CommandLine)
+{
+	m_AllowPII = Conf.AllowPII;
+
+	std::string SentryDatabasePath = Conf.DatabasePath;
+	if (SentryDatabasePath.starts_with("\\\\?\\"))
+	{
+		SentryDatabasePath = SentryDatabasePath.substr(4);
+	}
+	sentry_options_t* SentryOptions = sentry_options_new();
+
+	sentry_options_set_dsn(SentryOptions, Conf.Dsn.empty() ? sentry::DefaultDsn.c_str() : Conf.Dsn.c_str());
+	sentry_options_set_database_path(SentryOptions, SentryDatabasePath.c_str());
+	sentry_options_set_logger(SentryOptions, SentryLogFunction, this);
+	sentry_options_set_environment(SentryOptions, Conf.Environment.empty() ? "production" : Conf.Environment.c_str());
+
+	std::string SentryAttachmentsPath = Conf.AttachmentsPath;
+	if (!SentryAttachmentsPath.empty())
+	{
+		if (SentryAttachmentsPath.starts_with("\\\\?\\"))
+		{
+			SentryAttachmentsPath = SentryAttachmentsPath.substr(4);
+		}
+		sentry_options_add_attachment(SentryOptions, SentryAttachmentsPath.c_str());
+	}
+	sentry_options_set_release(SentryOptions, ZEN_CFG_VERSION);
+
+	if (Conf.Debug)
+	{
+		sentry_options_set_debug(SentryOptions, 1);
+	}
+
+	m_SentryErrorCode = sentry_init(SentryOptions);
+
+	if (m_SentryErrorCode == 0)
+	{
+		sentry_value_t SentryUserObject = sentry_value_new_object();
+
+		if (m_AllowPII)
+		{
+#	if ZEN_PLATFORM_WINDOWS
+			CHAR  Buffer[511 + 1];
+			DWORD BufferLength = sizeof(Buffer) / sizeof(CHAR);
+			BOOL  OK		   = GetUserNameA(Buffer, &BufferLength);
+			if (OK && BufferLength)
+			{
+				m_SentryUserName = std::string(Buffer, BufferLength - 1);
+			}
+			BufferLength = sizeof(Buffer) / sizeof(CHAR);
+			OK			 = GetComputerNameA(Buffer, &BufferLength);
+			if (OK && BufferLength)
+			{
+				m_SentryHostName = std::string(Buffer, BufferLength);
+			}
+			else
+			{
+				m_SentryHostName = "unknown";
+			}
+#	endif	// ZEN_PLATFORM_WINDOWS
+
+#	if (ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC)
+			uid_t		   uid = geteuid();
+			struct passwd* pw  = getpwuid(uid);
+			if (pw)
+			{
+				m_SentryUserName = std::string(pw->pw_name);
+			}
+			else
+			{
+				m_SentryUserName = "unknown";
+			}
+			char HostNameBuffer[1023 + 1];
+			int	 err = gethostname(HostNameBuffer, sizeof(HostNameBuffer));
+			if (err == 0)
+			{
+				m_SentryHostName = std::string(HostNameBuffer);
+			}
+			else
+			{
+				m_SentryHostName = "unknown";
+			}
+#	endif
+			m_SentryId = fmt::format("{}@{}", m_SentryUserName, m_SentryHostName);
+			sentry_value_set_by_key(SentryUserObject, "id", sentry_value_new_string(m_SentryId.c_str()));
+			sentry_value_set_by_key(SentryUserObject, "username", sentry_value_new_string(m_SentryUserName.c_str()));
+			sentry_value_set_by_key(SentryUserObject, "ip_address", sentry_value_new_string("{{auto}}"));
+		}
+
+		sentry_value_set_by_key(SentryUserObject, "cmd", sentry_value_new_string(CommandLine.c_str()));
+
+		const std::string SessionId(GetSessionIdString());
+		sentry_value_set_by_key(SentryUserObject, "session", sentry_value_new_string(SessionId.c_str()));
+
+		sentry_set_user(SentryUserObject);
+
+		m_SentryLogger = spdlog::create<sentry::sentry_sink>("sentry");
+		logging::SetErrorLog("sentry");
+
+		m_SentryAssert = std::make_unique<sentry::SentryAssertImpl>();
+	}
+
+	m_IsInitialized = true;
+}
+
+void
+SentryIntegration::LogStartupInformation()
+{
+	if (m_IsInitialized)
+	{
+		if (m_SentryErrorCode == 0)
+		{
+			if (m_AllowPII)
+			{
+				ZEN_INFO("sentry initialized, username: '{}', hostname: '{}', id: '{}'", m_SentryUserName, m_SentryHostName, m_SentryId);
+			}
+			else
+			{
+				ZEN_INFO("sentry initialized with anonymous reports");
+			}
+		}
+		else
+		{
+			ZEN_WARN(
+				"sentry_init returned failure! (error code: {}) note that sentry expects crashpad_handler to exist alongside the running "
+				"executable",
+				m_SentryErrorCode);
+		}
+	}
+}
+
+void
+SentryIntegration::ClearCaches()
+{
+	sentry_clear_modulecache();
+}
+
+}  // namespace zen
+#endif
diff --git a/src/zencore/testutils.cpp b/src/zencore/testutils.cpp
index 641d5508a..9f50de032 100644
--- a/src/zencore/testutils.cpp
+++ b/src/zencore/testutils.cpp
@@ -4,6 +4,7 @@
 
 #if ZEN_WITH_TESTS
 
+#	include <zencore/filesystem.h>
 #	include <zencore/session.h>
 #	include "zencore/string.h"
 
@@ -19,8 +20,8 @@ CreateTemporaryDirectory()
 	std::error_code Ec;
 
 	std::filesystem::path DirPath = std::filesystem::temp_directory_path() / GetSessionIdString() / IntNum(++Sequence).c_str();
-	std::filesystem::remove_all(DirPath, Ec);
-	std::filesystem::create_directories(DirPath);
+	DeleteDirectories(DirPath, Ec);
+	CreateDirectories(DirPath);
 
 	return DirPath;
 }
@@ -32,14 +33,14 @@ ScopedTemporaryDirectory::ScopedTemporaryDirectory() : m_RootPath(CreateTemporar
 ScopedTemporaryDirectory::ScopedTemporaryDirectory(std::filesystem::path Directory) : m_RootPath(Directory)
 {
 	std::error_code Ec;
-	std::filesystem::remove_all(Directory, Ec);
-	std::filesystem::create_directories(Directory);
+	DeleteDirectories(Directory, Ec);
+	CreateDirectories(Directory);
 }
 
 ScopedTemporaryDirectory::~ScopedTemporaryDirectory()
 {
 	std::error_code Ec;
-	std::filesystem::remove_all(m_RootPath, Ec);
+	DeleteDirectories(m_RootPath, Ec);
 }
 
 IoBuffer
diff --git a/src/zencore/xmake.lua b/src/zencore/xmake.lua
index 13611a2e9..b3a33e052 100644
--- a/src/zencore/xmake.lua
+++ b/src/zencore/xmake.lua
@@ -64,6 +64,27 @@ target('zencore')
         {public=true}
     )
 
+    if has_config("zensentry") then
+        add_packages("vcpkg::sentry-native")
+
+        if is_plat("windows") then
+            add_links("dbghelp", "winhttp", "version")    -- for Sentry
+        end
+
+        if is_plat("linux") then
+            -- As sentry_native uses symbols from breakpad_client, the latter must
+            -- be specified after the former with GCC-like toolchains. xmake however
+            -- is unaware of this and simply globs files from vcpkg's output. The
+            -- line below forces breakpad_client to be to the right of sentry_native
+            add_syslinks("breakpad_client")
+        end
+
+        if is_plat("macosx") then
+            add_syslinks("bsm")
+        end
+
+    end
+
     if is_plat("linux") then
         add_syslinks("rt")
     end