Merge branch 'main' into zs/web-ui-improvements

17 files changed, 836 insertions, 202 deletions

diff --git a/src/zencore/base64.cpp b/src/zencore/base64.cpp
index 1f56ee6c3..fdf5f2d66 100644
--- a/src/zencore/base64.cpp
+++ b/src/zencore/base64.cpp
@@ -1,6 +1,10 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 #include <zencore/base64.h>
+#include <zencore/string.h>
+#include <zencore/testing.h>
+
+#include <string>
 
 namespace zen {
 
@@ -11,7 +15,6 @@ static const uint8_t EncodingAlphabet[64] = {'A', 'B', 'C', 'D', 'E', 'F', 'G',
 											 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
 
 /** The table used to convert an ascii character into a 6 bit value */
-#if 0
 static const uint8_t DecodingAlphabet[256] = {
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	 // 0x00-0x0f
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	 // 0x10-0x1f
@@ -30,7 +33,6 @@ static const uint8_t DecodingAlphabet[256] = {
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,	 // 0xe0-0xef
 	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF	 // 0xf0-0xff
 };
-#endif	// 0
 
 template<typename CharType>
 uint32_t
@@ -104,4 +106,190 @@ Base64::Encode(const uint8_t* Source, uint32_t Length, CharType* Dest)
 template uint32_t Base64::Encode<char>(const uint8_t* Source, uint32_t Length, char* Dest);
 template uint32_t Base64::Encode<wchar_t>(const uint8_t* Source, uint32_t Length, wchar_t* Dest);
 
+template<typename CharType>
+bool
+Base64::Decode(const CharType* Source, uint32_t Length, uint8_t* Dest, uint32_t& OutLength)
+{
+	// Length must be a multiple of 4
+	if (Length % 4 != 0)
+	{
+		OutLength = 0;
+		return false;
+	}
+
+	uint8_t* DecodedBytes = Dest;
+
+	// Process 4 encoded characters at a time, producing 3 decoded bytes
+	while (Length > 0)
+	{
+		// Count padding characters at the end
+		uint32_t PadCount = 0;
+		if (Source[3] == '=')
+		{
+			PadCount++;
+			if (Source[2] == '=')
+			{
+				PadCount++;
+			}
+		}
+
+		// Look up each character in the decoding table
+		uint8_t A = DecodingAlphabet[static_cast<uint8_t>(Source[0])];
+		uint8_t B = DecodingAlphabet[static_cast<uint8_t>(Source[1])];
+		uint8_t C = (PadCount >= 2) ? 0 : DecodingAlphabet[static_cast<uint8_t>(Source[2])];
+		uint8_t D = (PadCount >= 1) ? 0 : DecodingAlphabet[static_cast<uint8_t>(Source[3])];
+
+		// Check for invalid characters (0xFF means not in the base64 alphabet)
+		if (A == 0xFF || B == 0xFF || C == 0xFF || D == 0xFF)
+		{
+			OutLength = 0;
+			return false;
+		}
+
+		// Reconstruct the 24-bit value from 4 6-bit chunks
+		uint32_t ByteTriplet = (A << 18) | (B << 12) | (C << 6) | D;
+
+		// Extract the 3 bytes
+		*DecodedBytes++ = static_cast<uint8_t>(ByteTriplet >> 16);
+		if (PadCount < 2)
+		{
+			*DecodedBytes++ = static_cast<uint8_t>((ByteTriplet >> 8) & 0xFF);
+		}
+		if (PadCount < 1)
+		{
+			*DecodedBytes++ = static_cast<uint8_t>(ByteTriplet & 0xFF);
+		}
+
+		Source += 4;
+		Length -= 4;
+	}
+
+	OutLength = uint32_t(DecodedBytes - Dest);
+	return true;
+}
+
+template bool Base64::Decode<char>(const char* Source, uint32_t Length, uint8_t* Dest, uint32_t& OutLength);
+template bool Base64::Decode<wchar_t>(const wchar_t* Source, uint32_t Length, uint8_t* Dest, uint32_t& OutLength);
+
+//////////////////////////////////////////////////////////////////////////
+//
+// Testing related code follows...
+//
+
+#if ZEN_WITH_TESTS
+
+using namespace std::string_literals;
+
+TEST_CASE("Base64")
+{
+	auto EncodeString = [](std::string_view Input) -> std::string {
+		std::string Result;
+		Result.resize(Base64::GetEncodedDataSize(uint32_t(Input.size())));
+		Base64::Encode(reinterpret_cast<const uint8_t*>(Input.data()), uint32_t(Input.size()), Result.data());
+		return Result;
+	};
+
+	auto DecodeString = [](std::string_view Input) -> std::string {
+		std::string Result;
+		Result.resize(Base64::GetMaxDecodedDataSize(uint32_t(Input.size())));
+		uint32_t DecodedLength = 0;
+		bool	 Success = Base64::Decode(Input.data(), uint32_t(Input.size()), reinterpret_cast<uint8_t*>(Result.data()), DecodedLength);
+		CHECK(Success);
+		Result.resize(DecodedLength);
+		return Result;
+	};
+
+	SUBCASE("Encode")
+	{
+		CHECK(EncodeString("") == ""s);
+		CHECK(EncodeString("f") == "Zg=="s);
+		CHECK(EncodeString("fo") == "Zm8="s);
+		CHECK(EncodeString("foo") == "Zm9v"s);
+		CHECK(EncodeString("foob") == "Zm9vYg=="s);
+		CHECK(EncodeString("fooba") == "Zm9vYmE="s);
+		CHECK(EncodeString("foobar") == "Zm9vYmFy"s);
+	}
+
+	SUBCASE("Decode")
+	{
+		CHECK(DecodeString("") == ""s);
+		CHECK(DecodeString("Zg==") == "f"s);
+		CHECK(DecodeString("Zm8=") == "fo"s);
+		CHECK(DecodeString("Zm9v") == "foo"s);
+		CHECK(DecodeString("Zm9vYg==") == "foob"s);
+		CHECK(DecodeString("Zm9vYmE=") == "fooba"s);
+		CHECK(DecodeString("Zm9vYmFy") == "foobar"s);
+	}
+
+	SUBCASE("RoundTrip")
+	{
+		auto RoundTrip = [&](const std::string& Input) {
+			std::string Encoded = EncodeString(Input);
+			std::string Decoded = DecodeString(Encoded);
+			CHECK(Decoded == Input);
+		};
+
+		RoundTrip("Hello, World!");
+		RoundTrip("Base64 encoding test with various lengths");
+		RoundTrip("A");
+		RoundTrip("AB");
+		RoundTrip("ABC");
+		RoundTrip("ABCD");
+		RoundTrip("\x00\x01\x02\xff\xfe\xfd"s);
+	}
+
+	SUBCASE("BinaryRoundTrip")
+	{
+		// Test with all byte values 0-255
+		uint8_t AllBytes[256];
+		for (int i = 0; i < 256; ++i)
+		{
+			AllBytes[i] = static_cast<uint8_t>(i);
+		}
+
+		char Encoded[Base64::GetEncodedDataSize(256) + 1];
+		Base64::Encode(AllBytes, 256, Encoded);
+
+		uint8_t	 Decoded[256];
+		uint32_t DecodedLength = 0;
+		bool	 Success	   = Base64::Decode(Encoded, uint32_t(strlen(Encoded)), Decoded, DecodedLength);
+		CHECK(Success);
+		CHECK(DecodedLength == 256);
+		CHECK(memcmp(AllBytes, Decoded, 256) == 0);
+	}
+
+	SUBCASE("DecodeInvalidInput")
+	{
+		uint8_t	 Dest[64];
+		uint32_t OutLength = 0;
+
+		// Length not a multiple of 4
+		CHECK_FALSE(Base64::Decode("abc", 3u, Dest, OutLength));
+
+		// Invalid character
+		CHECK_FALSE(Base64::Decode("ab!d", 4u, Dest, OutLength));
+	}
+
+	SUBCASE("EncodedDataSize")
+	{
+		CHECK(Base64::GetEncodedDataSize(0) == 0);
+		CHECK(Base64::GetEncodedDataSize(1) == 4);
+		CHECK(Base64::GetEncodedDataSize(2) == 4);
+		CHECK(Base64::GetEncodedDataSize(3) == 4);
+		CHECK(Base64::GetEncodedDataSize(4) == 8);
+		CHECK(Base64::GetEncodedDataSize(5) == 8);
+		CHECK(Base64::GetEncodedDataSize(6) == 8);
+	}
+
+	SUBCASE("MaxDecodedDataSize")
+	{
+		CHECK(Base64::GetMaxDecodedDataSize(0) == 0);
+		CHECK(Base64::GetMaxDecodedDataSize(4) == 3);
+		CHECK(Base64::GetMaxDecodedDataSize(8) == 6);
+		CHECK(Base64::GetMaxDecodedDataSize(12) == 9);
+	}
+}
+
+#endif
+
 }  // namespace zen
diff --git a/src/zencore/compactbinaryyaml.cpp b/src/zencore/compactbinaryyaml.cpp
index 5122e952a..b308af418 100644
--- a/src/zencore/compactbinaryyaml.cpp
+++ b/src/zencore/compactbinaryyaml.cpp
@@ -14,11 +14,6 @@
 #include <string_view>
 #include <vector>
 
-ZEN_THIRD_PARTY_INCLUDES_START
-#include <ryml.hpp>
-#include <ryml_std.hpp>
-ZEN_THIRD_PARTY_INCLUDES_END
-
 namespace zen {
 
 //////////////////////////////////////////////////////////////////////////
@@ -26,193 +21,349 @@ namespace zen {
 class CbYamlWriter
 {
 public:
-	explicit CbYamlWriter(StringBuilderBase& InBuilder) : m_StrBuilder(InBuilder) { m_NodeStack.push_back(m_Tree.rootref()); }
+	explicit CbYamlWriter(StringBuilderBase& InBuilder) : m_Builder(InBuilder) {}
 
 	void WriteField(CbFieldView Field)
 	{
-		ryml::NodeRef Node;
+		CbValue		Accessor = Field.GetValue();
+		CbFieldType Type	 = Accessor.GetType();
 
-		if (m_IsFirst)
+		switch (Type)
 		{
-			Node = Top();
+			case CbFieldType::Object:
+			case CbFieldType::UniformObject:
+				WriteMapEntries(Field, 0);
+				break;
+			case CbFieldType::Array:
+			case CbFieldType::UniformArray:
+				WriteSeqEntries(Field, 0);
+				break;
+			default:
+				WriteScalarValue(Field);
+				m_Builder << '\n';
+				break;
+		}
+	}
+
+	void WriteMapEntry(CbFieldView Field, int32_t Indent)
+	{
+		WriteIndent(Indent);
+		WriteMapEntryContent(Field, Indent);
+	}
+
+	void WriteSeqEntry(CbFieldView Field, int32_t Indent)
+	{
+		CbValue		Accessor = Field.GetValue();
+		CbFieldType Type	 = Accessor.GetType();
 
-			m_IsFirst = false;
+		if (Type == CbFieldType::Object || Type == CbFieldType::UniformObject)
+		{
+			bool First = true;
+			for (CbFieldView MapChild : Field)
+			{
+				if (First)
+				{
+					WriteIndent(Indent);
+					m_Builder << "- ";
+					First = false;
+				}
+				else
+				{
+					WriteIndent(Indent + 1);
+				}
+				WriteMapEntryContent(MapChild, Indent + 1);
+			}
+		}
+		else if (Type == CbFieldType::Array || Type == CbFieldType::UniformArray)
+		{
+			WriteIndent(Indent);
+			m_Builder << "-\n";
+			WriteSeqEntries(Field, Indent + 1);
 		}
 		else
 		{
-			Node = Top().append_child();
+			WriteIndent(Indent);
+			m_Builder << "- ";
+			WriteScalarValue(Field);
+			m_Builder << '\n';
 		}
+	}
 
-		if (std::u8string_view Name = Field.GetU8Name(); !Name.empty())
+private:
+	void WriteMapEntries(CbFieldView MapField, int32_t Indent)
+	{
+		for (CbFieldView Child : MapField)
 		{
-			Node.set_key_serialized(ryml::csubstr((const char*)Name.data(), Name.size()));
+			WriteIndent(Indent);
+			WriteMapEntryContent(Child, Indent);
 		}
+	}
+
+	void WriteMapEntryContent(CbFieldView Field, int32_t Indent)
+	{
+		std::u8string_view Name = Field.GetU8Name();
+		m_Builder << std::string_view(reinterpret_cast<const char*>(Name.data()), Name.size());
 
-		switch (CbValue Accessor = Field.GetValue(); Accessor.GetType())
+		CbValue		Accessor = Field.GetValue();
+		CbFieldType Type	 = Accessor.GetType();
+
+		if (IsContainer(Type))
 		{
-			case CbFieldType::Null:
-				Node.set_val("null");
-				break;
-			case CbFieldType::Object:
-			case CbFieldType::UniformObject:
-				Node |= ryml::MAP;
-				m_NodeStack.push_back(Node);
-				for (CbFieldView It : Field)
+			m_Builder << ":\n";
+			WriteFieldValue(Field, Indent + 1);
+		}
+		else
+		{
+			m_Builder << ": ";
+			WriteScalarValue(Field);
+			m_Builder << '\n';
+		}
+	}
+
+	void WriteSeqEntries(CbFieldView SeqField, int32_t Indent)
+	{
+		for (CbFieldView Child : SeqField)
+		{
+			CbValue		Accessor = Child.GetValue();
+			CbFieldType Type	 = Accessor.GetType();
+
+			if (Type == CbFieldType::Object || Type == CbFieldType::UniformObject)
+			{
+				bool First = true;
+				for (CbFieldView MapChild : Child)
 				{
-					WriteField(It);
+					if (First)
+					{
+						WriteIndent(Indent);
+						m_Builder << "- ";
+						First = false;
+					}
+					else
+					{
+						WriteIndent(Indent + 1);
+					}
+					WriteMapEntryContent(MapChild, Indent + 1);
 				}
-				m_NodeStack.pop_back();
+			}
+			else if (Type == CbFieldType::Array || Type == CbFieldType::UniformArray)
+			{
+				WriteIndent(Indent);
+				m_Builder << "-\n";
+				WriteSeqEntries(Child, Indent + 1);
+			}
+			else
+			{
+				WriteIndent(Indent);
+				m_Builder << "- ";
+				WriteScalarValue(Child);
+				m_Builder << '\n';
+			}
+		}
+	}
+
+	void WriteFieldValue(CbFieldView Field, int32_t Indent)
+	{
+		CbValue		Accessor = Field.GetValue();
+		CbFieldType Type	 = Accessor.GetType();
+
+		switch (Type)
+		{
+			case CbFieldType::Object:
+			case CbFieldType::UniformObject:
+				WriteMapEntries(Field, Indent);
 				break;
 			case CbFieldType::Array:
 			case CbFieldType::UniformArray:
-				Node |= ryml::SEQ;
-				m_NodeStack.push_back(Node);
-				for (CbFieldView It : Field)
-				{
-					WriteField(It);
-				}
-				m_NodeStack.pop_back();
+				WriteSeqEntries(Field, Indent);
 				break;
-			case CbFieldType::Binary:
-				{
-					ExtendableStringBuilder<256> Builder;
-					const MemoryView			 Value = Accessor.AsBinary();
-					ZEN_ASSERT(Value.GetSize() <= 512 * 1024 * 1024);
-					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);
-
-					Node.set_key_serialized(Builder.c_str());
-				}
+			case CbFieldType::CustomById:
+				WriteCustomById(Field.GetValue().AsCustomById(), Indent);
 				break;
-			case CbFieldType::String:
-				{
-					const std::u8string_view U8String = Accessor.AsU8String();
-					Node.set_val(ryml::csubstr((const char*)U8String.data(), U8String.size()));
-				}
+			case CbFieldType::CustomByName:
+				WriteCustomByName(Field.GetValue().AsCustomByName(), Indent);
+				break;
+			default:
+				WriteScalarValue(Field);
+				m_Builder << '\n';
+				break;
+		}
+	}
+
+	void WriteScalarValue(CbFieldView Field)
+	{
+		CbValue Accessor = Field.GetValue();
+		switch (Accessor.GetType())
+		{
+			case CbFieldType::Null:
+				m_Builder << "null";
+				break;
+			case CbFieldType::BoolFalse:
+				m_Builder << "false";
+				break;
+			case CbFieldType::BoolTrue:
+				m_Builder << "true";
 				break;
 			case CbFieldType::IntegerPositive:
-				Node << Accessor.AsIntegerPositive();
+				m_Builder << Accessor.AsIntegerPositive();
 				break;
 			case CbFieldType::IntegerNegative:
-				Node << Accessor.AsIntegerNegative();
+				m_Builder << Accessor.AsIntegerNegative();
 				break;
 			case CbFieldType::Float32:
 				if (const float Value = Accessor.AsFloat32(); std::isfinite(Value))
-				{
-					Node << Value;
-				}
+					m_Builder.Append(fmt::format("{}", Value));
 				else
-				{
-					Node << "null";
-				}
+					m_Builder << "null";
 				break;
 			case CbFieldType::Float64:
 				if (const double Value = Accessor.AsFloat64(); std::isfinite(Value))
-				{
-					Node << Value;
-				}
+					m_Builder.Append(fmt::format("{}", Value));
 				else
+					m_Builder << "null";
+				break;
+			case CbFieldType::String:
 				{
-					Node << "null";
+					const std::u8string_view U8String = Accessor.AsU8String();
+					WriteString(std::string_view(reinterpret_cast<const char*>(U8String.data()), U8String.size()));
 				}
 				break;
-			case CbFieldType::BoolFalse:
-				Node << "false";
-				break;
-			case CbFieldType::BoolTrue:
-				Node << "true";
+			case CbFieldType::Hash:
+				WriteString(Accessor.AsHash().ToHexString());
 				break;
 			case CbFieldType::ObjectAttachment:
 			case CbFieldType::BinaryAttachment:
-				Node << Accessor.AsAttachment().ToHexString();
-				break;
-			case CbFieldType::Hash:
-				Node << Accessor.AsHash().ToHexString();
+				WriteString(Accessor.AsAttachment().ToHexString());
 				break;
 			case CbFieldType::Uuid:
-				Node << fmt::format("{}", Accessor.AsUuid());
+				WriteString(fmt::format("{}", Accessor.AsUuid()));
 				break;
 			case CbFieldType::DateTime:
-				Node << DateTime(Accessor.AsDateTimeTicks()).ToIso8601();
+				WriteString(DateTime(Accessor.AsDateTimeTicks()).ToIso8601());
 				break;
 			case CbFieldType::TimeSpan:
 				if (const TimeSpan Span(Accessor.AsTimeSpanTicks()); Span.GetDays() == 0)
-				{
-					Node << Span.ToString("%h:%m:%s.%n");
-				}
+					WriteString(Span.ToString("%h:%m:%s.%n"));
 				else
-				{
-					Node << Span.ToString("%d.%h:%m:%s.%n");
-				}
+					WriteString(Span.ToString("%d.%h:%m:%s.%n"));
 				break;
 			case CbFieldType::ObjectId:
-				Node << fmt::format("{}", Accessor.AsObjectId());
+				WriteString(fmt::format("{}", Accessor.AsObjectId()));
 				break;
-			case CbFieldType::CustomById:
-				{
-					CbCustomById Custom = Accessor.AsCustomById();
+			case CbFieldType::Binary:
+				WriteBase64(Accessor.AsBinary());
+				break;
+			default:
+				ZEN_ASSERT_FORMAT(false, "invalid field type: {}", uint8_t(Accessor.GetType()));
+				break;
+		}
+	}
 
-					Node |= ryml::MAP;
+	void WriteCustomById(CbCustomById Custom, int32_t Indent)
+	{
+		WriteIndent(Indent);
+		m_Builder << "Id: ";
+		m_Builder.Append(fmt::format("{}", Custom.Id));
+		m_Builder << '\n';
+
+		WriteIndent(Indent);
+		m_Builder << "Data: ";
+		WriteBase64(Custom.Data);
+		m_Builder << '\n';
+	}
 
-					ryml::NodeRef IdNode = Node.append_child();
-					IdNode.set_key("Id");
-					IdNode.set_val_serialized(fmt::format("{}", Custom.Id));
+	void WriteCustomByName(CbCustomByName Custom, int32_t Indent)
+	{
+		WriteIndent(Indent);
+		m_Builder << "Name: ";
+		WriteString(std::string_view(reinterpret_cast<const char*>(Custom.Name.data()), Custom.Name.size()));
+		m_Builder << '\n';
+
+		WriteIndent(Indent);
+		m_Builder << "Data: ";
+		WriteBase64(Custom.Data);
+		m_Builder << '\n';
+	}
 
-					ryml::NodeRef DataNode = Node.append_child();
-					DataNode.set_key("Data");
+	void WriteBase64(MemoryView Value)
+	{
+		ZEN_ASSERT(Value.GetSize() <= 512 * 1024 * 1024);
+		ExtendableStringBuilder<256> Buf;
+		const uint32_t				 EncodedSize  = Base64::GetEncodedDataSize(uint32_t(Value.GetSize()));
+		const size_t				 EncodedIndex = Buf.AddUninitialized(size_t(EncodedSize));
+		Base64::Encode(static_cast<const uint8_t*>(Value.GetData()), uint32_t(Value.GetSize()), Buf.Data() + EncodedIndex);
+		WriteString(Buf.ToView());
+	}
 
-					ExtendableStringBuilder<256> Builder;
-					const MemoryView&			 Value		  = Custom.Data;
-					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);
+	void WriteString(std::string_view Str)
+	{
+		if (NeedsQuoting(Str))
+		{
+			m_Builder << '\'';
+			for (char C : Str)
+			{
+				if (C == '\'')
+					m_Builder << "''";
+				else
+					m_Builder << C;
+			}
+			m_Builder << '\'';
+		}
+		else
+		{
+			m_Builder << Str;
+		}
+	}
 
-					DataNode.set_val_serialized(Builder.c_str());
-				}
-				break;
-			case CbFieldType::CustomByName:
-				{
-					CbCustomByName Custom = Accessor.AsCustomByName();
+	void WriteIndent(int32_t Indent)
+	{
+		for (int32_t I = 0; I < Indent; ++I)
+			m_Builder << "  ";
+	}
 
-					Node |= ryml::MAP;
+	static bool NeedsQuoting(std::string_view Str)
+	{
+		if (Str.empty())
+			return false;
 
-					ryml::NodeRef NameNode = Node.append_child();
-					NameNode.set_key("Name");
-					std::string_view Name = std::string_view((const char*)Custom.Name.data(), Custom.Name.size());
-					NameNode.set_val_serialized(std::string(Name));
+		char First = Str[0];
+		if (First == ' ' || First == '\n' || First == '\t' || First == '\r' || First == '*' || First == '&' || First == '%' ||
+			First == '@' || First == '`')
+			return true;
 
-					ryml::NodeRef DataNode = Node.append_child();
-					DataNode.set_key("Data");
+		if (Str.size() >= 2 && Str[0] == '<' && Str[1] == '<')
+			return true;
 
-					ExtendableStringBuilder<256> Builder;
-					const MemoryView&			 Value		  = Custom.Data;
-					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);
+		char Last = Str.back();
+		if (Last == ' ' || Last == '\n' || Last == '\t' || Last == '\r')
+			return true;
 
-					DataNode.set_val_serialized(Builder.c_str());
-				}
-				break;
-			default:
-				ZEN_ASSERT_FORMAT(false, "invalid field type: {}", uint8_t(Accessor.GetType()));
-				break;
+		for (char C : Str)
+		{
+			if (C == '#' || C == ':' || C == '-' || C == '?' || C == ',' || C == '\n' || C == '{' || C == '}' || C == '[' || C == ']' ||
+				C == '\'' || C == '"')
+				return true;
 		}
 
-		if (m_NodeStack.size() == 1)
+		return false;
+	}
+
+	static bool IsContainer(CbFieldType Type)
+	{
+		switch (Type)
 		{
-			std::string Yaml = ryml::emitrs_yaml<std::string>(m_Tree);
-			m_StrBuilder << Yaml;
+			case CbFieldType::Object:
+			case CbFieldType::UniformObject:
+			case CbFieldType::Array:
+			case CbFieldType::UniformArray:
+			case CbFieldType::CustomById:
+			case CbFieldType::CustomByName:
+				return true;
+			default:
+				return false;
 		}
 	}
 
-private:
-	StringBuilderBase& m_StrBuilder;
-	bool			   m_IsFirst = true;
-
-	ryml::Tree				   m_Tree;
-	std::vector<ryml::NodeRef> m_NodeStack;
-	ryml::NodeRef&			   Top() { return m_NodeStack.back(); }
+	StringBuilderBase& m_Builder;
 };
 
 void
@@ -229,6 +380,32 @@ CompactBinaryToYaml(const CbArrayView& Array, StringBuilderBase& Builder)
 	Writer.WriteField(Array.AsFieldView());
 }
 
