Merge branch 'main' into fd-fix-binary-json

6 files changed, 900 insertions, 148 deletions

diff --git a/src/zencore/basicfile.cpp b/src/zencore/basicfile.cpp
index a181bbd66..ea526399c 100644
--- a/src/zencore/basicfile.cpp
+++ b/src/zencore/basicfile.cpp
@@ -590,7 +590,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)
 	{
@@ -984,9 +984,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")
@@ -997,11 +997,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/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..4ec563ba3 100644
--- a/src/zencore/filesystem.cpp
+++ b/src/zencore/filesystem.cpp
@@ -86,16 +86,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 +205,327 @@ 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
+IsFileAttributeReadOnly(uint32_t FileAttributes)
+{
+#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);
+}
+
 bool
-CreateDirectories(const std::filesystem::path& Dir)
+RemoveDirNative(const std::filesystem::path& Path, std::error_code& Ec)
 {
-	if (Dir.string().ends_with(":"))
+#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 = ::GetFileAttributes(NativePath);
+			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);
+}
+
+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;
+}
+
+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;
+}
 
-		return Success;
+bool
+DeleteDirectories(const std::filesystem::path& Path, std::error_code& Ec)
+{
+	bool Exists = IsDir(Path, Ec);
+	if (Ec)
+	{
+		return Exists;
 	}
 
-	return CreateDirectories(Dir);
+	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 +882,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 +891,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))
@@ -811,7 +1053,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 +1061,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 +1414,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 +1425,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 +1435,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 +1456,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 +1581,172 @@ 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 = ::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;
+			default:
+				Ec = MakeErrorCode(LastError);
+				break;
+		}
+		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 = ::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;
+			default:
+				Ec = MakeErrorCode(LastError);
+				break;
+		}
+		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,6 +1844,49 @@ PathFromHandle(void* NativeHandle, std::error_code& Ec)
 }
 
 uint64_t
+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)
+{
+#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)
 {
 	uint64_t FileSize = ~0ull;
@@ -1483,7 +1935,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 +1951,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 +1965,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()
 {
@@ -1793,7 +2347,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 +2356,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 +2375,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 +2422,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 +2490,46 @@ PickDefaultSystemRootDirectory()
 #if ZEN_PLATFORM_WINDOWS
 
 uint32_t
-GetFileAttributes(const std::filesystem::path& Filename)
+GetFileAttributes(const std::filesystem::path& Filename, std::error_code& Ec)
 {
 	DWORD Attributes = ::GetFileAttributes(Filename.native().c_str());
 	if (Attributes == INVALID_FILE_ATTRIBUTES)
 	{
-		ThrowLastError(fmt::format("failed to get attributes of file {}", Filename));
+		Ec = MakeErrorCodeFromLastError();
+		return 0;
 	}
 	return (uint32_t)Attributes;
 }
 
+uint32_t
+GetFileAttributes(const std::filesystem::path& Filename)
+{
+	std::error_code Ec;
+	uint32_t		Result = zen::GetFileAttributes(Filename, Ec);
+	if (Ec)
+	{
+		throw std::system_error(Ec, fmt::format("failed to get attributes of file '{}'", Filename.string()));
+	}
+	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 +2540,117 @@ 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)
 {
-	int err = chmod(Filename.native().c_str(), (mode_t)Attributes);
-	if (err)
+	std::error_code Ec;
+	SetFileMode(Filename, Mode, Ec);
+	if (Ec)
 	{
-		ThrowLastError(fmt::format("Failed to set mode of file {}", Filename));
+		throw std::system_error(Ec, fmt::format("Failed to set mode of file {}", Filename));
 	}
 }
 
-#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)
-{
-#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)
+void
+SetFileMode(const std::filesystem::path& Filename, uint32_t Mode, std::error_code& Ec)
 {
-	return ReadOnly ? (FileAttributes | FileAttributesSystemReadOnlyFlag) : (FileAttributes & ~FileAttributesSystemReadOnlyFlag);
+	int err = chmod(Filename.native().c_str(), (mode_t)Mode);
+	if (err)
+	{
+		Ec = MakeErrorCodeFromLastError();
+	}
 }
 
-uint32_t
-MakeFileModeReadOnly(uint32_t FileMode, bool ReadOnly)
-{
-	return ReadOnly ? (FileMode & ~FileModeWriteEnableFlags) : (FileMode | FileModeWriteEnableFlags);
-}
+#endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 
 bool
-SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly)
+SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly, std::error_code& Ec)
 {
 #if ZEN_PLATFORM_WINDOWS
-	uint32_t CurrentAttributes = GetFileAttributes(Filename);
-	uint32_t NewAttributes	   = MakeFileAttributeReadOnly(CurrentAttributes, ReadOnly);
+	uint32_t CurrentAttributes = GetFileAttributes(Filename, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	uint32_t NewAttributes = MakeFileAttributeReadOnly(CurrentAttributes, ReadOnly);
 	if (CurrentAttributes != NewAttributes)
 	{
-		SetFileAttributes(Filename, 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);
-	uint32_t NewMode	 = MakeFileModeReadOnly(CurrentMode, ReadOnly);
+	uint32_t CurrentMode = GetFileMode(Filename, Ec);
+	if (Ec)
+	{
+		return false;
+	}
+	uint32_t NewMode = MakeFileModeReadOnly(CurrentMode, ReadOnly);
 	if (CurrentMode != NewMode)
 	{
-		SetFileMode(Filename, NewMode);
+		SetFileMode(Filename, NewMode, Ec);
+		if (Ec)
+		{
+			return false;
+		}
 		return true;
 	}
 #endif	// ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC
 	return false;
 }
 
+bool
+SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly)
+{
+	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;
+}
+
 std::filesystem::path
 StringToPath(const std::string_view& Path)
 {
+	std::string_view UnquotedPath = Path;
+
 	if (Path.length() > 2 && Path.front() == '\"' && Path.back() == '\"')
 	{
-		return std::filesystem::path(Path.substr(1, Path.length() - 2)).make_preferred();
+		UnquotedPath = Path.substr(1, Path.length() - 2);
 	}
-	else
+	if (UnquotedPath.ends_with('/') || UnquotedPath.ends_with('\\') || UnquotedPath.ends_with(std::filesystem::path::preferred_separator))
 	{
-		return std::filesystem::path(Path).make_preferred();
+		UnquotedPath = UnquotedPath.substr(0, UnquotedPath.length() - 1);
 	}
+	return std::filesystem::path(UnquotedPath).make_preferred();
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -2076,7 +2673,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 +2726,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 +2834,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 +2891,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 +2905,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,16 +2924,16 @@ 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)));
 	}
 }
 
diff --git a/src/zencore/include/zencore/filesystem.h b/src/zencore/include/zencore/filesystem.h
index 9a2b15d1d..66deffa6f 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,6 +58,46 @@ 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);
@@ -56,6 +110,27 @@ 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
@@ -277,12 +352,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,6 +369,7 @@ 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);
diff --git a/src/zencore/process.cpp b/src/zencore/process.cpp
index 0761521dc..2fe5b8948 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)
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