diff --git a/deps/ox/src/ox/mc/write.hpp b/deps/ox/src/ox/mc/write.hpp
index 0e03b7fd..ddc18236 100644
--- a/deps/ox/src/ox/mc/write.hpp
+++ b/deps/ox/src/ox/mc/write.hpp
@@ -32,68 +32,68 @@ template<Writer_c Writer>
 class MetalClawWriter {
 
 	private:
-		ox::Vector<uint8_t, 16> m_presenceMapBuff{};
+		Vector<uint8_t, 16> m_presenceMapBuff{};
 		FieldBitmap m_fieldPresence;
 		int m_field = 0;
-		ox::Optional<int> m_unionIdx;
-		std::size_t m_writerBeginP{};
+		Optional<int> m_unionIdx;
+		size_t m_writerBeginP{};
 		Writer &m_writer;
 
 	public:
-		constexpr explicit MetalClawWriter(Writer &writer, ox::Optional<int> const&unionIdx = {}) noexcept;
+		constexpr explicit MetalClawWriter(Writer &writer, Optional<int> const &unionIdx = {}) noexcept;
 
 		constexpr ~MetalClawWriter() noexcept = default;
 
-		constexpr Error field(const char*, const int8_t *val) noexcept;
-		constexpr Error field(const char*, const int16_t *val) noexcept;
-		constexpr Error field(const char*, const int32_t *val) noexcept;
-		constexpr Error field(const char*, const int64_t *val) noexcept;
+		constexpr Error field(CString, int8_t const *val) noexcept;
+		constexpr Error field(CString, int16_t const *val) noexcept;
+		constexpr Error field(CString, int32_t const *val) noexcept;
+		constexpr Error field(CString, int64_t const *val) noexcept;
 
-		constexpr Error field(const char*, const uint8_t *val) noexcept;
-		constexpr Error field(const char*, const uint16_t *val) noexcept;
-		constexpr Error field(const char*, const uint32_t *val) noexcept;
-		constexpr Error field(const char*, const uint64_t *val) noexcept;
+		constexpr Error field(CString, uint8_t const *val) noexcept;
+		constexpr Error field(CString, uint16_t const *val) noexcept;
+		constexpr Error field(CString, uint32_t const *val) noexcept;
+		constexpr Error field(CString, uint64_t const *val) noexcept;
 
-		constexpr Error field(const char*, const bool *val) noexcept;
+		constexpr Error field(CString, bool const *val) noexcept;
 
 		template<typename T>
-		constexpr Error field(const char*, const T *val, std::size_t len) noexcept;
+		constexpr Error field(CString, T const *val, size_t len) noexcept;
 
 		template<typename T>
-		constexpr Error field(const char *name, const HashMap<String, T> *val) noexcept;
+		constexpr Error field(CString name, HashMap<String, T> const *val) noexcept;
 
-		template<std::size_t SmallStringSize>
-		constexpr Error field(const char*, const BasicString<SmallStringSize> *val) noexcept;
+		template<size_t SmallStringSize>
+		constexpr Error field(CString, BasicString<SmallStringSize> const *val) noexcept;
 
-		template<std::size_t L>
-		constexpr Error field(const char*, const IString<L> *val) noexcept;
+		template<size_t L>
+		constexpr Error field(CString, IString<L> const *val) noexcept;
 
-		constexpr Error fieldCString(const char *name, const char *const*val, std::size_t buffLen) noexcept;
+		constexpr Error fieldCString(CString name, CString const*val, size_t buffLen) noexcept;
 
-		constexpr Error fieldCString(const char *name, const char **val) noexcept;
+		constexpr Error fieldCString(CString name, CString *val) noexcept;
 
-		constexpr Error fieldCString(const char *name, const char *const*val) noexcept;
+		constexpr Error fieldCString(CString name, CString const*val) noexcept;
 
-		constexpr Error fieldCString(const char *name, const char *val, std::size_t len) noexcept;
+		constexpr Error fieldCString(CString name, CString val, size_t strLen) noexcept;
 
 		template<typename T>
-		constexpr Error field(const char*, const T *val) noexcept;
+		constexpr Error field(CString, T const *val) noexcept;
 
 		template<typename U, bool force = false>
-		constexpr Error field(const char*, UnionView<U, force> val) noexcept;
+		constexpr Error field(CString, UnionView<U, force> val) noexcept;
 
 		template<typename T = std::nullptr_t>
-		constexpr ox::Error setTypeInfo(
-				const char *name = T::TypeName,
+		constexpr Error setTypeInfo(
+				CString name = T::TypeName,
 				int version = T::TypeVersion,
-		        const Vector<String>& = {},
-				std::size_t fields = ModelFieldCount_v<T>) noexcept;
+		        Vector<String> const& = {},
+				size_t fields = ModelFieldCount_v<T>) noexcept;
 
 		/**
 		 * stringLength is not implemented in MetalClawWriter
 		 */
 		[[nodiscard]]
-		constexpr auto stringLength(const char*) noexcept {
+		constexpr auto stringLength(CString) noexcept {
 			return 0;
 		}
 
@@ -101,7 +101,7 @@ class MetalClawWriter {
 		 * stringLength is not implemented in MetalClawWriter
 		 */
 		[[nodiscard]]
-		constexpr auto arrayLength(const char*, bool = true) noexcept {
+		constexpr auto arrayLength(CString, bool = true) noexcept {
 			return 0;
 		}
 
@@ -110,17 +110,17 @@ class MetalClawWriter {
 			return OpType::Write;
 		}
 
-		ox::Error finalize() noexcept;
+		Error finalize() noexcept;
 
 	private:
 		constexpr Error appendInteger(Integer_c auto val) noexcept {
 			bool fieldSet = false;
 			if (val && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 				auto mi = mc::encodeInteger(val);
-				OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(mi.data.data()), mi.length));
+				OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(mi.data.data()), mi.length));
 				fieldSet = true;
 			}
-			OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+			OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 			++m_field;
 			return {};
 		}