+void
+CompactBinaryToYaml(MemoryView Data, StringBuilderBase& InBuilder)
+{
+	std::vector<CbFieldView> Fields = ReadCompactBinaryStream(Data);
+	if (Fields.empty())
+		return;
+
+	CbYamlWriter Writer(InBuilder);
+	if (Fields.size() == 1)
+	{
+		Writer.WriteField(Fields[0]);
+		return;
+	}
+
+	if (Fields[0].HasName())
+	{
+		for (const CbFieldView& Field : Fields)
+			Writer.WriteMapEntry(Field, 0);
+	}
+	else
+	{
+		for (const CbFieldView& Field : Fields)
+			Writer.WriteSeqEntry(Field, 0);
+	}
+}
+
 #if ZEN_WITH_TESTS
 void
 cbyaml_forcelink()
diff --git a/src/zencore/filesystem.cpp b/src/zencore/filesystem.cpp
index 92a065707..553897407 100644
--- a/src/zencore/filesystem.cpp
+++ b/src/zencore/filesystem.cpp
@@ -1326,11 +1326,6 @@ ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uin
 		{
 			BytesRead = size_t(dwNumberOfBytesRead);
 		}
-		else if ((BytesRead != NumberOfBytesToRead))
-		{
-			Ec = MakeErrorCode(ERROR_HANDLE_EOF);
-			return;
-		}
 		else
 		{
 			Ec = MakeErrorCodeFromLastError();
@@ -1344,20 +1339,15 @@ ReadFile(void* NativeHandle, void* Data, uint64_t Size, uint64_t FileOffset, uin
 		{
 			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;
+		Size -= BytesRead;
+		FileOffset += BytesRead;
+		Data = reinterpret_cast<uint8_t*>(Data) + BytesRead;
 	}
 }
 
@@ -3069,7 +3059,7 @@ SetFileReadOnly(const std::filesystem::path& Filename, bool ReadOnly)
 }
 
 void
