Address blob lifecycle review feedback

Remove the extra LoadFile byte copy by moving the runtime file-loader buffer directly into the blob. Replace unbounded tombstone storage with reusable slot/generation handles and add churn coverage for stale-handle validation. Normalize blob source extensions before format inference and cover mixed-case metadata.

Author: bboczula

source/common/AssetSuite.cpp

@@ -152,7 +152,7 @@ AssetSuite::Result AssetSuite::LoadFile(ContextHandle context, const char* fileP
 		return Result::ErrorInvalidArgument;
 	}
 
-	std::vector<BYTE> rawBytes;
+	std::vector<uint8_t> rawBytes;
 	const ErrorCode loadResult = context->Runtime().FileLoader().LoadToMemory(filePath, true, rawBytes);
 	const Result mappedResult = MapFileLoadResult(loadResult);
 	if (mappedResult != Result::Success)
@@ -163,8 +163,7 @@ AssetSuite::Result AssetSuite::LoadFile(ContextHandle context, const char* fileP
 
 	try
 	{
-		std::vector<uint8_t> bytes(rawBytes.begin(), rawBytes.end());
-		Internal::Blob blob(std::move(bytes), Internal::MakeBlobSourceMetadata(filePath));
+		Internal::Blob blob(std::move(rawBytes), Internal::MakeBlobSourceMetadata(filePath));
 		*outBlob = context->Runtime().BlobStorage().Create(std::move(blob));
 	}
 	catch (const std::bad_alloc&)

source/runtime/AssetSuiteBlob.cpp

@@ -1,27 +1,40 @@
 #include "AssetSuiteBlob.h"
 
+#include <algorithm>
+#include <cctype>
+#include <string>
 #include <utility>
 
 namespace
 {
 	AssetSuite::AssetFormat ResolveBlobFormat(const std::filesystem::path& extension) noexcept
 	{
-		if (extension == ".bmp")
+		std::string normalizedExtension = extension.string();
+		std::transform(
+			normalizedExtension.begin(),
+			normalizedExtension.end(),
+			normalizedExtension.begin(),
+			[](unsigned char character)
+			{
+				return static_cast<char>(std::tolower(character));
+			});
+
+		if (normalizedExtension == ".bmp")
 		{
 			return AssetSuite::AssetFormat::BMP;
 		}
 
-		if (extension == ".png")
+		if (normalizedExtension == ".png")
 		{
 			return AssetSuite::AssetFormat::PNG;
 		}
 
-		if (extension == ".ppm")
+		if (normalizedExtension == ".ppm")
 		{
 			return AssetSuite::AssetFormat::PPM;
 		}
 
-		if (extension == ".obj")
+		if (normalizedExtension == ".obj")
 		{
 			return AssetSuite::AssetFormat::WavefrontObj;
 		}
@@ -76,30 +89,3 @@ AssetSuite::Internal::MakeBlobSourceMetadata(const std::filesystem::path& source
 	metadata.format = ResolveBlobFormat(metadata.extension);
 	return metadata;
 }
-
-AssetSuite::AssetSuiteBlob_t::AssetSuiteBlob_t(Internal::Blob blob)
-	: blob(std::make_unique<Internal::Blob>(std::move(blob)))
-{
-}
-
-AssetSuite::AssetSuiteBlob_t::~AssetSuiteBlob_t() = default;
-
-AssetSuite::Internal::Blob& AssetSuite::AssetSuiteBlob_t::Blob() noexcept
-{
-	return *blob;
-}
-
-const AssetSuite::Internal::Blob& AssetSuite::AssetSuiteBlob_t::Blob() const noexcept
-{
-	return *blob;
-}
-
-bool AssetSuite::AssetSuiteBlob_t::IsLive() const noexcept
-{
-	return blob != nullptr;
-}
-
-void AssetSuite::AssetSuiteBlob_t::Release() noexcept
-{
-	blob.reset();
-}

source/runtime/AssetSuiteBlob.h

@@ -6,7 +6,6 @@
 
 #include <cstdint>
 #include <filesystem>
-#include <memory>
 #include <vector>
 
 namespace AssetSuite::Internal
@@ -45,18 +44,5 @@ namespace AssetSuite
 {
 	struct AssetSuiteBlob_t
 	{
-		explicit AssetSuiteBlob_t(Internal::Blob blob);
-		~AssetSuiteBlob_t();
-
-		AssetSuiteBlob_t(const AssetSuiteBlob_t&) = delete;
-		AssetSuiteBlob_t& operator=(const AssetSuiteBlob_t&) = delete;
-
-		Internal::Blob& Blob() noexcept;
-		const Internal::Blob& Blob() const noexcept;
-		bool IsLive() const noexcept;
-		void Release() noexcept;
-
-	private:
-		std::unique_ptr<Internal::Blob> blob;
 	};
 }

source/runtime/AssetSuiteRuntimeState.cpp

@@ -8,8 +8,48 @@
 
 #include <fstream>
 #include <new>
+#include <cstdint>
 #include <utility>
 
+namespace
+{
+	constexpr uintptr_t SLOT_INDEX_MASK = 0xffffffffu;
+	constexpr uint32_t INITIAL_BLOB_GENERATION = 1;
+
+	AssetSuite::BlobHandle EncodeBlobHandle(size_t slotIndex, uint32_t generation) noexcept
+	{
+		const uintptr_t token =
+			(static_cast<uintptr_t>(generation) << 32) |
+			(static_cast<uintptr_t>(slotIndex) + 1u);
+		return reinterpret_cast<AssetSuite::BlobHandle>(token);
+	}
+
+	bool DecodeBlobHandle(AssetSuite::BlobHandle handle, size_t& slotIndex, uint32_t& generation) noexcept
+	{
+		const uintptr_t token = reinterpret_cast<uintptr_t>(handle);
+		const uintptr_t encodedSlotIndex = token & SLOT_INDEX_MASK;
+		if (encodedSlotIndex == 0)
+		{
+			return false;
+		}
+
+		generation = static_cast<uint32_t>(token >> 32);
+		if (generation == 0)
+		{
+			return false;
+		}
+
+		slotIndex = static_cast<size_t>(encodedSlotIndex - 1u);
+		return true;
+	}
+
+	uint32_t NextBlobGeneration(uint32_t generation) noexcept
+	{
+		++generation;
+		return generation == 0 ? INITIAL_BLOB_GENERATION : generation;
+	}
+}
+
 AssetSuite::Internal::RuntimeState::RuntimeState()
 	: codecs()
 {
@@ -81,7 +121,7 @@ AssetSuite::Internal::RuntimeState::Diagnostics::Entries() const noexcept
 AssetSuite::ErrorCode AssetSuite::Internal::RuntimeState::FileLoader::LoadToMemory(
 	const std::filesystem::path& fileName,
 	bool isBinary,
-	std::vector<BYTE>& output) const
+	std::vector<uint8_t>& output) const
 {
 	if (!std::filesystem::exists(fileName))
 	{
@@ -118,48 +158,89 @@ AssetSuite::ErrorCode AssetSuite::Internal::RuntimeState::FileLoader::LoadToMemo
 
 AssetSuite::BlobHandle AssetSuite::Internal::RuntimeState::BlobStorage::Create(Blob blob)
 {
-	auto storedBlob = std::make_unique<AssetSuiteBlob_t>(std::move(blob));
-	BlobHandle handle = storedBlob.get();
-	blobs.push_back(std::move(storedBlob));
-	return handle;
+	size_t slotIndex = 0;
+	if (!freeSlots.empty())
+	{
+		slotIndex = freeSlots.back();
+		freeSlots.pop_back();
+	}
+	else
+	{
+		slotIndex = slots.size();
+		slots.push_back({ nullptr, INITIAL_BLOB_GENERATION });
+	}
+
+	slots[slotIndex].blob = std::make_unique<Blob>(std::move(blob));
+	return EncodeBlobHandle(slotIndex, slots[slotIndex].generation);
 }
 
 bool AssetSuite::Internal::RuntimeState::BlobStorage::Owns(BlobHandle blob) const noexcept
 {
-	for (const auto& storedBlob : blobs)
-	{
-		if (storedBlob.get() == blob)
-		{
-			return true;
-		}
-	}
-
-	return false;
+	return Get(blob) != nullptr;
 }
 
 bool AssetSuite::Internal::RuntimeState::BlobStorage::IsLive(BlobHandle blob) const noexcept
 {
-	return Owns(blob) && blob->IsLive();
+	return Get(blob) != nullptr;
+}
+
+const AssetSuite::Internal::Blob*
+AssetSuite::Internal::RuntimeState::BlobStorage::Get(BlobHandle blob) const noexcept
+{
+	size_t slotIndex = 0;
+	uint32_t generation = 0;
+	if (!DecodeBlobHandle(blob, slotIndex, generation))
+	{
+		return nullptr;
+	}
+
+	if (slotIndex >= slots.size())
+	{
+		return nullptr;
+	}
+
+	const Slot& slot = slots[slotIndex];
+	if (slot.generation != generation || !slot.blob)
+	{
+		return nullptr;
+	}
+
+	return slot.blob.get();
 }
 
 AssetSuite::Result AssetSuite::Internal::RuntimeState::BlobStorage::Release(BlobHandle* blob) noexcept
 {
-	if (!blob || !*blob || !IsLive(*blob))
+	size_t slotIndex = 0;
+	uint32_t generation = 0;
+	if (!blob || !DecodeBlobHandle(*blob, slotIndex, generation))
 	{
 		return Result::ErrorInvalidHandle;
 	}
 
-	(*blob)->Release();
+	if (slotIndex >= slots.size())
+	{
+		return Result::ErrorInvalidHandle;
+	}
+
+	Slot& slot = slots[slotIndex];
+	if (slot.generation != generation || !slot.blob)
+	{
+		return Result::ErrorInvalidHandle;
+	}
+
+	slot.blob.reset();
+	slot.generation = NextBlobGeneration(slot.generation);
+	freeSlots.push_back(slotIndex);
 	*blob = nullptr;
 	return Result::Success;
 }
 
 size_t AssetSuite::Internal::RuntimeState::BlobStorage::LiveCount() const noexcept
 {
 	size_t count = 0;
-	for (const auto& storedBlob : blobs)
+	for (const auto& slot : slots)
 	{
-		if (storedBlob->IsLive())
+		if (slot.blob)
 		{
 			++count;
 		}
@@ -168,6 +249,11 @@ size_t AssetSuite::Internal::RuntimeState::BlobStorage::LiveCount() const noexce
 	return count;
 }
 
+size_t AssetSuite::Internal::RuntimeState::BlobStorage::SlotCapacity() const noexcept
+{
+	return slots.size();
+}
+
 bool AssetSuite::Internal::RuntimeState::CodecRegistry::RegisterImageDecoder(
 	ImageDecoders decoder,
 	ImageDecoder& implementation) noexcept

source/runtime/AssetSuiteRuntimeState.h

@@ -59,19 +59,28 @@ namespace AssetSuite::Internal
 
 		struct FileLoader
 		{
-			ErrorCode LoadToMemory(const std::filesystem::path& fileName, bool isBinary, std::vector<BYTE>& output) const;
+			ErrorCode LoadToMemory(const std::filesystem::path& fileName, bool isBinary, std::vector<uint8_t>& output) const;
 		};
 
 		struct BlobStorage
 		{
 			BlobHandle Create(Blob blob);
 			bool Owns(BlobHandle blob) const noexcept;
 			bool IsLive(BlobHandle blob) const noexcept;
+			const Blob* Get(BlobHandle blob) const noexcept;
 			Result Release(BlobHandle* blob) noexcept;
 			size_t LiveCount() const noexcept;
+			size_t SlotCapacity() const noexcept;
 
 		private:
-			std::vector<std::unique_ptr<AssetSuiteBlob_t>> blobs;
+			struct Slot
+			{
+				std::unique_ptr<Blob> blob;
+				uint32_t generation = 1;
+			};
+
+			std::vector<Slot> slots;
+			std::vector<size_t> freeSlots;
 		};
 
 		struct CodecRegistry
@@ -133,7 +142,7 @@ namespace AssetSuite::Internal
 		FileInfo fileInfo;
 		ImageInfo imageInfo;
 		MeshInfo meshInfo;
-		std::vector<BYTE> rawBuffer;
+		std::vector<uint8_t> rawBuffer;
 		std::vector<BYTE> decodedBuffer;
 		std::vector<BYTE> formattedBuffer;
 		CodecStorage codecs;

source/runtime/README.md

@@ -36,9 +36,9 @@ The public SDK surface is guarded by `PublicHeaderCompile`, `PublicHeaderHygiene
 
 `Internal::Blob` stores raw asset bytes in runtime-owned memory and copies minimal source metadata into the runtime object. The metadata currently tracks the original source path, source extension, and best-known public `AssetFormat` derived from the extension when possible.
 
-`AssetSuiteBlob_t` is the private bridge behind `BlobHandle`. It owns one `Internal::Blob` while the handle is live and remains outside the installed SDK headers.
+`BlobHandle` is treated as an opaque slot/generation token by the runtime. The public type remains pointer-shaped for ABI opacity, but blob validation decodes the token and never dereferences the handle value directly.
 
-`RuntimeState::BlobStorage` owns all blob bridge objects for one context. `ReleaseBlob` clears the blob payload and nulls the caller's handle, but the inactive bridge remains in the owning context until context destruction so copied stale handles can be rejected deterministically. Handles from another context are rejected because each context validates against only its own blob storage.
+`RuntimeState::BlobStorage` owns reusable blob slots for one context. `ReleaseBlob` clears the blob payload, advances the slot generation, returns the slot to the free list, and nulls the caller's handle. Copied stale handles are rejected by generation mismatch, and handles from another context are rejected because each context validates against only its own slot table.
 
 ## Deferred Scope