@@ -131,7 +131,7 @@ extern template class ModelHandlerInterface<MetalClawWriter<BufferWriter>>;
 extern template class ModelHandlerInterface<MetalClawWriter<CharBuffWriter>>;
 
 template<Writer_c Writer>
-constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, ox::Optional<int> const&unionIdx) noexcept:
+constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, Optional<int> const &unionIdx) noexcept:
 	m_fieldPresence(m_presenceMapBuff.data(), m_presenceMapBuff.size()),
 	m_unionIdx(unionIdx),
 	m_writerBeginP(writer.tellp()),
@@ -139,128 +139,128 @@ constexpr MetalClawWriter<Writer>::MetalClawWriter(Writer &writer, ox::Optional<
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const int8_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, int8_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const int16_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, int16_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const int32_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, int32_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const int64_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, int64_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const uint8_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, uint8_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const uint16_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, uint16_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const uint32_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, uint32_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const uint64_t *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, uint64_t const *val) noexcept {
 	return appendInteger(*val);
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const bool *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, bool const *val) noexcept {
 	if (!m_unionIdx.has_value() || *m_unionIdx == m_field) {
-		OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), *val));
+		OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), *val));
 	}
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
-template<std::size_t SmallStringSize>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const BasicString<SmallStringSize> *val) noexcept {
+template<size_t SmallStringSize>
+constexpr Error MetalClawWriter<Writer>::field(CString, BasicString<SmallStringSize> const *val) noexcept {
 	bool fieldSet = false;
 	if (val->size() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
-		const auto strLen = mc::encodeInteger(val->size());
-		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(strLen.data.data()), strLen.length));
+		auto const strLen = mc::encodeInteger(val->size());
+		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(strLen.data.data()), strLen.length));
 		// write the string