-MakeSafeAbsolutePathÍnPlace(std::filesystem::path& Path)
+MakeSafeAbsolutePathInPlace(std::filesystem::path& Path)
 {
 	if (!Path.empty())
 	{
@@ -3091,7 +3081,7 @@ std::filesystem::path
 MakeSafeAbsolutePath(const std::filesystem::path& Path)
 {
 	std::filesystem::path Tmp(Path);
-	MakeSafeAbsolutePathÍnPlace(Tmp);
+	MakeSafeAbsolutePathInPlace(Tmp);
 	return Tmp;
 }
 
diff --git a/src/zencore/include/zencore/base64.h b/src/zencore/include/zencore/base64.h
index 4d78b085f..08d9f3043 100644
--- a/src/zencore/include/zencore/base64.h
+++ b/src/zencore/include/zencore/base64.h
@@ -11,7 +11,11 @@ struct Base64
 	template<typename CharType>
 	static uint32_t Encode(const uint8_t* Source, uint32_t Length, CharType* Dest);
 
+	template<typename CharType>
+	static bool Decode(const CharType* Source, uint32_t Length, uint8_t* Dest, uint32_t& OutLength);
+
 	static inline constexpr int32_t GetEncodedDataSize(uint32_t Size) { return ((Size + 2) / 3) * 4; }
+	static inline constexpr int32_t GetMaxDecodedDataSize(uint32_t Length) { return (Length / 4) * 3; }
 };
 
 }  // namespace zen
