Zs/oplog export zero size attachment fix (#911)

* Unit test coverage for zero byte file handling in oplogs
* Unit test fixes for the zero length file case
* Fixes for zero length file attachments
* Additional fix for zero length file attachments

4 files changed, 157 insertions, 2 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f46adc60f..345758799 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 ##
+- Bugfix: Handle zero length file attachments without assert
+
+## 5.8.1
 - Feature: Hub dashboard now shows a Resources tile with disk and memory usage against configured limits
 - Feature: Hub module listing now shows state-change timestamps and duration for each instance
 - Feature: Added `--hub-hydration-target-config` option to specify the hydration target via a JSON config file (mutually exclusive with `--hub-hydration-target-spec`); supports `file` and `s3` types with structured settings
diff --git a/src/zenremotestore/projectstore/remoteprojectstore.cpp b/src/zenremotestore/projectstore/remoteprojectstore.cpp
index 1a9dc10ef..2076adb70 100644
--- a/src/zenremotestore/projectstore/remoteprojectstore.cpp
+++ b/src/zenremotestore/projectstore/remoteprojectstore.cpp
@@ -929,7 +929,6 @@ namespace remotestore_impl {
 					{
 						return;
 					}
-					ZEN_ASSERT(UploadAttachment->Size != 0);
 					if (!UploadAttachment->RawPath.empty())
 					{
 						if (UploadAttachment->Size > (MaxChunkEmbedSize * 2))
@@ -7008,6 +7007,60 @@ TEST_CASE("buildcontainer.ignore_missing_file_attachment_warn")
 	}
 }
 
+TEST_CASE("buildcontainer.zero_byte_file_attachment")
+{
+	// A zero-byte file on disk is a valid attachment. BuildContainer must process
+	// it without hitting ZEN_ASSERT(UploadAttachment->Size != 0) in
+	// ResolveAttachments. The empty file flows through the compress-inline path
+	// and becomes a LooseUploadAttachment with raw size 0.
+	using namespace projectstore_testutils;
+	using namespace std::literals;
+
+	ScopedTemporaryDirectory TempDir;
+
+	GcManager					  Gc;
+	CidStore					  CidStore(Gc);
+	std::unique_ptr<ProjectStore> ProjectStoreDummy;
+	Ref<ProjectStore::Project>	  Project = MakeTestProject(CidStore, Gc, TempDir.Path(), ProjectStoreDummy);
+
+	std::filesystem::path RootDir  = TempDir.Path() / "root";
+	auto				  FileAtts = CreateFileAttachments(RootDir, std::initializer_list<size_t>{512});
+
+	Ref<ProjectStore::Oplog> Oplog = Project->NewOplog("bc_zero_byte_file", {});
+	REQUIRE(Oplog);
+	Oplog->AppendNewOplogEntry(CreateFilesOplogPackage(Oid::NewOid(), RootDir, FileAtts));
+
+	// Truncate the file to zero bytes after the oplog entry is created.
+	// The file still exists on disk so RewriteOplog's IsFile() check passes,
+	// but MakeFromFile returns a zero-size buffer.
+	std::filesystem::resize_file(FileAtts[0].second, 0);
+
+	WorkerThreadPool WorkerPool(GetWorkerCount());
+
+	CbObject Container = BuildContainer(
+		CidStore,
+		*Project,
+		*Oplog,
+		WorkerPool,
+		64u * 1024u,
+		1000,
+		32u * 1024u,
+		64u * 1024u * 1024u,
+		/*BuildBlocks=*/true,
+		/*IgnoreMissingAttachments=*/false,
+		/*AllowChunking=*/true,
+		[](CompressedBuffer&&, ChunkBlockDescription&&) {},
+		[](const IoHash&, TGetAttachmentBufferFunc&&) {},
+		[](std::vector<std::pair<IoHash, FetchChunkFunc>>&&) {},
+		/*EmbedLooseFiles=*/true);
+
+	CHECK(Container.GetSize() > 0);
+
+	// The zero-byte attachment is packed into a block via the compress-inline path.
+	CbArrayView Blocks = Container["blocks"sv].AsArrayView();
+	CHECK(Blocks.Num() > 0);
+}
+
 TEST_CASE("buildcontainer.embed_loose_files_false_no_rewrite")
 {
 	// EmbedLooseFiles=false: RewriteOp is skipped for file-op entries; they pass through
diff --git a/src/zenserver-test/projectstore-tests.cpp b/src/zenserver-test/projectstore-tests.cpp
index d72b897c8..cec453511 100644
--- a/src/zenserver-test/projectstore-tests.cpp
+++ b/src/zenserver-test/projectstore-tests.cpp
@@ -341,6 +341,102 @@ TEST_CASE("project.basic")
 			ZEN_INFO("+++++++");
 		}
 
+		SUBCASE("snapshot zero byte file")
+		{
+			// A zero-byte file referenced in an oplog entry must survive a
+			// snapshot: the file is read, compressed, stored in CidStore, and
+			// the oplog is rewritten with a BinaryAttachment reference. After
+			// the snapshot the chunk must be retrievable and decompress to an
+			// empty payload.
+
+			std::filesystem::path EmptyFileRelPath = std::filesystem::path("zerobyte_snapshot_test") / "empty.bin";
+			std::filesystem::path EmptyFileAbsPath = RootPath / EmptyFileRelPath;
+			CreateDirectories(MakeSafeAbsolutePath(EmptyFileAbsPath.parent_path()));
+			// Create a zero-byte file on disk.
+			WriteFile(MakeSafeAbsolutePath(EmptyFileAbsPath), IoBuffer{});
+			REQUIRE(IsFile(MakeSafeAbsolutePath(EmptyFileAbsPath)));
+
+			const std::string_view EmptyChunkId{
+				"00000000"
+				"00000000"
+				"00030000"};
+			auto EmptyFileOid = zen::Oid::FromHexString(EmptyChunkId);
+
+			zen::CbObjectWriter OpWriter;
+			OpWriter << "key"
+					 << "zero_byte_test";
+			OpWriter.BeginArray("files");
+			OpWriter.BeginObject();
+			OpWriter << "id" << EmptyFileOid;
+			OpWriter << "clientpath"
+					 << "/{engine}/empty_file";
+			OpWriter << "serverpath" << EmptyFileRelPath.c_str();
+			OpWriter.EndObject();
+			OpWriter.EndArray();
+
+			zen::CbObject  Op = OpWriter.Save();
+			zen::CbPackage OpPackage(Op);
+
+			zen::BinaryWriter MemOut;
+			legacy::SaveCbPackage(OpPackage, MemOut);
+
+			HttpClient Http{BaseUri};
+
+			{
+				auto Response = Http.Post("/new", IoBufferBuilder::MakeFromMemory(MemOut.GetView()));
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::Created);
+			}
+
+			// Read file data before snapshot - raw and uncompressed, 0 bytes.
+			// http.sys converts a 200 OK with empty body to 204 No Content, so
+			// accept either status code.
+			{
+				zen::StringBuilder<128> ChunkGetUri;
+				ChunkGetUri << "/" << EmptyChunkId;
+				auto Response = Http.Get(ChunkGetUri);
+
+				REQUIRE(Response);
+				CHECK((Response.StatusCode == HttpResponseCode::OK || Response.StatusCode == HttpResponseCode::NoContent));
+				CHECK(Response.ResponsePayload.GetSize() == 0);
+			}
+
+			// Trigger snapshot.
+			{
+				IoBuffer Payload  = MakeCbObjectPayload([&](CbObjectWriter& Writer) { Writer.AddString("method"sv, "snapshot"sv); });
+				auto	 Response = Http.Post("/rpc"sv, Payload);
+				REQUIRE(Response);
+				CHECK(Response.StatusCode == HttpResponseCode::OK);
+			}
+
+			// Read chunk after snapshot - compressed, decompresses to 0 bytes.
+			{
+				zen::StringBuilder<128> ChunkGetUri;
+				ChunkGetUri << "/" << EmptyChunkId;
+				auto Response = Http.Get(ChunkGetUri, {{"Accept-Type", "application/x-ue-comp"}});
+
+				REQUIRE(Response);
+				REQUIRE(Response.StatusCode == HttpResponseCode::OK);
+
+				IoBuffer		 Data = Response.ResponsePayload;
+				IoHash			 RawHash;
+				uint64_t		 RawSize;
+				CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(Data), RawHash, RawSize);
+				REQUIRE(Compressed);
+				CHECK(RawSize == 0);
+				IoBuffer DataDecompressed = Compressed.Decompress().AsIoBuffer();
+				CHECK(DataDecompressed.GetSize() == 0);
+			}
+
+			// Cleanup
+			{
+				std::error_code Ec;
+				DeleteDirectories(MakeSafeAbsolutePath(RootPath / "zerobyte_snapshot_test"), Ec);
+			}
+
+			ZEN_INFO("+++++++");
+		}
+
 		SUBCASE("test chunk not found error")
 		{
 			HttpClient Http{BaseUri};
diff --git a/src/zenstore/projectstore.cpp b/src/zenstore/projectstore.cpp
index 0c4abeb1e..7cd6b9e37 100644
--- a/src/zenstore/projectstore.cpp
+++ b/src/zenstore/projectstore.cpp
@@ -5169,7 +5169,10 @@ ExtractRange(IoBuffer&& Chunk, uint64_t Offset, uint64_t Size, ZenContentType Ac
 		const bool IsFullRange = (Offset == 0) && ((Size == ~(0ull)) || (Size == ChunkSize));
 		if (IsFullRange)
 		{
-			Result.Chunk   = CompositeBuffer(SharedBuffer(std::move(Chunk)));
+			if (ChunkSize > 0)
+			{
+				Result.Chunk = CompositeBuffer(SharedBuffer(std::move(Chunk)));
+			}
 			Result.RawSize = 0;
 		}
 		else