-		OX_RETURN_ERROR(m_writer.write(val->c_str(), static_cast<std::size_t>(val->size())));
+		OX_RETURN_ERROR(m_writer.write(val->c_str(), static_cast<size_t>(val->size())));
 		fieldSet = true;
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
-template<std::size_t L>
-constexpr Error MetalClawWriter<Writer>::field(const char *name, const IString<L> *val) noexcept {
+template<size_t L>
+constexpr Error MetalClawWriter<Writer>::field(CString name, IString<L> const *val) noexcept {
 	return fieldCString(name, val->data(), val->size());
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::fieldCString(const char*, const char *const*val, std::size_t) noexcept {
+constexpr Error MetalClawWriter<Writer>::fieldCString(CString, CString const *val, size_t) noexcept {
 	bool fieldSet = false;
 	if (!m_unionIdx.has_value() || *m_unionIdx == m_field) {
 		OX_ALLOW_UNSAFE_BUFFERS_BEGIN
 		// this strlen is tolerated because sometimes 0 gets passed to
 		// the size param, which is a lie
 		// this code should be cleaned up at some point...
-		const auto strLen = *val ? ox::strlen(*val) : 0;
+		auto const strLen = *val ? ox::strlen(*val) : 0;
 		OX_ALLOW_UNSAFE_BUFFERS_END
 		// write the length
-		const auto strLenBuff = mc::encodeInteger(strLen);
-		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(strLenBuff.data.data()), strLenBuff.length));
+		auto const strLenBuff = mc::encodeInteger(strLen);
+		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(strLenBuff.data.data()), strLenBuff.length));
 		// write the string
-		OX_RETURN_ERROR(m_writer.write(*val, static_cast<std::size_t>(strLen)));
+		OX_RETURN_ERROR(m_writer.write(*val, static_cast<size_t>(strLen)));
 		fieldSet = true;
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::fieldCString(const char *name, const char **val) noexcept {
+constexpr Error MetalClawWriter<Writer>::fieldCString(CString const name, CString *val) noexcept {
 	return fieldCString(name, val, {});
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::fieldCString(const char *name, const char *const*val) noexcept {
+constexpr Error MetalClawWriter<Writer>::fieldCString(CString const name, CString const *val) noexcept {
 	return fieldCString(name, val, {});
 }
 
 template<Writer_c Writer>
-constexpr Error MetalClawWriter<Writer>::fieldCString(const char*, const char *val, std::size_t strLen) noexcept {
+constexpr Error MetalClawWriter<Writer>::fieldCString(CString, CString const val, size_t const strLen) noexcept {
 	bool fieldSet = false;
 	if (strLen && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
-		const auto strLenBuff = mc::encodeInteger(strLen);
-		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(strLenBuff.data.data()), strLenBuff.length));
+		auto const strLenBuff = mc::encodeInteger(strLen);
+		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(strLenBuff.data.data()), strLenBuff.length));
 		// write the string
-		OX_RETURN_ERROR(m_writer.write(val, static_cast<std::size_t>(strLen)));
+		OX_RETURN_ERROR(m_writer.write(val, static_cast<size_t>(strLen)));
 		fieldSet = true;
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
 template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, T const *val) noexcept {
 	if constexpr(isVector_v<T> || isArray_v<T>) {
 		return field(nullptr, val->data(), val->size());
 	} else {
@@ -273,7 +273,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val) noexce
 			OX_RETURN_ERROR(writer.finalize());
 			fieldSet = writeIdx != m_writer.tellp();
 		}
-		OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+		OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 		++m_field;
 		return {};
 	}
@@ -281,35 +281,35 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val) noexce
 
 template<Writer_c Writer>
 template<typename U, bool force>
-constexpr Error MetalClawWriter<Writer>::field(const char*, UnionView<U, force> val) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, UnionView<U, force> val) noexcept {
 	bool fieldSet = false;
 	if (val.get() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		auto const writeIdx = m_writer.tellp();
-		MetalClawWriter<Writer> writer(m_writer, ox::Optional<int>(ox::in_place, val.idx()));
+		MetalClawWriter<Writer> writer(m_writer, Optional<int>(in_place, val.idx()));
 		ModelHandlerInterface handler{writer};
 		OX_RETURN_ERROR(model(&handler, val.get()));
 		OX_RETURN_ERROR(writer.finalize());
 		fieldSet = writeIdx != m_writer.tellp();
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
 template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const T *val, std::size_t len) noexcept {
+constexpr Error MetalClawWriter<Writer>::field(CString, T const *val, size_t const len) noexcept {
 	bool fieldSet = false;
 	if (len && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
-		const auto arrLen = mc::encodeInteger(len);
-		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length));
+		auto const arrLen = mc::encodeInteger(len);
+		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(arrLen.data.data()), arrLen.length));
 		auto const writeIdx = m_writer.tellp();
 		MetalClawWriter<Writer> writer(m_writer);
 		ModelHandlerInterface handler{writer};
-		OX_RETURN_ERROR(handler.template setTypeInfo<T>("List", 0, {}, static_cast<std::size_t>(len)));
+		OX_RETURN_ERROR(handler.template setTypeInfo<T>("List", 0, {}, static_cast<size_t>(len)));
 		// write the array
-		for (std::size_t i = 0; i < len; ++i) {
+		for (size_t i{}; i < len; ++i) {
 OX_ALLOW_UNSAFE_BUFFERS_BEGIN
 			OX_RETURN_ERROR(handler.field("", &val[i]));
 OX_ALLOW_UNSAFE_BUFFERS_END
@@ -317,29 +317,29 @@ OX_ALLOW_UNSAFE_BUFFERS_END
 		OX_RETURN_ERROR(writer.finalize());
 		fieldSet = writeIdx != m_writer.tellp();
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
 template<typename T>
-constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String, T> *val) noexcept {
-	const auto &keys = val->keys();
-	const auto len = keys.size();
+constexpr Error MetalClawWriter<Writer>::field(CString, HashMap<String, T> const *val) noexcept {
+	auto const &keys = val->keys();
+	auto const len = keys.size();
 	bool fieldSet = false;
 	if (len && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
-		const auto arrLen = mc::encodeInteger(len);
-		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(arrLen.data.data()), arrLen.length));
+		auto const arrLen = mc::encodeInteger(len);
+		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<CString>(arrLen.data.data()), arrLen.length));
 		// write map
 		MetalClawWriter<Writer> writer(m_writer);
 		ModelHandlerInterface handler{writer};
 		// double len for both key and value
 		OX_RETURN_ERROR(handler.setTypeInfo("Map", 0, {}, len * 2));
 		// this loop body needs to be in a lambda because of the potential alloca call