diff --git a/src/zencore/include/zencore/compactbinaryvalue.h b/src/zencore/include/zencore/compactbinaryvalue.h
index aa2d2821d..4ce8009b8 100644
--- a/src/zencore/include/zencore/compactbinaryvalue.h
+++ b/src/zencore/include/zencore/compactbinaryvalue.h
@@ -128,17 +128,21 @@ CbValue::AsString(CbFieldError* OutError, std::string_view Default) const
 	uint32_t		  ValueSizeByteCount;
 	const uint64_t	  ValueSize = ReadVarUInt(Chars, ValueSizeByteCount);
 
-	if (OutError)
+	if (ValueSize >= (uint64_t(1) << 31))
 	{
-		if (ValueSize >= (uint64_t(1) << 31))
+		if (OutError)
 		{
 			*OutError = CbFieldError::RangeError;
-			return Default;
 		}
+		return Default;
+	}
+
+	if (OutError)
+	{
 		*OutError = CbFieldError::None;
 	}
 
-	return std::string_view(Chars + ValueSizeByteCount, int32_t(ValueSize));
+	return std::string_view(Chars + ValueSizeByteCount, size_t(ValueSize));
 }
 
 inline std::u8string_view
@@ -148,17 +152,21 @@ CbValue::AsU8String(CbFieldError* OutError, std::u8string_view Default) const
 	uint32_t			 ValueSizeByteCount;
 	const uint64_t		 ValueSize = ReadVarUInt(Chars, ValueSizeByteCount);
 
-	if (OutError)
+	if (ValueSize >= (uint64_t(1) << 31))
 	{
-		if (ValueSize >= (uint64_t(1) << 31))
+		if (OutError)
 		{
 			*OutError = CbFieldError::RangeError;
-			return Default;
 		}
+		return Default;
+	}
+
+	if (OutError)
+	{
 		*OutError = CbFieldError::None;
 	}
 
-	return std::u8string_view(Chars + ValueSizeByteCount, int32_t(ValueSize));
+	return std::u8string_view(Chars + ValueSizeByteCount, size_t(ValueSize));
 }
 
 inline uint64_t
diff --git a/src/zencore/include/zencore/filesystem.h b/src/zencore/include/zencore/filesystem.h
index f28863679..16e2b59f8 100644
--- a/src/zencore/include/zencore/filesystem.h
+++ b/src/zencore/include/zencore/filesystem.h
@@ -64,80 +64,80 @@ std::filesystem::path PathFromHandle(void* NativeHandle, std::error_code& Ec);
  */
 std::filesystem::path CanonicalPath(std::filesystem::path InPath, std::error_code& Ec);
 
-/** Query file size
+/** Check if a path exists and is a regular file (throws)
  */
 bool IsFile(const std::filesystem::path& Path);
 
-/** Query file size
+/** Check if a path exists and is a regular file (does not throw)
  */
 bool IsFile(const std::filesystem::path& Path, std::error_code& Ec);
 
-/** Query file size
+/** Check if a path exists and is a directory (throws)
  */
 bool IsDir(const std::filesystem::path& Path);
 
-/** Query file size
+/** Check if a path exists and is a directory (does not throw)
  */
 bool IsDir(const std::filesystem::path& Path, std::error_code& Ec);
 
-/** Query file size
+/** Delete file at path, if it exists (throws)
  */
 bool RemoveFile(const std::filesystem::path& Path);
 
-/** Query file size
+/** Delete file at path, if it exists (does not throw)
  */
 bool RemoveFile(const std::filesystem::path& Path, std::error_code& Ec);
 
-/** Query file size
+/** Delete directory at path, if it exists (throws)
  */
 bool RemoveDir(const std::filesystem::path& Path);
 
-/** Query file size
+/** Delete directory at path, if it exists (does not throw)
  */
 bool RemoveDir(const std::filesystem::path& Path, std::error_code& Ec);
 
-/** Query file size
+/** Query file size (throws)
  */
 uint64_t FileSizeFromPath(const std::filesystem::path& Path);
 
-/** Query file size
+/** Query file size (does not throw)
  */
 uint64_t FileSizeFromPath(const std::filesystem::path& Path, std::error_code& Ec);
 
-/** Query file size from native file handle
+/** Query file size from native file handle (throws)
  */
 uint64_t FileSizeFromHandle(void* NativeHandle);
 
-/** Query file size from native file handle
+/** Query file size from native file handle (does not throw)
  */
 uint64_t FileSizeFromHandle(void* NativeHandle, std::error_code& Ec);
 
 /** Get a native time tick of last modification time
  */
-uint64_t GetModificationTickFromHandle(void* NativeHandle, std::error_code& Ec);
+uint64_t GetModificationTickFromPath(const std::filesystem::path& Filename);
 
 /** Get a native time tick of last modification time
  */
-uint64_t GetModificationTickFromPath(const std::filesystem::path& Filename);
+uint64_t GetModificationTickFromHandle(void* NativeHandle, std::error_code& Ec);
 
 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
+/** Move/rename a file, if the files are not on the same drive the function will fail (throws)
  */
 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
+/** Move/rename a file, if the files are not on the same drive the function will fail
  */
 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
+/** Move/rename a directory, if the files are not on the same drive the function will fail (throws)
  */
 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
+/** Move/rename a directory, if the files are not on the same drive the function will fail
  */
 void RenameDirectory(const std::filesystem::path& SourcePath, const std::filesystem::path& TargetPath, std::error_code& Ec);
 
@@ -421,7 +421,7 @@ 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);
 
-void								MakeSafeAbsolutePathÍnPlace(std::filesystem::path& Path);
+void								MakeSafeAbsolutePathInPlace(std::filesystem::path& Path);
 [[nodiscard]] std::filesystem::path MakeSafeAbsolutePath(const std::filesystem::path& Path);
 
 class SharedMemory