-		constexpr auto loopBody = [](auto &handler, auto const&key, auto const&val) -> ox::Error {
-			const auto keyLen = key.size();
+		constexpr auto loopBody = [](auto &handler, auto const &key, auto const &val) -> Error {
+			auto const keyLen = key.size();
 			auto wkey = ox_malloca(keyLen + 1, char, 0);
 			memcpy(wkey.get(), key.c_str(), keyLen + 1);
 			OX_RETURN_ERROR(handler.fieldCString("", wkey.get(), keyLen));
@@ -347,26 +347,26 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 			return handler.field("", value);
 		};
 		// write the array
-		for (std::size_t i = 0; i < len; ++i) {
-			auto const&key = keys[i];
+		for (size_t i{}; i < len; ++i) {
+			auto const &key = keys[i];
 			OX_RETURN_ERROR(loopBody(handler, key, *val));
 		}
 		OX_RETURN_ERROR(writer.finalize());
 		fieldSet = true;
 	}
-	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
+	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<size_t>(m_field), fieldSet));
 	++m_field;
 	return {};
 }
 
 template<Writer_c Writer>
 template<typename T>
-constexpr ox::Error MetalClawWriter<Writer>::setTypeInfo(
-		const char*,
+constexpr Error MetalClawWriter<Writer>::setTypeInfo(
+		CString,
 		int,
-		const Vector<String>&,
-		std::size_t fields) noexcept {
-	const auto fieldPresenceLen = (fields - 1) / 8 + 1;
+		Vector<String> const&,
+		size_t const fields) noexcept {
+	auto const fieldPresenceLen = (fields - 1) / 8 + 1;
 	OX_RETURN_ERROR(m_writer.write(nullptr, fieldPresenceLen));
 	m_presenceMapBuff.resize(fieldPresenceLen);
 	m_fieldPresence.setBuffer(m_presenceMapBuff.data(), m_presenceMapBuff.size());
@@ -375,17 +375,17 @@ constexpr ox::Error MetalClawWriter<Writer>::setTypeInfo(
 }
 
 template<Writer_c Writer>
-ox::Error MetalClawWriter<Writer>::finalize() noexcept {
-	const auto end = m_writer.tellp();
+Error MetalClawWriter<Writer>::finalize() noexcept {
+	auto const end = m_writer.tellp();
 	OX_RETURN_ERROR(m_writer.seekp(m_writerBeginP));
 	OX_RETURN_ERROR(m_writer.write(
-			reinterpret_cast<const char*>(m_presenceMapBuff.data()),
+			reinterpret_cast<CString>(m_presenceMapBuff.data()),
 			m_presenceMapBuff.size()));
 	OX_RETURN_ERROR(m_writer.seekp(end));
 	return {};
 }
 
-Result<Buffer> writeMC(Writer_c auto &writer, const auto &val) noexcept {
+Result<Buffer> writeMC(Writer_c auto &writer, auto const &val) noexcept {
 	MetalClawWriter mcWriter(writer);
 	ModelHandlerInterface handler{mcWriter};
 	OX_RETURN_ERROR(model(&handler, &val));
@@ -393,7 +393,7 @@ Result<Buffer> writeMC(Writer_c auto &writer, const auto &val) noexcept {
 	return {};
 }
 
-Result<Buffer> writeMC(auto const&val, std::size_t buffReserveSz = 2 * units::KB) noexcept {
+Result<Buffer> writeMC(auto const &val, size_t const buffReserveSz = 2 * units::KB) noexcept {
 	Buffer buff(buffReserveSz);
 	BufferWriter bw(&buff, 0);
 	OX_RETURN_ERROR(writeMC(bw, val));
@@ -401,7 +401,7 @@ Result<Buffer> writeMC(auto const&val, std::size_t buffReserveSz = 2 * units::KB
 	return buff;
 }
 
-Error writeMC(char *buff, std::size_t buffLen, auto const&val, std::size_t *sizeOut = nullptr) noexcept {
+Error writeMC(char *buff, size_t const buffLen, auto const &val, size_t *sizeOut = nullptr) noexcept {
 	CharBuffWriter bw{{buff, buffLen}};
 	OX_RETURN_ERROR(writeMC(bw, val));
 	if (sizeOut) {