diff --git a/src/zencore/include/zencore/hashutils.h b/src/zencore/include/zencore/hashutils.h
index 4e877e219..6b9902b3a 100644
--- a/src/zencore/include/zencore/hashutils.h
+++ b/src/zencore/include/zencore/hashutils.h
@@ -2,6 +2,9 @@
 
 #pragma once
 
+#include <cstddef>
+#include <type_traits>
+
 namespace zen {
 
 template<typename T>
diff --git a/src/zencore/include/zencore/iobuffer.h b/src/zencore/include/zencore/iobuffer.h
index 182768ff6..82c201edd 100644
--- a/src/zencore/include/zencore/iobuffer.h
+++ b/src/zencore/include/zencore/iobuffer.h
@@ -426,22 +426,39 @@ private:
 class IoBufferBuilder
 {
 public:
-	static IoBuffer MakeFromFile(const std::filesystem::path& FileName, uint64_t Offset = 0, uint64_t Size = ~0ull);
-	static IoBuffer MakeFromTemporaryFile(const std::filesystem::path& FileName);
-	static IoBuffer MakeFromFileHandle(void* FileHandle, uint64_t Offset = 0, uint64_t Size = ~0ull);
-	/** Make sure buffer data is memory resident, but avoid memory mapping data from files
-	 */
-	static IoBuffer		   ReadFromFileMaybe(const IoBuffer& InBuffer);
-	inline static IoBuffer MakeFromMemory(MemoryView Memory) { return IoBuffer(IoBuffer::Wrap, Memory.GetData(), Memory.GetSize()); }
-	inline static IoBuffer MakeCloneFromMemory(const void* Ptr, size_t Sz)
+	static IoBuffer MakeFromFile(const std::filesystem::path& FileName,
+								 uint64_t					  Offset	  = 0,
+								 uint64_t					  Size		  = ~0ull,
+								 ZenContentType				  ContentType = ZenContentType::kBinary);
+	static IoBuffer MakeFromTemporaryFile(const std::filesystem::path& FileName, ZenContentType ContentType = ZenContentType::kBinary);
+	static IoBuffer MakeFromFileHandle(void*		  FileHandle,
+									   uint64_t		  Offset	  = 0,
+									   uint64_t		  Size		  = ~0ull,
+									   ZenContentType ContentType = ZenContentType::kBinary);
+	inline static IoBuffer MakeFromMemory(MemoryView Memory, ZenContentType ContentType = ZenContentType::kBinary)
+	{
+		IoBuffer NewBuffer(IoBuffer::Wrap, Memory.GetData(), Memory.GetSize());
+		NewBuffer.SetContentType(ContentType);
+		return NewBuffer;
+	}
+	inline static IoBuffer MakeCloneFromMemory(const void* Ptr, size_t Sz, ZenContentType ContentType = ZenContentType::kBinary)
 	{
 		if (Sz)
 		{
-			return IoBuffer(IoBuffer::Clone, Ptr, Sz);
+			IoBuffer NewBuffer(IoBuffer::Clone, Ptr, Sz);
+			NewBuffer.SetContentType(ContentType);
+			return NewBuffer;
 		}
 		return {};
 	}
-	inline static IoBuffer MakeCloneFromMemory(MemoryView Memory) { return MakeCloneFromMemory(Memory.GetData(), Memory.GetSize()); }
+	inline static IoBuffer MakeCloneFromMemory(MemoryView Memory, ZenContentType ContentType = ZenContentType::kBinary)
+	{
+		return MakeCloneFromMemory(Memory.GetData(), Memory.GetSize(), ContentType);
+	}
+
+	/** Make sure buffer data is memory resident, but avoid memory mapping data from files
+	 */
+	static IoBuffer ReadFromFileMaybe(const IoBuffer& InBuffer);
 };
 
 void iobuffer_forcelink();
diff --git a/src/zencore/include/zencore/process.h b/src/zencore/include/zencore/process.h
index e3b7a70d7..c51163a68 100644
--- a/src/zencore/include/zencore/process.h
+++ b/src/zencore/include/zencore/process.h
@@ -105,6 +105,7 @@ int	 GetCurrentProcessId();
 int	 GetProcessId(CreateProcResult ProcId);
 
 std::filesystem::path GetProcessExecutablePath(int Pid, std::error_code& OutEc);
+std::string			  GetProcessCommandLine(int Pid, std::error_code& OutEc);
 std::error_code		  FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle, bool IncludeSelf = true);
 
 /** Wait for all threads in the current process to exit (except the calling thread)
diff --git a/src/zencore/include/zencore/sharedbuffer.h b/src/zencore/include/zencore/sharedbuffer.h
index c57e9f568..3d4c19282 100644
--- a/src/zencore/include/zencore/sharedbuffer.h
+++ b/src/zencore/include/zencore/sharedbuffer.h
@@ -116,14 +116,15 @@ public:
 	inline void				  Reset() { m_Buffer = nullptr; }
 	inline bool				  GetFileReference(IoBufferFileReference& OutRef) const
 	{
-		if (const IoBufferExtendedCore* Core = m_Buffer->ExtendedCore())
+		if (!IsNull())
 		{
-			return Core->GetFileReference(OutRef);
-		}
-		else
-		{
-			return false;
+			if (const IoBufferExtendedCore* Core = m_Buffer->ExtendedCore())
+			{
+				return Core->GetFileReference(OutRef);
+			}
 		}
+
+		return false;
 	}
 
 	[[nodiscard]] MemoryView GetView() const
diff --git a/src/zencore/intmath.cpp b/src/zencore/intmath.cpp
index 5a686dc8e..32f82b486 100644
--- a/src/zencore/intmath.cpp
+++ b/src/zencore/intmath.cpp
@@ -43,6 +43,12 @@ TEST_CASE("intmath")
 	CHECK(FloorLog2_64(0x0000'0001'0000'0000ull) == 32);
 	CHECK(FloorLog2_64(0x8000'0000'0000'0000ull) == 63);
 
+	CHECK(CountLeadingZeros(0x8000'0000u) == 0);
+	CHECK(CountLeadingZeros(0x0000'0000u) == 32);
+	CHECK(CountLeadingZeros(0x0000'0001u) == 31);
+	CHECK(CountLeadingZeros(0x0000'8000u) == 16);
+	CHECK(CountLeadingZeros(0x0001'0000u) == 15);
+
 	CHECK(CountLeadingZeros64(0x8000'0000'0000'0000ull) == 0);
 	CHECK(CountLeadingZeros64(0x0000'0000'0000'0000ull) == 64);
 	CHECK(CountLeadingZeros64(0x0000'0000'0000'0001ull) == 63);
diff --git a/src/zencore/iobuffer.cpp b/src/zencore/iobuffer.cpp
index be9b39e7a..1c31d6620 100644
--- a/src/zencore/iobuffer.cpp
+++ b/src/zencore/iobuffer.cpp
@@ -592,15 +592,17 @@ IoBufferBuilder::ReadFromFileMaybe(const IoBuffer& InBuffer)
 }
 
 IoBuffer
-IoBufferBuilder::MakeFromFileHandle(void* FileHandle, uint64_t Offset, uint64_t Size)
+IoBufferBuilder::MakeFromFileHandle(void* FileHandle, uint64_t Offset, uint64_t Size, ZenContentType ContentType)
 {
 	ZEN_TRACE_CPU("IoBufferBuilder::MakeFromFileHandle");
 
-	return IoBuffer(IoBuffer::BorrowedFile, FileHandle, Offset, Size);
+	IoBuffer Buffer(IoBuffer::BorrowedFile, FileHandle, Offset, Size);
+	Buffer.SetContentType(ContentType);
+	return Buffer;
 }
 
 IoBuffer
-IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Offset, uint64_t Size)
+IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Offset, uint64_t Size, ZenContentType ContentType)
 {
 	ZEN_TRACE_CPU("IoBufferBuilder::MakeFromFile");
 
@@ -632,8 +634,6 @@ IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Of
 	FileSize = Stat.st_size;
 #endif	// ZEN_PLATFORM_WINDOWS
 
-	// TODO: should validate that offset is in range
-
 	if (Size == ~0ull)
 	{
 		Size = FileSize - Offset;
@@ -652,7 +652,9 @@ IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Of
 #if ZEN_PLATFORM_WINDOWS
 		void* Fd = DataFile.Detach();
 #endif
-		return IoBuffer(IoBuffer::File, (void*)uintptr_t(Fd), Offset, Size, Offset == 0 && Size == FileSize);
+		IoBuffer NewBuffer(IoBuffer::File, (void*)uintptr_t(Fd), Offset, Size, Offset == 0 && Size == FileSize);
+		NewBuffer.SetContentType(ContentType);
+		return NewBuffer;
 	}
 
 #if !ZEN_PLATFORM_WINDOWS
@@ -664,7 +666,7 @@ IoBufferBuilder::MakeFromFile(const std::filesystem::path& FileName, uint64_t Of
 }
 
 IoBuffer
-IoBufferBuilder::MakeFromTemporaryFile(const std::filesystem::path& FileName)
+IoBufferBuilder::MakeFromTemporaryFile(const std::filesystem::path& FileName, ZenContentType ContentType)
 {
 	ZEN_TRACE_CPU("IoBufferBuilder::MakeFromTemporaryFile");
 
@@ -703,7 +705,9 @@ IoBufferBuilder::MakeFromTemporaryFile(const std::filesystem::path& FileName)
 	Handle = (void*)uintptr_t(Fd);
 #endif	// ZEN_PLATFORM_WINDOWS
 
-	return IoBuffer(IoBuffer::File, Handle, 0, FileSize, /*IsWholeFile*/ true);
+	IoBuffer NewBuffer(IoBuffer::File, Handle, 0, FileSize, /*IsWholeFile*/ true);
+	NewBuffer.SetContentType(ContentType);
+	return NewBuffer;
 }
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/src/zencore/memtrack/callstacktrace.cpp b/src/zencore/memtrack/callstacktrace.cpp
index a5b7fede6..4a7068568 100644
--- a/src/zencore/memtrack/callstacktrace.cpp
+++ b/src/zencore/memtrack/callstacktrace.cpp
@@ -169,13 +169,13 @@ private:
 		std::atomic_uint64_t Key;
 		std::atomic_uint32_t Value;
 
-		inline uint64	GetKey() const { return Key.load(std::memory_order_relaxed); }
+		inline uint64	GetKey() const { return Key.load(std::memory_order_acquire); }
 		inline uint32_t GetValue() const { return Value.load(std::memory_order_relaxed); }
-		inline bool		IsEmpty() const { return Key.load(std::memory_order_relaxed) == 0; }
+		inline bool		IsEmpty() const { return Key.load(std::memory_order_acquire) == 0; }
 		inline void		SetKeyValue(uint64_t InKey, uint32_t InValue)
 		{
-			Value.store(InValue, std::memory_order_release);
-			Key.store(InKey, std::memory_order_relaxed);
+			Value.store(InValue, std::memory_order_relaxed);
+			Key.store(InKey, std::memory_order_release);
 		}
 		static inline uint32_t KeyHash(uint64_t Key) { return static_cast<uint32_t>(Key); }
 		static inline void	   ClearEntries(FEncounteredCallstackSetEntry* Entries, int32_t EntryCount)
diff --git a/src/zencore/process.cpp b/src/zencore/process.cpp
index 56849a10d..4a2668912 100644
--- a/src/zencore/process.cpp
+++ b/src/zencore/process.cpp
@@ -1001,6 +1001,232 @@ GetProcessExecutablePath(int Pid, std::error_code& OutEc)
 #endif	// ZEN_PLATFORM_LINUX
 }
 
+std::string
+GetProcessCommandLine(int Pid, std::error_code& OutEc)
+{
+#if ZEN_PLATFORM_WINDOWS
+	HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, static_cast<DWORD>(Pid));
+	if (!hProcess)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+	auto _ = MakeGuard([hProcess] { CloseHandle(hProcess); });
+
+	// NtQueryInformationProcess is an undocumented NT API; load it dynamically.
+	// Info class 60 = ProcessCommandLine, available since Windows 8.1.
+	using PFN_NtQIP = LONG(WINAPI*)(HANDLE, UINT, PVOID, ULONG, PULONG);
+	static const PFN_NtQIP s_NtQIP =
+		reinterpret_cast<PFN_NtQIP>(GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQueryInformationProcess"));
+	if (!s_NtQIP)
+	{
+		return {};
+	}
+
+	constexpr UINT ProcessCommandLineClass	= 60;
+	constexpr LONG StatusInfoLengthMismatch = static_cast<LONG>(0xC0000004L);
+
+	ULONG ReturnLength = 0;
+	LONG  Status	   = s_NtQIP(hProcess, ProcessCommandLineClass, nullptr, 0, &ReturnLength);
+	if (Status != StatusInfoLengthMismatch || ReturnLength == 0)
+	{
+		return {};
+	}
+
+	std::vector<char> Buf(ReturnLength);
+	Status = s_NtQIP(hProcess, ProcessCommandLineClass, Buf.data(), ReturnLength, &ReturnLength);
+	if (Status < 0)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+
+	// Output: UNICODE_STRING header immediately followed by the UTF-16 string data.
+	// The UNICODE_STRING.Buffer field points into our Buf.
+	struct LocalUnicodeString
+	{
+		USHORT Length;
+		USHORT MaximumLength;
+		WCHAR* Buffer;
+	};
+	if (ReturnLength < sizeof(LocalUnicodeString))
+	{
+		return {};
+	}
+	const auto* Us = reinterpret_cast<const LocalUnicodeString*>(Buf.data());
+	if (Us->Length == 0 || Us->Buffer == nullptr)
+	{
+		return {};
+	}
+
+	// Skip argv[0]: may be a quoted path ("C:\...\exe.exe") or a bare path
+	const WCHAR* p	 = Us->Buffer;
+	const WCHAR* End = Us->Buffer + Us->Length / sizeof(WCHAR);
+	if (p < End && *p == L'"')
+	{
+		++p;
+		while (p < End && *p != L'"')
+		{
+			++p;
+		}
+		if (p < End)
+		{
+			++p;  // skip closing quote
+		}
+	}
+	else
+	{
+		while (p < End && *p != L' ')
+		{
+			++p;
+		}
+	}
+	while (p < End && *p == L' ')
+	{
+		++p;
+	}
+	if (p >= End)
+	{
+		return {};
+	}
+
+	int Utf8Size = WideCharToMultiByte(CP_UTF8, 0, p, static_cast<int>(End - p), nullptr, 0, nullptr, nullptr);
+	if (Utf8Size <= 0)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+	std::string Result(Utf8Size, '\0');
+	WideCharToMultiByte(CP_UTF8, 0, p, static_cast<int>(End - p), Result.data(), Utf8Size, nullptr, nullptr);
+	return Result;
+
+#elif ZEN_PLATFORM_LINUX
+	std::string CmdlinePath = fmt::format("/proc/{}/cmdline", Pid);
+	FILE*		F			= fopen(CmdlinePath.c_str(), "rb");
+	if (!F)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+	auto FGuard = MakeGuard([F] { fclose(F); });
+
+	// /proc/{pid}/cmdline contains null-separated argv entries; read it all
+	std::string Raw;
+	char		Chunk[4096];
+	size_t		BytesRead;
+	while ((BytesRead = fread(Chunk, 1, sizeof(Chunk), F)) > 0)
+	{
+		Raw.append(Chunk, BytesRead);
+	}
+	if (Raw.empty())
+	{
+		return {};
+	}
+
+	// Skip argv[0] (first null-terminated entry)
+	const char* p	= Raw.data();
+	const char* End = Raw.data() + Raw.size();
+	while (p < End && *p != '\0')
+	{
+		++p;
+	}
+	if (p < End)
+	{
+		++p;  // skip null terminator of argv[0]
+	}
+
+	// Build result: remaining entries joined by spaces (inter-arg nulls → spaces)
+	std::string Result;
+	Result.reserve(static_cast<size_t>(End - p));
+	for (const char* q = p; q < End; ++q)
+	{
+		Result += (*q == '\0') ? ' ' : *q;
+	}
+	while (!Result.empty() && Result.back() == ' ')
+	{
+		Result.pop_back();
+	}
+	return Result;
+
+#elif ZEN_PLATFORM_MAC
+	int	   Mib[3]  = {CTL_KERN, KERN_PROCARGS2, Pid};
+	size_t BufSize = 0;
+	if (sysctl(Mib, 3, nullptr, &BufSize, nullptr, 0) != 0 || BufSize == 0)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+
+	std::vector<char> Buf(BufSize);
+	if (sysctl(Mib, 3, Buf.data(), &BufSize, nullptr, 0) != 0)
+	{
+		OutEc = MakeErrorCodeFromLastError();
+		return {};
+	}
+
+	// Layout: [int argc][exec_path\0][null padding][argv[0]\0][argv[1]\0]...[envp\0]...
+	if (BufSize < sizeof(int))
+	{
+		return {};
+	}
+	int Argc = 0;
+	memcpy(&Argc, Buf.data(), sizeof(int));
+	if (Argc <= 1)
+	{
+		return {};
+	}
+
+	const char* p	= Buf.data() + sizeof(int);
+	const char* End = Buf.data() + BufSize;
+
+	// Skip exec_path and any trailing null padding that follows it
+	while (p < End && *p != '\0')
+	{
+		++p;
+	}
+	while (p < End && *p == '\0')
+	{
+		++p;
+	}
+
+	// Skip argv[0]
+	while (p < End && *p != '\0')
+	{
+		++p;
+	}
+	if (p < End)
+	{
+		++p;
+	}
+
+	// Collect argv[1..Argc-1]
+	std::string Result;
+	for (int i = 1; i < Argc && p < End; ++i)
+	{
+		if (i > 1)
+		{
+			Result += ' ';
+		}
+		const char* ArgStart = p;
+		while (p < End && *p != '\0')
+		{
+			++p;
+		}
+		Result.append(ArgStart, p);
+		if (p < End)
+		{
+			++p;
+		}
+	}
+	return Result;
+
+#else
+	ZEN_UNUSED(Pid);
+	ZEN_UNUSED(OutEc);
+	return {};
+#endif
+}
+
 std::error_code
 FindProcess(const std::filesystem::path& ExecutableImage, ProcessHandle& OutHandle, bool IncludeSelf)
 {
diff --git a/src/zencore/string.cpp b/src/zencore/string.cpp
index 0ee863b74..a9aed6309 100644
--- a/src/zencore/string.cpp
+++ b/src/zencore/string.cpp
@@ -24,6 +24,10 @@ utf16to8_impl(u16bit_iterator StartIt, u16bit_iterator EndIt, ::zen::StringBuild
 		// Take care of surrogate pairs first
 		if (utf8::internal::is_lead_surrogate(cp))
 		{
+			if (StartIt == EndIt)
+			{
+				break;
+			}
 			uint32_t trail_surrogate = utf8::internal::mask16(*StartIt++);
 			cp						 = (cp << 10) + trail_surrogate + utf8::internal::SURROGATE_OFFSET;
 		}
diff --git a/src/zencore/trace.cpp b/src/zencore/trace.cpp
index 87035554f..a026974c0 100644
--- a/src/zencore/trace.cpp
+++ b/src/zencore/trace.cpp
@@ -165,10 +165,17 @@ GetTraceOptionsFromCommandline(TraceOptions& OutOptions)
 	auto MatchesArg = [](std::string_view Option, std::string_view Arg) -> std::optional<std::string_view> {
 		if (Arg.starts_with(Option))
 		{
-			std::string_view::value_type DelimChar = Arg[Option.length()];
-			if (DelimChar == ' ' || DelimChar == '=')
+			if (Arg.length() > Option.length())
 			{
-				return Arg.substr(Option.size() + 1);
+				std::string_view::value_type DelimChar = Arg[Option.length()];
+				if (DelimChar == ' ' || DelimChar == '=')
+				{
+					return Arg.substr(Option.size() + 1);
+				}
+			}
+			else
+			{
+				return ""sv;
 			}
 		}
 		return {};
diff --git a/src/zencore/xmake.lua b/src/zencore/xmake.lua
index a3fd4dacb..9a67175a0 100644
--- a/src/zencore/xmake.lua
+++ b/src/zencore/xmake.lua
@@ -33,8 +33,6 @@ target('zencore')
     add_deps("timesinceprocessstart")
     add_deps("doctest")
     add_deps("fmt")
-    add_deps("ryml")
-    
     add_packages("json11")
 
     if is_plat("linux", "macosx") then