[ox] Remove oxExpect macro

Makefile

@@ -14,7 +14,7 @@ endif
 PROJECT_PLAYER=./build/${BC_VAR_CURRENT_BUILD}/bin/${BC_VAR_PROJECT_NAME_CAP}
 
 .PHONY: pkg-gba
-pkg-gba: build
+pkg-gba: build-pack build-gba-player
 	${BC_CMD_ENVRUN} ${BC_PY3} ./util/scripts/pkg-gba.py sample_project ${BC_VAR_PROJECT_NAME_CAP}
 
 .PHONY: pkg-mac
@@ -26,25 +26,44 @@ generate-studio-rsrc:
 	${BC_CMD_ENVRUN} ${BC_PY3} ./util/scripts/file-to-cpp.py --rsrc src/olympic/studio/applib/src/rsrc.json
 	${BC_CMD_ENVRUN} ${BC_PY3} ./util/scripts/file-to-cpp.py --rsrc src/nostalgia/studio/rsrc.json
 
+.PHONY: build-gba-player
+build-gba-player:
+	cmake --build ./build/gba-*
+
 .PHONY: build-player
 build-player:
 	${BC_CMD_CMAKE_BUILD} ${BC_VAR_BUILD_PATH} ${BC_VAR_PROJECT_NAME_CAP}
+
+.PHONY: build-pack
+build-pack:
+	cmake --build ./build/${BC_VAR_CURRENT_BUILD} --target ${BC_VAR_PROJECT_NAME}-pack
+
+
 .PHONY: run
 run: build-player
 	${PROJECT_PLAYER} sample_project
+
+.PHONY: build-studio
+build-studio:
+	cmake --build ./build/${BC_VAR_CURRENT_BUILD} --target ${BC_VAR_PROJECT_NAME_CAP}Studio
+
 .PHONY: run-studio
-run-studio: build
+run-studio: build-studio
 	${PROJECT_STUDIO}
+
 .PHONY: gba-run
 gba-run: pkg-gba
 	${MGBA} ${BC_VAR_PROJECT_NAME_CAP}.gba
+
 .PHONY: debug
 debug: build
 	${BC_CMD_HOST_DEBUGGER} ${PROJECT_PLAYER} sample_project
+
 .PHONY: debug-studio
 debug-studio: build
 	${BC_CMD_HOST_DEBUGGER} ${PROJECT_STUDIO}
 
+
 .PHONY: configure-gba
 configure-gba:
 	${BC_CMD_SETUP_BUILD} --toolchain=deps/gbabuildcore/cmake/modules/GBA.cmake --target=gba --current_build=0 --build_type=release --build_root=${BC_VAR_BUILD_PATH}

deps/ox/ox-docs.md

@@ -28,10 +28,7 @@ All components have a platform indicator next to them:
 Ox provides ```ox::Error``` to report errors.
 ```ox::Error``` is a struct that has overloaded operators to behave like an
 integer error code, plus some extra fields to enhance debuggability.
-If instantiated through the ```OxError(x)``` macro, it will also include the
+```ox::Error```s will also include the file and line of the error.
-file and line of the error.
-The ```OxError(x)``` macro should only be used for the initial instantiation of
-an ```ox::Error```.
 
 In addition to ```ox::Error``` there is also the template ```ox::Result<T>```.
 ```ox::Result``` simply wraps the type T value in a struct that also includes
@@ -49,7 +46,7 @@ ox::Result<int> foo(int i) noexcept {
 	if (i < 10) {
 		return i + 1; // implicitly calls ox::Result<T>::Result(T)
 	}
-	return OxError(1); // implicitly calls ox::Result<T>::Result(ox::Error)
+	return ox::Error(1); // implicitly calls ox::Result<T>::Result(ox::Error)
 }
 
 int caller1() {
@@ -181,6 +178,216 @@ variant for creating a non-const value.
 
 * ```OX_REQUIRE_M``` - OX_REQUIRE Mutable
 
+### Ox String Types
+
+Ox has six different major string types.
+These types are divided into two categories: store types and view types.
+
+String stores maintain a copy of the string data, whereas view types only
+maintain a reference to the data.
+Views should be used where you otherwise might use a const reference to a
+string store type.
+
+Having all of these different string types may sound like an interoperability
+nightmare, but taking string view types extensively where applicable makes the
+imagined interoperability issues virtually non-existent.
+
+#### String Store Types
+
+##### String / BasicString
+
+```ox::String```, or really ```ox::BasicString```, is Ox's version of
+```std::string```.
+Like ```std::string```, ```String``` allocates to store the string data.
+Also like ```std::string```, ```String``` allows for small string
+optimization for strings under 8 bytes.
+Unlike ```std::string```, the template that ```String``` is based on,
+```BasicString```, takes a parameter that allows adjusting to different size
+small string buffers.
+```ox::String``` is an alias to ```ox::BasicString<8>```.
+
+```cpp
+// s can hold up to 100 bytes, plus one for a null terminator before allocating
+ox::BasicString<100> s;
+```
+Also unlike ```std::string```, ```ox::String``` has an explicit C-string conversion
+constructor.
+This prevents accidental instantiations of ```String```.
+
+Consider the following:
+
+```cpp
+void fStd(std::string const&);
+void fOx(ox::String const&);
+
+int main() {
+    // implicit and silent instantiation of std::string, which includes an
+    // allocation
+    fStd("123456789");
+    // Will fail to compile:
+    fOx("123456789");
+    // But explicit String instantiation will work:
+    fOx(ox::String{"123456789"});
+}
+```
+
+##### IString
+
+```IString```, or "inline string", is like ```BasicString```, but it will cut
+off strings that exceed that limit.
+
+```cpp
+ox::IString<5> s; // s can hold up to 5 characters, plus a null terminator
+s = "12345";      // valid
+s = "123456";     // will compile and run, but will get cut off at '5'
+```
+
+This is useful for certain string categories that have fixed lengths, like UUID
+strings or for numbers.
+
+Ox makes use of ```IString``` in the following ways:
+
+```cpp
+using UUIDStr = ox::IString<36>;
+
+// and
+
+template<Integer_c Integer>
+[[nodiscard]]
+constexpr auto intToStr(Integer v) noexcept {
+	constexpr auto Cap = [] {
+		auto out = 0;
+		switch (sizeof(Integer)) {
+			case 1:
+				out = 3;
+				break;
+			case 2:
+				out = 5;
+				break;
+			case 4:
+				out = 10;
+				break;
+			case 8:
+				out = 21;
+				break;
+		}
+		return out + ox::is_signed_v<Integer>;
+	}();
+	ox::IString<Cap> out;
+	std::ignore = out.resize(out.cap());
+	ox::CharBuffWriter w{{out.data(), out.cap()}};
+	std::ignore = writeItoa(v, w);
+	std::ignore = out.resize(w.tellp());
+	return out;
+}
+```
+
+##### StringParam
+
+```StringParam``` is a weird type.
+Because ```String::String(const char*)``` is explicit, it becomes a pain for
+functions to take ```String```s.
+
+```cpp
+struct Type {
+    ox::String m_s;
+    explicit Type(ox::String p): m_s(std::move(p)) {
+    }
+};
+
+void f() {
+    ox::String s{"asdf"};
+    Type t1{"asdf"};             // invalid - will not compile
+    Type t2{s};                  // invalid - will not compile
+    Type t3{std::move(s)};       // valid
+    Type t4{ox::String{"asdf"}}; // valid
+}
+```
+
+```StringParam``` has implicit conversion constructors, and will appropriately
+move from r-value ```String```s or create a ```String``` if not passed
+ownership of an existing ```String```.
+Think of ```StringParam``` as a way to opt-in to implicit instantiation with
+strings.
+
+```StringParam``` can access the string as a view through the ```view()```
+function, and the ```String``` inside can be accessed by moving from the
+```StringParam```.
+
+```cpp
+struct Type {
+    ox::String m_s;
+    explicit Type(ox::StringParam p): m_s(std::move(p)) {
+    }
+};
+
+void f() {
+    ox::String s{"asdf"};
+    Type t1{"asdf"};             // valid
+    Type t2{s};                  // valid
+    Type t3{std::move(s)};       // valid
+    Type t4{ox::String{"asdf"}}; // valid
+}
+```
+
+#### String View Types
+
+##### StringView
+
+```ox::StringView``` is Ox's version of ```std::string_view```.
+```StringView``` contains a pointer to a string, along with its size.
+
+This should be the normal type taken when a function needs a string that will
+exist until it returns.
+
+##### CStringView
+
+```CStringView``` is like ```StringView```, but it comes with the promise that
+the string ends with a null terminator.
+Accordingly, it has a ```c_str()``` function in addition to the ```data()```
+function that ```StringView``` has.
+
+```CStringView``` should be used when wrapping a C API that only takes C
+strings.
+
+##### StringLiteral
+
+```StringLiteral``` is a string view type, but it kind of straddles the line
+between view and store types.
+Creating a ```StringLiteral``` is a promise that you are passing a string
+literal into the constructor.
+This means you can treat it like a store, that can be safely used as a copy of
+the data.
+Functions that take ```StringLiteral```s are allowed to assume that the data
+will have no lifetime concerns and hold onto it without any need to make a
+copy.
+It has a consteval constructor to enforce the promise that it is a compile time
+string.
+
+```cpp
+void f(ox::StringLiteral const&);
+
+int main() {
+    f("123456789");                     // valid
+    f(ox::String{"123456789"}.c_str()); // invalid - will not compile
+}
+```
+
+#### Other Variants
+
+There are a few convenience aliases as well.
+
+* StringCR = String const&
+* StringViewCR = StringView const&
+* CStringViewCR = CStringView const&
+* CString = const char*
+
+String views do not generally need const references, but it does make debugging
+easier, as we can skip the constructor call if a string view already exists.
+
+These kind of aliases probably should not exist for most types, but strings are
+fundamental and ease of use is desirable.
+
 ### Logging and Output
 
 Ox provides for logging and debug prints via the ```oxTrace```, ```oxDebug```, and ```oxError``` macros.

deps/ox/src/ox/claw/test/tests.cpp

@@ -135,7 +135,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 				constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;awefawf");
 				constexpr auto expected = ox::StringLiteral("com.drinkingtea.ox.claw.test.Header2;3");
 				OX_REQUIRE(actual, ox::readClawTypeId({hdr.data(), hdr.size() + 1}));
-				oxExpect(actual, expected);
+				ox::expect(actual, expected);
 				return ox::Error{};
 			}
 		},

deps/ox/src/ox/fs/filesystem/filesystem.hpp

@@ -87,7 +87,7 @@ class FileSystem {
 			return writeFilePath(path, buffer, size, FileType::NormalFile);
 		}
 
-		Error write(StringViewCR path, ox::Span<char> const&buff) noexcept {
+		Error write(StringViewCR path, ox::SpanView<char> const&buff) noexcept {
 			return write(path, buff.data(), buff.size(), FileType::NormalFile);
 		}
 
@@ -95,7 +95,7 @@ class FileSystem {
 			return write(inode, buffer, size, FileType::NormalFile);
 		}
 
-		Error write(uint64_t inode, ox::Span<char> const&buff) noexcept {
+		Error write(uint64_t inode, ox::SpanView<char> const&buff) noexcept {
 			return write(inode, buff.data(), buff.size(), FileType::NormalFile);
 		}
 

deps/ox/src/ox/fs/test/tests.cpp

@@ -74,9 +74,9 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
 				ox::PathIterator it(path);
 				ox::StringView buff;
 				oxAssert(it.next(buff), "PathIterator::next returned error");
-				oxExpect(buff, "usr");
+				ox::expect(buff, "usr");
 				oxAssert(it.next(buff), "PathIterator::next returned error");
-				oxExpect(buff, "share");
+				ox::expect(buff, "share");
 				return ox::Error(0);
 			}
 		},

deps/ox/src/ox/mc/test/tests.cpp

@@ -157,8 +157,7 @@ std::map<ox::StringView, ox::Error(*)()> tests = {
 				oxAssert(testIn.Int8                == testOut.Int8,                "Int8 value mismatch");
 				oxAssert(testIn.Union.Int           == testOut.Union.Int,           "Union.Int value mismatch");
 				oxAssert(testIn.String              == testOut.String,              "String value mismatch");
-				oxDebugf("{}", testOut.IString.size());
+				ox::expect(testIn.IString,               testOut.IString);
-				oxExpect(testIn.IString,               testOut.IString);
 				oxAssert(testIn.List[0]             == testOut.List[0],             "List[0] value mismatch");
 				oxAssert(testIn.List[1]             == testOut.List[1],             "List[1] value mismatch");
 				oxAssert(testIn.List[2]             == testOut.List[2],             "List[2] value mismatch");

deps/ox/src/ox/model/descwrite.hpp

@@ -187,7 +187,7 @@ constexpr ox::Error TypeDescWriter::setTypeInfo(
 	PrimitiveType pt;
 	if constexpr(is_union_v<T>) {
 		pt = PrimitiveType::Union;
-	} else if constexpr(isBasicString_v<T> || isBString_v<T>) {
+	} else if constexpr(isBasicString_v<T> || isIString_v<T>) {
 		pt = PrimitiveType::String;
 	} else {
 		pt = PrimitiveType::Struct;
@@ -357,7 +357,7 @@ constexpr const DescriptorType *TypeDescWriter::type(const char*) const noexcept
 template<std::size_t sz>
 constexpr const DescriptorType *TypeDescWriter::type(const IString<sz>*) const noexcept {
 	constexpr auto PT = PrimitiveType::String;
-	return getType(types::BString, 0, PT, 0);
+	return getType(types::IString, 0, PT, 0);
 }
 
 constexpr const DescriptorType *TypeDescWriter::getType(StringViewCR tn, int typeVersion, PrimitiveType pt, int b,

deps/ox/src/ox/model/modelhandleradaptor.hpp

@@ -135,7 +135,7 @@ class ModelHandlerInterface {
 					return m_handler->field(name, &v->template get<ModelValueArray>());
 			}
 			oxErrf("invalid type: {}: {}\n", name, static_cast<int>(v->type()));
-			oxPanic(ox::Error(1), "invalid type");
+			ox::panic(ox::Error(1), "invalid type");
 			return ox::Error(1, "invalid type");
 		}
 

deps/ox/src/ox/model/modelvalue.cpp

@@ -20,4 +20,7 @@ static_assert([]() -> ox::Error {
 	return {};
 }() == ox::Error{});
 
+// a dummy function to prevent linker errors in a library that has no other symbols
+void modelDummyFunc() noexcept {}
+
 }

deps/ox/src/ox/model/modelvalue.hpp

@@ -100,7 +100,7 @@ class ModelValue {
 				return Type::Union;
 			} else if constexpr(is_same_v<U, ModelObject>) {
 				return Type::Object;
-			} else if constexpr(isBasicString_v<U> || isBString_v<U>) {
+			} else if constexpr(isBasicString_v<U> || isIString_v<U>) {
 				return Type::String;
 			} else if constexpr(is_same_v<U, ModelValueVector>) {
 				return Type::Vector;
@@ -168,7 +168,7 @@ class ModelValue {
 		constexpr const auto &get() const noexcept {
 			constexpr auto type = getType<T>();
 			if (m_type != type) [[unlikely]] {
-				oxPanic(ox::Error(1), "invalid cast");
+				ox::panic(ox::Error(1), "invalid cast");
 			}
 			return getValue<type>(*this);
 		}
@@ -178,7 +178,7 @@ class ModelValue {
 		constexpr auto &get() noexcept {
 			constexpr auto type = getType<T>();
 			if (m_type != type) [[unlikely]] {
-				oxPanic(ox::Error(1), "invalid cast");
+				ox::panic(ox::Error(1), "invalid cast");
 			}
 			return getValue<type>(*this);
 		}
@@ -1098,7 +1098,7 @@ constexpr Error ModelValue::setType(
 	} else if (type->typeName == types::Bool) {
 		m_type = Type::Bool;
 	} else if (type->typeName == types::BasicString ||
-	           type->typeName == types::BString ||
+	           type->typeName == types::IString ||
 	           type->typeName == types::String) {
 		m_type = Type::String;
 		m_data.str = new String;

deps/ox/src/ox/model/types.hpp

@@ -31,18 +31,18 @@
 namespace ox {
 
 namespace types {
-constexpr StringView BasicString = "net.drinkingtea.ox.BasicString";
+constexpr StringLiteral BasicString = "net.drinkingtea.ox.BasicString";
-constexpr StringView BString     = "net.drinkingtea.ox.BString";
+constexpr StringLiteral IString     = "net.drinkingtea.ox.IString";
-constexpr StringView String      = "B.string";
+constexpr StringLiteral String      = "B.string";
-constexpr StringView Bool        = "B.bool";
+constexpr StringLiteral Bool        = "B.bool";
-constexpr StringView Uint8       = "B.uint8";
+constexpr StringLiteral Uint8       = "B.uint8";
-constexpr StringView Uint16      = "B.uint16";
+constexpr StringLiteral Uint16      = "B.uint16";
-constexpr StringView Uint32      = "B.uint32";
+constexpr StringLiteral Uint32      = "B.uint32";
-constexpr StringView Uint64      = "B.uint64";
+constexpr StringLiteral Uint64      = "B.uint64";
-constexpr StringView Int8        = "B.int8";
+constexpr StringLiteral Int8        = "B.int8";
-constexpr StringView Int16       = "B.int16";
+constexpr StringLiteral Int16       = "B.int16";
-constexpr StringView Int32       = "B.int32";
+constexpr StringLiteral Int32       = "B.int32";
-constexpr StringView Int64       = "B.int64";
+constexpr StringLiteral Int64       = "B.int64";
 }
 
 template<typename T>
@@ -63,17 +63,17 @@ static_assert(isBasicString_v<ox::BasicString<8ul>>);
 static_assert(isBasicString_v<ox::String>);
 
 template<typename T>
-consteval bool isBString(const T*) noexcept {
+consteval bool isIString(const T*) noexcept {
 	return false;
 }
 
 template<std::size_t SmallVecSize>
-consteval bool isBString(const BasicString<SmallVecSize>*) noexcept {
+consteval bool isIString(const BasicString<SmallVecSize>*) noexcept {
 	return true;
 }
 
 template<typename T>
-constexpr bool isBString_v = isBasicString(static_cast<const T*>(nullptr));
+constexpr bool isIString_v = isIString(static_cast<const T*>(nullptr));
 
 static_assert(isBasicString_v<ox::BasicString<0ul>>);
 static_assert(isBasicString_v<ox::BasicString<8ul>>);
@@ -169,12 +169,12 @@ constexpr bool isSmartPtr_v<::std::unique_ptr<T>> = true;
 #endif
 
 
-template<typename Union, bool force = false>
+template<typename Union, bool force = false> requires(force || is_union_v<Union>)
 class UnionView {
 
 	protected:
 		int m_idx = -1;
-		typename enable_if<is_union_v<Union> || force, Union>::type *m_union = nullptr;
+		Union *m_union = nullptr;
 
 	public:
 		constexpr UnionView(Union *u, int idx) noexcept: m_idx(idx), m_union(u) {

deps/ox/src/ox/oc/read.hpp

@@ -181,7 +181,6 @@ Error OrganicClawReader::field(const char *key, T *val) noexcept {
 			}
 		}
 	} catch (Json::LogicError const&e) {
-		oxDebugf("JSON error: {}", e.what());
 		err = ox::Error(1, "error reading JSON data");
 	}
 	++m_fieldIt;

deps/ox/src/ox/std/array.hpp

@@ -181,13 +181,13 @@ constexpr Array<T, ArraySize> &Array<T, ArraySize>::operator=(Array &&other) noe
 
 template<typename T, std::size_t ArraySize>
 constexpr T &Array<T, ArraySize>::operator[](std::size_t i) noexcept {
-	boundsCheck(__FILE__, __LINE__, i, size(), "Array access overflow");
+	boundsCheck(i, size(), "Array access overflow");
 	return m_items[i];
 }
 
 template<typename T, std::size_t ArraySize>
 constexpr const T &Array<T, ArraySize>::operator[](std::size_t i) const noexcept {
-	boundsCheck(__FILE__, __LINE__, i, size(), "Array access overflow");
+	boundsCheck(i, size(), "Array access overflow");
 	return m_items[i];
 }
 

deps/ox/src/ox/std/assert.cpp

@@ -15,8 +15,8 @@
 
 namespace ox {
 
-void panic(StringViewCR file, int const line, StringViewCR panicMsg, Error const&err) noexcept {
+void panic(Error const &err, StringViewCR panicMsg, std::source_location const &src) noexcept {
-	oxErrf("\033[31;1;1mPANIC:\033[0m [{}:{}]: {}\n", file, line, panicMsg);
+	oxErrf("\033[31;1;1mPANIC:\033[0m [{}:{}]: {}\n", src.file_name(), src.line(), panicMsg);
 	if (err.msg) {
 		oxErrf("\tError Message:\t{}\n", err.msg);
 	}
@@ -26,44 +26,61 @@ void panic(StringViewCR file, int const line, StringViewCR panicMsg, Error const
 	}
 #ifdef OX_USE_STDLIB
 	printStackTrace(2);
-	oxTrace("panic").del("") << "Panic: " << panicMsg << " (" << file << ":" << line << ")";
+	oxTrace("panic").del("") << "Panic: " << panicMsg << " (" << src.file_name() << ":" << src.line() << ")";
 	std::abort();
 #else
 	while (1);
 #endif
 }
 
-#if __GNUC__
+#if __GNUC__ && !_WIN32
 __attribute__((weak))
 #endif
-void panic(const char *file, int const line, char const*panicMsg, Error const&err) noexcept {
+void panic(Error const &err, char const*panicMsg, std::source_location const &src) noexcept {
-	panic(StringView{file}, line, StringView{panicMsg}, err);
+	panic(err, StringView{panicMsg}, src);
 }
 
 void assertFailFuncRuntime(
-	StringViewCR file,
-	int const line,
 	StringViewCR assertTxt,
-	StringViewCR msg) noexcept {
+	StringViewCR msg,
+	std::source_location const &src) noexcept {
 #ifdef OX_USE_STDLIB
 	auto const st = genStackTrace(2);
-	oxTracef("assert", "Failed assert: {} ({}) [{}:{}]:\n{}", msg, assertTxt, file, line, st);
+	oxTracef(
+		"assert", "Failed assert: {} ({}) [{}:{}]:\n{}",
+		msg,
+		assertTxt,
+		src.file_name(),
+		src.line(),
+		st);
 	abort();
 #else
-	oxErrf("\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n", file, line, msg);
+	oxErrf(
-	oxTracef("assert", "Failed assert: {} ({}) [{}:{}]", msg, assertTxt, file, line);
+		"\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n",
-	constexprPanic(file, line, msg);
+		src.file_name(),
+		src.line(),
+		msg);
+	oxTracef(
+		"assert", "Failed assert: {} ({}) [{}:{}]",
+		msg,
+		assertTxt,
+		src.file_name(),
+		src.line());
+	constexprPanic(msg, {}, src);
 #endif
 }
 
 void assertFailFuncRuntime(
-	StringViewCR file,
-	int const line,
 	[[maybe_unused]] Error const &err,
 	StringViewCR,
-	StringViewCR assertMsg) noexcept {
+	StringViewCR assertMsg,
+	std::source_location const &src) noexcept {
 #if defined(OX_USE_STDLIB)
-	auto msg = sfmt("\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n", file, line, assertMsg);
+	auto msg = sfmt(
+		"\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n",
+		src.file_name(),
+		src.line(),
+		assertMsg);
 	if (err.msg) {
 		msg += sfmt("\tError Message:\t{}\n", err.msg);
 	}
@@ -73,10 +90,10 @@ void assertFailFuncRuntime(
 	}
 	msg += genStackTrace(2);
 	oxErr(msg);
-	oxTracef("assert", "Failed assert: {} [{}:{}]", assertMsg, file, line);
+	oxTracef("assert", "Failed assert: {} [{}:{}]", assertMsg, src.file_name(), src.line());
 	abort();
 #else
-	constexprPanic(file, line, assertMsg);
+	constexprPanic(assertMsg, {}, src);
 #endif
 }
 

deps/ox/src/ox/std/assert.hpp

@@ -23,42 +23,42 @@
 namespace ox {
 
 [[noreturn]]
-void panic(StringViewCR file, int line, StringViewCR panicMsg, Error const&err = {}) noexcept;
+void panic(
+	Error const&err,
+	StringViewCR panicMsg,
+	std::source_location const &src = std::source_location::current()) noexcept;
 
 [[noreturn]]
 constexpr void constexprPanic(
-	StringViewCR file,
-	int const line,
 	StringViewCR panicMsg,
-	Error const&err = {}) noexcept {
+	Error const &err = {},
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if (!std::is_constant_evaluated()) {
-		panic(file, line, panicMsg, err);
+		panic(err, panicMsg, src);
 	} else {
 		while (true);
 	}
 }
 
 void assertFailFuncRuntime(
-	StringViewCR file,
-	int line,
 	StringViewCR assertTxt,
-	StringViewCR msg) noexcept;
+	StringViewCR msg,
+	std::source_location const &src = std::source_location::current()) noexcept;
+
 void assertFailFuncRuntime(
-	StringViewCR file,
-	int line,
 	Error const &err,
 	StringViewCR,
-	StringViewCR assertMsg) noexcept;
+	StringViewCR assertMsg,
+	std::source_location const &src = std::source_location::current()) noexcept;
 
 constexpr void assertFunc(
-	StringViewCR file,
-	int const line,
 	bool const pass,
 	[[maybe_unused]]StringViewCR assertTxt,
-	[[maybe_unused]]StringViewCR msg) noexcept {
+	[[maybe_unused]]StringViewCR msg,
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if (!pass) {
 		if (!std::is_constant_evaluated()) {
-			assertFailFuncRuntime(file, line, assertTxt, msg);
+			assertFailFuncRuntime(assertTxt, msg, src);
 		} else {
 			while (true);
 		}
@@ -66,14 +66,13 @@ constexpr void assertFunc(
 }
 
 constexpr void assertFunc(
-	StringViewCR file,
-	int const line,
 	Error const &err,
 	StringViewCR,
-	StringViewCR assertMsg) noexcept {
+	StringViewCR assertMsg,
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if (err) {
 		if (!std::is_constant_evaluated()) {
-			assertFailFuncRuntime(file, line, err, {}, assertMsg);
+			assertFailFuncRuntime(err, {}, assertMsg, src);
 		} else {
 			while (true);
 		}
@@ -81,20 +80,31 @@ constexpr void assertFunc(
 }
 
 constexpr void expect(
-	StringViewCR file,
-	int const line,
 	auto const &actual,
-	auto const&expected) noexcept {
+	auto const &expected,
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if (actual != expected) {
 		 if (!std::is_constant_evaluated()) {
 #if defined(OX_USE_STDLIB)
-			oxErrf("\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n", file, line, "Value incorrect");
+			oxErrf(
-			oxErrf("expected: {}\nactual:   {}\n", detail::toStringView<true>(expected), detail::toStringView<true>(actual));
+				"\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n",
+				src.file_name(),
+				src.line(),
+				"Value incorrect");
+			oxErrf(
+				"expected: {}\nactual:   {}\n",
+				detail::toStringView<true>(expected),
+				detail::toStringView<true>(actual));
 			printStackTrace(2);
-			oxTracef("assert.expect", "Failed assert: {} == {} [{}:{}]", detail::toStringView<true>(actual), detail::toStringView<true>(expected), file, line);
+			oxTracef(
+				"assert.expect", "Failed assert: {} == {} [{}:{}]",
+				detail::toStringView<true>(actual),
+				detail::toStringView<true>(expected),
+				src.file_name(),
+				src.line());
 			std::abort();
 #else
-			constexprPanic(file, line, "Comparison failed");
+			constexprPanic("Comparison failed", {}, src);
 #endif
 		} else {
 			while (true);

deps/ox/src/ox/std/byteswap.hpp

@@ -17,19 +17,19 @@ namespace ox {
 
 template<typename T>
 [[nodiscard]]
-constexpr T byteSwap(typename enable_if<sizeof(T) == 1, T>::type i) noexcept {
+constexpr T byteSwap(T const i) noexcept requires(sizeof(T) == 1) {
 	return i;
 }
 
 template<typename T>
 [[nodiscard]]
-constexpr T byteSwap(typename enable_if<sizeof(T) == 2, T>::type i) noexcept {
+constexpr T byteSwap(T const i) noexcept requires(sizeof(T) == 2) {
 	return static_cast<T>(i << 8) | static_cast<T>(i >> 8);
 }
 
 template<typename T>
 [[nodiscard]]
-constexpr T byteSwap(typename enable_if<sizeof(T) == 4, T>::type i) noexcept {
+constexpr T byteSwap(T const i) noexcept requires(sizeof(T) == 4) {
 	return ((i >> 24) & 0x000000ff) |
 	       ((i >>  8) & 0x0000ff00) |
 	       ((i <<  8) & 0x00ff0000) |
@@ -38,7 +38,7 @@ constexpr T byteSwap(typename enable_if<sizeof(T) == 4, T>::type i) noexcept {
 
 template<typename T>
 [[nodiscard]]
-constexpr T byteSwap(typename enable_if<sizeof(T) == 8, T>::type i) noexcept {
+constexpr T byteSwap(T const i) noexcept requires(sizeof(T) == 8) {
 	return ((i >> 56) & 0x00000000000000ff) |
 	       ((i >> 40) & 0x000000000000ff00) |
 	       ((i >> 24) & 0x0000000000ff0000) |

deps/ox/src/ox/std/concepts.hpp

@@ -32,4 +32,8 @@ concept Integral_c = ox::is_integral_v<T>;
 
 template<typename T, size_t max>
 concept IntegerRange_c = ox::is_integer_v<T> && ox::MaxValue<T> >= max;
+
+template<typename Union>
+concept Union_c = is_union_v<Union>;
+
 }

deps/ox/src/ox/std/def.hpp

@@ -48,9 +48,8 @@
 
 // Asserts
 
-#define oxPanic(errCode, msg) ox::panic(__FILE__, __LINE__, msg, errCode)
 #ifndef NDEBUG
-#define oxAssert(pass, msg) ox::assertFunc(__FILE__, __LINE__, pass, #pass, msg)
+#define oxAssert(pass, msg) ox::assertFunc(pass, #pass, msg)
 #else
 namespace ox {
 struct [[nodiscard]] Error;
@@ -59,8 +58,6 @@ constexpr void oxAssert(bool, const char*) noexcept {}
 constexpr void oxAssert(const ox::Error&, const char*) noexcept {}
 #endif
 
-#define oxExpect(actual, expected) ox::expect(__FILE__, __LINE__, actual, expected)
-
 // Alloca
 
 #if defined(_MSC_VER)

deps/ox/src/ox/std/error.hpp

@@ -110,7 +110,10 @@ struct Exception: public std::exception {
 };
 
 [[noreturn]]
-void panic(char const*file, int line, char const*panicMsg, Error const&err) noexcept;
+void panic(
+	Error const &err,
+	char const *panicMsg,
+	std::source_location const &src = std::source_location::current()) noexcept;
 
 template<typename T>
 struct [[nodiscard]] Result {
@@ -182,7 +185,7 @@ struct [[nodiscard]] Result {
 	[[nodiscard]]
 	constexpr T &unwrap() & noexcept {
 		if (error) {
-			oxPanic(error, "Failed unwrap");
+			ox::panic(error, "Failed unwrap");
 		}
 		return value;
 	}
@@ -190,7 +193,7 @@ struct [[nodiscard]] Result {
 	[[nodiscard]]
 	constexpr T &&unwrap() && noexcept {
 		if (error) {
-			oxPanic(error, "Failed unwrap");
+			ox::panic(error, "Failed unwrap");
 		}
 		return std::move(value);
 	}
@@ -198,7 +201,7 @@ struct [[nodiscard]] Result {
 	[[nodiscard]]
 	constexpr T const &unwrap() const & noexcept {
 		if (error) [[unlikely]] {
-			oxPanic(error, "Failed unwrap");
+			ox::panic(error, "Failed unwrap");
 		}
 		return value;
 	}
@@ -329,23 +332,25 @@ constexpr Error toError(Result<T> const&r) noexcept {
 
 }
 
-constexpr void primitiveAssert(char const*file, int line, bool pass, char const*msg) noexcept {
+constexpr void primitiveAssert(
+	bool const pass,
+	char const *msg,
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if constexpr(ox::defines::Debug) {
 		if (!pass) [[unlikely]] {
-			panic(file, line, msg, ox::Error(1));
+			panic(ox::Error{1}, msg, src);
 		}
 	}
 }
 
 constexpr void boundsCheck(
-	char const*file,
-	int const line,
 	size_t const i,
 	size_t const sz,
-	char const*msg) noexcept {
+	char const *msg,
+	std::source_location const &src = std::source_location::current()) noexcept {
 	if constexpr(defines::CheckBounds) {
 		if (i >= sz) [[unlikely]] {
-			panic(file, line, msg, ox::Error{1});
+			panic(ox::Error{1}, msg, src);
 		}
 	}
 }

deps/ox/src/ox/std/heapmgr.cpp

@@ -77,7 +77,7 @@ static HeapSegment *findSegmentFor(std::size_t sz) noexcept {
 			return s;
 		}
 	}
-	oxPanic(ox::Error(1), "malloc: could not find segment");
+	ox::panic(ox::Error(1), "malloc: could not find segment");
 	return nullptr;
 }
 
@@ -102,7 +102,7 @@ void free(void *ptr) noexcept {
 	} else if (p.segment) {
 		p.segment->inUse = false;
 	} else {
-		oxPanic(ox::Error(1), "Bad heap free");
+		ox::panic(ox::Error(1), "Bad heap free");
 	}
 }
 

deps/ox/src/ox/std/iterator.hpp

@@ -133,17 +133,17 @@ struct SpanIterator {
 		}
 
 		constexpr PtrType operator->() const noexcept {
-			boundsCheck(__FILE__, __LINE__, m_offset, m_max, "SpanIterator access overflow");
+			boundsCheck(m_offset, m_max, "SpanIterator access overflow");
 			return &m_t[m_offset];
 		}
 
 		constexpr RefType operator*() const noexcept {
-			boundsCheck(__FILE__, __LINE__, m_offset, m_max, "SpanIterator access overflow");
+			boundsCheck(m_offset, m_max, "SpanIterator access overflow");
 			return m_t[m_offset];
 		}
 
 		constexpr RefType operator[](std::size_t s) const noexcept {
-			boundsCheck(__FILE__, __LINE__, s, m_max, "SpanIterator access overflow");
+			boundsCheck(s, m_max, "SpanIterator access overflow");
 			return m_t[s];
 		}
 

deps/ox/src/ox/std/new.hpp

@@ -30,11 +30,49 @@ constexpr void *operator new(std::size_t, void *addr) noexcept {
 constexpr void *operator new[](std::size_t, void *addr) noexcept {
 	return addr;
 }
+
+namespace std {
+
+template<typename T>
+[[nodiscard]]
+constexpr T* launder(T* __p) noexcept {
+	return __builtin_launder(__p);
+}
+
+template<typename T, typename... Args, bool noex>
+void launder(T(*)(Args...) noexcept(noex)) = delete;
+template<typename T, typename... Args, bool noex>
+void launder(T(*)(Args......) noexcept(noex)) = delete;
+void launder(void*) = delete;
+void launder(void const*) = delete;
+void launder(volatile void*) = delete;
+void launder(volatile void const*) = delete;
+
+}
 #endif
 
 
 namespace ox {
 
+/**
+ * Aliases type T in size and alignment to allow allocating space for a T
+ * without running the constructor.
+ */
+template<typename T, std::size_t sz = sizeof(T)>
+struct alignas(alignof(T)) AllocAlias {
+	char buff[sz];
+	constexpr AllocAlias() noexcept = default;
+	[[nodiscard]]
+	auto data() noexcept {
+		return reinterpret_cast<T*>(this);
+	}
+	[[nodiscard]]
+	auto data() const noexcept {
+		return reinterpret_cast<T const*>(this);
+	}
+};
+
+
 template<typename T, typename U = T, typename ...Args>
 [[nodiscard]]
 constexpr U *make(Args &&...args) noexcept {
@@ -42,10 +80,10 @@ constexpr U *make(Args &&...args) noexcept {
 	try {
 		return new T(ox::forward<Args>(args)...);
 	} catch (std::exception const &ex) {
-		oxPanic(ox::Error(1, ex.what()), ex.what());
+		ox::panic(ox::Error(1, ex.what()), ex.what());
 		return nullptr;
 	} catch (...) {
-		oxPanic(ox::Error(2, "Allocation or constructor failed"),  "Allocation or constructor failed");
+		ox::panic(ox::Error(2, "Allocation or constructor failed"),  "Allocation or constructor failed");
 		return nullptr;
 	}
 #else

deps/ox/src/ox/std/span.hpp

@@ -147,17 +147,17 @@ class Span {
 		}
 
 		constexpr T &operator[](std::size_t i) const noexcept {
-			boundsCheck(__FILE__, __LINE__, i, size(), "Span access overflow");
+			boundsCheck(i, size(), "Span access overflow");
 			return m_items[i];
 		}
 
 		constexpr Span operator+(size_t i) const noexcept {
-			boundsCheck(__FILE__, __LINE__, i, size(), "Span access overflow");
+			boundsCheck(i, size(), "Span access overflow");
 			return {m_items + i, m_size - i};
 		}
 
 		constexpr Span operator+=(size_t i) noexcept {
-			boundsCheck(__FILE__, __LINE__, i, size(), "Span access overflow");
+			boundsCheck(i, size(), "Span access overflow");
 			m_items += i;
 			m_size -= i;
 			return *this;

deps/ox/src/ox/std/strconv.hpp

@@ -17,7 +17,7 @@
 namespace ox {
 
 template<Integer_c Integer>
-constexpr ox::Error writeItoa(Integer v, ox::Writer_c auto &writer) noexcept {
+constexpr ox::Error writeItoa(Integer const v, ox::Writer_c auto &writer) noexcept {
 	if (v) {
 		ox::ResizedInt_t<Integer, 64> mod = 1000000000000000000;
 		ox::ResizedInt_t<Integer, 64> val = v;
@@ -25,19 +25,25 @@ constexpr ox::Error writeItoa(Integer v, ox::Writer_c auto &writer) noexcept {
 		auto it = 0;
 		if (val < 0) {
 			OX_RETURN_ERROR(writer.put('-'));
-				++it;
+			val = ~val + 1;
 		}
-			while (mod) {
+		if constexpr(sizeof(v) == 8 && !ox::is_signed_v<Integer>) {
 			auto digit = val / mod;
 			val %= mod;
 			mod /= base;
-				if (it || digit) {
+			if (digit) {
-					ox::ResizedInt_t<Integer, 64> start = '0';
-					if (digit >= 10) {
-						start = 'a';
 				digit -= 10;
+				OX_RETURN_ERROR(writer.put('1'));
+				OX_RETURN_ERROR(writer.put(static_cast<char>('0' + digit)));
+				++it;
 			}
-					OX_RETURN_ERROR(writer.put(static_cast<char>(start + digit)));
+		}
+		while (mod) {
+			auto const digit = val / mod;
+			val %= mod;
+			mod /= base;
+			if (it || digit) {
+				OX_RETURN_ERROR(writer.put(static_cast<char>('0' + digit)));
 				++it;
 			}
 		}

deps/ox/src/ox/std/stringliteral.hpp

@@ -23,12 +23,12 @@ class StringLiteral: public detail::BaseStringView {
 
 		constexpr StringLiteral(StringLiteral const &sv) noexcept = default;
 
-		consteval explicit StringLiteral(std::nullptr_t) noexcept {}
+		consteval StringLiteral(std::nullptr_t) noexcept {}
 
-		consteval explicit StringLiteral(char const *str, std::size_t const len) noexcept: BaseStringView{str, len} {}
+		consteval StringLiteral(char const *str, std::size_t const len) noexcept: BaseStringView{str, len} {}
 
 		OX_ALLOW_UNSAFE_BUFFERS_BEGIN
-		consteval explicit StringLiteral(char const *str) noexcept: StringLiteral{str, ox::strlen(str)} {}
+		consteval StringLiteral(char const *str) noexcept: StringLiteral{str, ox::strlen(str)} {}
 		OX_ALLOW_UNSAFE_BUFFERS_END
 
 		constexpr StringLiteral &operator=(StringLiteral const &other) noexcept {

deps/ox/src/ox/std/test/CMakeLists.txt

@@ -28,3 +28,4 @@ add_test("[ox/std] FromHex" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/StdTest "FromHex")
 add_test("[ox/std] ToHex" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/StdTest "ToHex")
 add_test("[ox/std] UUID" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/StdTest "UUID")
 add_test("[ox/std] UUID::generate" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/StdTest "UUID::generate")
+add_test("[ox/std] intToStr" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/StdTest "intToStr")

deps/ox/src/ox/std/test/tests.cpp

@@ -30,7 +30,7 @@ static uint64_t steadyNowMs() {
 }
 
 template<typename Map = ox::SmallMap<ox::String, ox::UUID>>
-uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexcept {
+uint64_t timeMapStrToUuid(int const elemCnt, int const lookups, uint64_t seed = 4321) noexcept {
 	ox::UUID::seedGenerator({1234, seed});
 	Map map;
 	// setup test map
@@ -45,13 +45,14 @@ uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	for (int i = 0; i < lookups; ++i) {
 		auto const &k = keys[rand.gen() % keys.size()];
 		map[k];
-		oxExpect(map[k], ox::UUID::fromString(k).unwrap());
+		ox::expect(map[k], ox::UUID::fromString(k).unwrap());
 	}
 	return steadyNowMs() - startTime;
 }
 
 template<typename Map = ox::SmallMap<ox::UUID, ox::String>>
-uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexcept {
+[[nodiscard]]
+uint64_t timeMapUuidToStr(int const elemCnt, int const lookups, uint64_t seed = 4321) noexcept {
 	ox::UUID::seedGenerator({1234, seed});
 	Map map;
 	// setup test map
@@ -65,12 +66,12 @@ uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	auto const startTime = steadyNowMs();
 	for (int i = 0; i < lookups; ++i) {
 		auto const &k = keys[rand.gen() % keys.size()];
-		oxExpect(map[k], k.toString());
+		ox::expect(map[k], k.toString());
 	}
 	return steadyNowMs() - startTime;
 }
 
-static ox::Error compareMaps(int lookupCnt = 1'000'000) {
+static ox::Error compareMaps(int const lookupCnt = 1'000'000) {
 	auto const seed = steadyNowMs();
 	uint64_t hashTime{};
 	uint64_t smallTime{};
@@ -126,7 +127,7 @@ OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
 OX_CLANG_NOWARN_END
 			ox::heapmgr::free(a1);
 			ox::heapmgr::free(a2);
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -135,13 +136,13 @@ OX_CLANG_NOWARN_END
 			ox::Array<char, 10> buff;
 			ox::CharBuffWriter bw(buff);
 			oxAssert(ox::writeItoa(5, bw), "ox::writeItoa returned Error");
-			oxExpect(ox::StringView(buff.data()), ox::StringView("5"));
+			ox::expect(ox::StringView(buff.data()), ox::StringView("5"));
 			OX_RETURN_ERROR(bw.seekp(0));
 			oxAssert(ox::writeItoa(50, bw), "ox::writeItoa returned Error");
-			oxExpect(ox::StringView(buff.data()), ox::StringView("50"));
+			ox::expect(ox::StringView(buff.data()), ox::StringView("50"));
 			OX_RETURN_ERROR(bw.seekp(0));
 			oxAssert(ox::writeItoa(500, bw), "ox::writeItoa returned Error");
-			oxExpect(ox::StringView(buff.data()), ox::StringView("500"));
+			ox::expect(ox::StringView(buff.data()), ox::StringView("500"));
 			return ox::Error{};
 		}
 	},
@@ -184,7 +185,7 @@ OX_CLANG_NOWARN_END
 			oxAssert(s == "asdf", "String assign broken");
 			oxAssert(s != "aoeu", "String assign broken");
 			oxAssert(s.size() == 4, "String assign broken");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -214,11 +215,11 @@ OX_CLANG_NOWARN_END
 			oxAssert(ox::StringView("Write") != ox::String(""), "String / StringView comparison broken");
 			oxAssert(ox::String("Write") != ox::StringView(""), "String / StringView comparison broken");
 			oxAssert(ox::String("Write") == ox::StringView("Write"), "String / StringView comparison broken");
-			oxExpect(ox::String("asdf").substr(1, 3), "sd");
+			ox::expect(ox::String("asdf").substr(1, 3), "sd");
 			oxAssert(
 					ox::String(ox::StringView("Write")) == ox::StringView("Write"),
 					"String / StringView comparison broken");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -227,16 +228,16 @@ OX_CLANG_NOWARN_END
 			ox::Vector<int> v;
 			oxAssert(v.size() == 0, "Initial Vector size not 0");
 			oxAssert(v.empty(), "Vector::empty() is broken");
-			auto insertTest = [&v](int val, std::size_t size) {
+			auto insertTest = [&v](int const val, std::size_t const size) {
 				v.push_back(val);
 				OX_RETURN_ERROR(ox::Error(v.size() != size, "Vector size incorrect"));
 				OX_RETURN_ERROR(ox::Error(v[v.size() - 1] != val, "Vector value wrong"));
-				return ox::Error(0);
+				return ox::Error{};
 			};
 			oxAssert(insertTest(42, 1), "Vector insertion failed");
 			oxAssert(insertTest(100, 2), "Vector insertion failed");
 			oxAssert(insertTest(102, 3), "Vector insertion failed");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -249,9 +250,9 @@ OX_CLANG_NOWARN_END
 				v.emplace_back("aoeu");
 				auto const origData = v.data();
 				v.shrink_to_fit();
-				oxExpect(v[0], "asdf");
+				ox::expect(v[0], "asdf");
-				oxExpect(v[1], "aoeu");
+				ox::expect(v[1], "aoeu");
-				oxExpect(v.capacity(), 2u);
+				ox::expect(v.capacity(), 2u);
 				oxAssert(origData != v.data(), "shrink_to_fit did not create a new allocation");
 			}
 			{
@@ -261,9 +262,9 @@ OX_CLANG_NOWARN_END
 				v.emplace_back("aoeu");
 				auto const origData = v.data();
 				v.shrink_to_fit();
-				oxExpect(v[0], "asdf");
+				ox::expect(v[0], "asdf");
-				oxExpect(v[1], "aoeu");
+				ox::expect(v[1], "aoeu");
-				oxExpect(v.capacity(), 2u);
+				ox::expect(v.capacity(), 2u);
 				oxAssert(origData == v.data(), "shrink_to_fit inappropriately created a new allocation");
 			}
 			return ox::Error{};
@@ -273,13 +274,13 @@ OX_CLANG_NOWARN_END
 		"findIdx",
 		[] {
 			ox::Vector<ox::IString<8>> const v {"zero", "one", "two", "three", "four"};
-			oxExpect(ox::findIdx(v.begin(), v.end(), "zero").or_value(5), 0u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "zero").or_value(5), 0u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "five").or_value(5), 5u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "five").or_value(5), 5u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "six").or_value(6), 6u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "six").or_value(6), 6u);
 			return ox::Error{};
 		}
 	},
@@ -288,19 +289,19 @@ OX_CLANG_NOWARN_END
 		[] {
 			ox::SmallMap<ox::String, ox::String> map;
 			map["asdf"] = "aoeu";
-			oxExpect(map["asdf"], "aoeu");
+			ox::expect(map["asdf"], "aoeu");
-			oxExpect(map.size(), 1u);
+			ox::expect(map.size(), 1u);
-			oxExpect(map["aoeu"], "");
+			ox::expect(map["aoeu"], "");
-			oxExpect(map.size(), 2u);
+			ox::expect(map.size(), 2u);
 			ox::SmallMap<ox::String, ox::String> cmap;
 			cmap["asdf"] = "aoeu";
 			auto constexpr constTest = [](ox::SmallMap<ox::String, ox::String> const &map) {
 				OX_REQUIRE(asdf, map.at("asdf"));
-				oxExpect(*asdf, "aoeu");
+				ox::expect(*asdf, "aoeu");
-				oxExpect(map.size(), 1u);
+				ox::expect(map.size(), 1u);
 				auto const aoeu = map.at("aoeu");
-				oxExpect(aoeu.ok(), false);
+				ox::expect(aoeu.ok(), false);
-				oxExpect(map.size(), 1u);
+				ox::expect(map.size(), 1u);
 				return ox::Error{};
 			};
 			return constTest(cmap);
@@ -319,7 +320,7 @@ OX_CLANG_NOWARN_END
 			ii[5] = 100;
 			oxAssert(ii[4] == 42, "4 != 42");
 			oxAssert(ii[5] == 100, "5 != 100");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -334,18 +335,17 @@ OX_CLANG_NOWARN_END
 			oxAssert(!si.contains("asdf"), "wrongly contains asdf");
 			oxAssert(si.contains("aoeu"), "does not contains aoeu");
 			oxAssert(!si.at("asdf").ok(), "asdf != 0");
-			oxExpect(si["asdf"], 0);
+			ox::expect(si["asdf"], 0);
 			oxAssert(si["aoeu"] == 100, "aoeu != 100");
 			auto si2 = si;
-			oxDebugf("{}", si2["asdf"]);
+			ox::expect(si2["asdf"], 0);
-			oxExpect(si2["asdf"], 0);
 			oxAssert(si2["aoeu"] == 100, "aoeu != 100");
 			ox::HashMap<int, int> ii;
 			ii[4] = 42;
 			ii[5] = 100;
 			oxAssert(ii[4] == 42, "4 != 42");
 			oxAssert(ii[5] == 100, "5 != 100");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -378,15 +378,15 @@ OX_CLANG_NOWARN_END
 				   static_cast<int>(actual[1]),
 				   static_cast<int>(actual[2]),
 				   static_cast<int>(actual[3]));
-			oxExpect(ox::serialize<int32_t>(4).unwrap(), BA({4, 0, 0, 0}));
+			ox::expect(ox::serialize<int32_t>(4).unwrap(), BA({4, 0, 0, 0}));
-			oxExpect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0}));
+			ox::expect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0}));
-			oxExpect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0}));
+			ox::expect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0}));
-			oxExpect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0}));
+			ox::expect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0}));
-			oxExpect(ox::serialize<uint32_t>(256).unwrap(), BA({0, 1, 0, 0}));
+			ox::expect(ox::serialize<uint32_t>(256).unwrap(), BA({0, 1, 0, 0}));
-			oxExpect(ox::serialize<uint32_t>(257).unwrap(), BA({1, 1, 0, 0}));
+			ox::expect(ox::serialize<uint32_t>(257).unwrap(), BA({1, 1, 0, 0}));
 			constexpr auto neg1 = static_cast<char>(-1); // ARM64 Linux assumes -1 literals are ints...
-			oxExpect(ox::serialize<uint32_t>(0xffff'ffff).unwrap(), BA({neg1, neg1, neg1, neg1}));
+			ox::expect(ox::serialize<uint32_t>(0xffff'ffff).unwrap(), BA({neg1, neg1, neg1, neg1}));
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -395,58 +395,58 @@ OX_CLANG_NOWARN_END
 			ox::Buffer b;
 			ox::BufferWriter w(&b);
 			oxAssert(w.write("asdf", 4), "write failed");
-			oxExpect(b.size(), 4u);
+			ox::expect(b.size(), 4u);
 			oxAssert(w.write("aoeu", 4), "write failed");
-			oxExpect(b.size(), 8u);
+			ox::expect(b.size(), 8u);
-			oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeu");
+			ox::expect(ox::StringView(b.data(), b.size()), "asdfaoeu");
 			ox::StringView constexpr qwerty = "qwerty";
 			oxAssert(w.write(qwerty.data(), qwerty.bytes()), "write failed");
-			oxExpect(b.size(), 14u);
+			ox::expect(b.size(), 14u);
-			oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty");
+			ox::expect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
 		"FromHex",
 		[] {
-			oxExpect(ox::detail::fromHex("01").unwrap(), 0x01);
+			ox::expect(ox::detail::fromHex("01").unwrap(), 0x01);
-			oxExpect(ox::detail::fromHex("02").unwrap(), 0x02);
+			ox::expect(ox::detail::fromHex("02").unwrap(), 0x02);
-			oxExpect(ox::detail::fromHex("03").unwrap(), 0x03);
+			ox::expect(ox::detail::fromHex("03").unwrap(), 0x03);
-			oxExpect(ox::detail::fromHex("04").unwrap(), 0x04);
+			ox::expect(ox::detail::fromHex("04").unwrap(), 0x04);
-			oxExpect(ox::detail::fromHex("05").unwrap(), 0x05);
+			ox::expect(ox::detail::fromHex("05").unwrap(), 0x05);
-			oxExpect(ox::detail::fromHex("06").unwrap(), 0x06);
+			ox::expect(ox::detail::fromHex("06").unwrap(), 0x06);
-			oxExpect(ox::detail::fromHex("07").unwrap(), 0x07);
+			ox::expect(ox::detail::fromHex("07").unwrap(), 0x07);
-			oxExpect(ox::detail::fromHex("08").unwrap(), 0x08);
+			ox::expect(ox::detail::fromHex("08").unwrap(), 0x08);
-			oxExpect(ox::detail::fromHex("0d").unwrap(), 0x0d);
+			ox::expect(ox::detail::fromHex("0d").unwrap(), 0x0d);
-			oxExpect(ox::detail::fromHex("0e").unwrap(), 0x0e);
+			ox::expect(ox::detail::fromHex("0e").unwrap(), 0x0e);
-			oxExpect(ox::detail::fromHex("0f").unwrap(), 0x0f);
+			ox::expect(ox::detail::fromHex("0f").unwrap(), 0x0f);
-			oxExpect(ox::detail::fromHex("0F").unwrap(), 0x0f);
+			ox::expect(ox::detail::fromHex("0F").unwrap(), 0x0f);
-			oxExpect(ox::detail::fromHex("fF").unwrap(), 0xff);
+			ox::expect(ox::detail::fromHex("fF").unwrap(), 0xff);
-			oxExpect(ox::detail::fromHex("ff").unwrap(), 0xff);
+			ox::expect(ox::detail::fromHex("ff").unwrap(), 0xff);
-			oxExpect(ox::detail::fromHex("a0").unwrap(), 0xa0);
+			ox::expect(ox::detail::fromHex("a0").unwrap(), 0xa0);
-			oxExpect(ox::detail::fromHex("93").unwrap(), 0x93);
+			ox::expect(ox::detail::fromHex("93").unwrap(), 0x93);
-			oxExpect(ox::detail::fromHex("40").unwrap(), 0x40);
+			ox::expect(ox::detail::fromHex("40").unwrap(), 0x40);
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
 		"ToHex",
 		[] {
-			oxExpect(ox::detail::toHex(0x01), "01");
+			ox::expect(ox::detail::toHex(0x01), "01");
-			oxExpect(ox::detail::toHex(0x02), "02");
+			ox::expect(ox::detail::toHex(0x02), "02");
-			oxExpect(ox::detail::toHex(0x03), "03");
+			ox::expect(ox::detail::toHex(0x03), "03");
-			oxExpect(ox::detail::toHex(0x04), "04");
+			ox::expect(ox::detail::toHex(0x04), "04");
-			oxExpect(ox::detail::toHex(0x05), "05");
+			ox::expect(ox::detail::toHex(0x05), "05");
-			oxExpect(ox::detail::toHex(0x06), "06");
+			ox::expect(ox::detail::toHex(0x06), "06");
-			oxExpect(ox::detail::toHex(0x07), "07");
+			ox::expect(ox::detail::toHex(0x07), "07");
-			oxExpect(ox::detail::toHex(0x08), "08");
+			ox::expect(ox::detail::toHex(0x08), "08");
-			oxExpect(ox::detail::toHex(0x0d), "0d");
+			ox::expect(ox::detail::toHex(0x0d), "0d");
-			oxExpect(ox::detail::toHex(0x0e), "0e");
+			ox::expect(ox::detail::toHex(0x0e), "0e");
-			oxExpect(ox::detail::toHex(0x0f), "0f");
+			ox::expect(ox::detail::toHex(0x0f), "0f");
-			oxExpect(ox::detail::toHex(0x93), "93");
+			ox::expect(ox::detail::toHex(0x93), "93");
-			oxExpect(ox::detail::toHex(0x40), "40");
+			ox::expect(ox::detail::toHex(0x40), "40");
-			oxExpect(ox::detail::toHex(0xf0), "f0");
+			ox::expect(ox::detail::toHex(0xf0), "f0");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -454,20 +454,20 @@ OX_CLANG_NOWARN_END
 		[] {
 			constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db";
 			OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr));
-			oxExpect(uuid.toString(), uuidStr);
+			ox::expect(uuid.toString(), uuidStr);
-			oxExpect(ox::UUID{}.isNull(), true);
+			ox::expect(ox::UUID{}.isNull(), true);
-			oxExpect(ox::UUID::fromString(uuidStr).value.isNull(), false);
+			ox::expect(ox::UUID::fromString(uuidStr).value.isNull(), false);
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
 		"UUID::generate",
 		[] {
 			ox::UUID::seedGenerator({1234, 4321});
-			oxExpect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827");
+			ox::expect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827");
-			oxExpect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf");
+			ox::expect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf");
-			oxExpect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e");
+			ox::expect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e");
-			return ox::Error(0);
+			return ox::Error{};
 		}
 	},
 	{
@@ -475,71 +475,100 @@ OX_CLANG_NOWARN_END
 		[] {
 			ox::StringView sv = "ab.cd";
 			auto list = ox::split(sv, ".");
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = "ab.cd.fg";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 3u);
+			ox::expect(list.size(), 3u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
-			oxExpect(list[2], "fg");
+			ox::expect(list[2], "fg");
 			sv = "ab.cd.";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = ".ab.cd.";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = ".";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
 			sv = ".";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
 			sv = "";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
 			// split by single char
 			sv = "ab.cd";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = "ab.cd.fg";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 3u);
+			ox::expect(list.size(), 3u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
-			oxExpect(list[2], "fg");
+			ox::expect(list[2], "fg");
 			sv = "ab.cd.";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = ".ab.cd.";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 2u);
+			ox::expect(list.size(), 2u);
-			oxExpect(list[0], "ab");
+			ox::expect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list[1], "cd");
 			sv = ".";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
 			sv = ".";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
 			sv = "";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 0u);
+			ox::expect(list.size(), 0u);
-			return ox::Error(0);
+			return ox::Error{};
+		}
+	},
+	{
+		"intToStr",
+		[] {
+			ox::expect(ox::intToStr<uint8_t>(255u), "255");
+			ox::expect(ox::intToStr<int8_t>(127), "127");
+			ox::expect(ox::intToStr<int8_t>(-128), "-128");
+			ox::expect(ox::intToStr<uint16_t>(65535u), "65535");
+			ox::expect(ox::intToStr<int16_t>(32767), "32767");
+			ox::expect(ox::intToStr<int16_t>(-32768), "-32768");
+			ox::expect(ox::intToStr<uint32_t>(4294967295u), "4294967295");
+			ox::expect(ox::intToStr<int32_t>(2147483647), "2147483647");
+			ox::expect(ox::intToStr<int32_t>(-2147483648), "-2147483648");
+			ox::expect(ox::intToStr<uint64_t>(18446744073709551615u), "18446744073709551615");
+			ox::expect(ox::intToStr<int64_t>(9223372036854775807), "9223372036854775807");
+			ox::expect(ox::intToStr<int64_t>(-9223372036854775807), "-9223372036854775807");
+			ox::expect(ox::intToStr<uint64_t>(0), "0");
+			ox::expect(ox::intToStr<uint64_t>(5), "5");
+			ox::expect(ox::intToStr(0), "0");
+			ox::expect(ox::intToStr(5), "5");
+			ox::expect(ox::intToStr(5000), "5000");
+			ox::expect(ox::intToStr(50000), "50000");
+			ox::expect(ox::intToStr(500000), "500000");
+			ox::expect(ox::intToStr(-5), "-5");
+			ox::expect(ox::intToStr(-5000), "-5000");
+			ox::expect(ox::intToStr(-50000), "-50000");
+			ox::expect(ox::intToStr(-500000), "-500000");
+			return ox::Error{};
 		}
 	},
 };
 
-int main(int argc, const char **argv) {
+int main(int const argc, const char **argv) {
 	if (argc < 2) {
 		oxError("Must specify test to run");
 		return -1;

deps/ox/src/ox/std/trace.hpp

@@ -268,7 +268,7 @@ using TraceStream = NullStream;
 
 inline void logError(const char *file, int line, const char *fmt, const Error &err) noexcept {
 	if (err) {
-		TraceStream trc(file, line, "ox::error");
+		TraceStream trc(file, line, "ox.error");
 		if (err.src.file_name() != nullptr) {
 			trc << "Error: (" << err.src.file_name() << ":" << err.src.line() << "):";
 		} else {
@@ -280,7 +280,7 @@ inline void logError(const char *file, int line, const char *fmt, const Error &e
 
 inline void logError(const char *file, int line, const Error &err) noexcept {
 	if (err) {
-		TraceStream trc(file, line, "ox::error");
+		TraceStream trc(file, line, "ox.error");
 		trc <<  "Error:" << err;
 		if (err.src.file_name() != nullptr) {
 			trc << "(" << err.src.file_name() << ":" << err.src.line() << ")";

deps/ox/src/ox/std/types.hpp

@@ -63,25 +63,6 @@ namespace ox {
 
 using CString = char const*;
 
-/**
- * Aliases type T in size and alignment to allow allocating space for a T
- * without running the constructor.
- */
-template<typename T, std::size_t sz = sizeof(T)>
-struct alignas(alignof(T)) AllocAlias {
-	char buff[sz];
-	constexpr AllocAlias() noexcept = default;
-	[[nodiscard]]
-	auto data() noexcept {
-		return reinterpret_cast<T*>(this);
-	}
-	[[nodiscard]]
-	auto data() const noexcept {
-		return reinterpret_cast<const T*>(this);
-	}
-};
-
-
 template<std::size_t sz>
 struct SignedType {
 };

deps/ox/src/ox/std/typetraits.hpp

@@ -180,20 +180,6 @@ struct is_same<T, T>: true_type {};
 template<typename T, typename U>
 constexpr auto is_same_v = is_same<T, U>::value;
 
-// enable_if ///////////////////////////////////////////////////////////////////
-
-template<bool B, class T = void>
-struct enable_if {
-};
-
-template<class T>
-struct enable_if<true, T> {
-	using type = T;
-};
-
-template<bool B, typename T>
-using enable_if_t = typename enable_if<B, T>::type;
-
 template<typename T>
 struct is_pointer {
 	static constexpr bool value = false;

deps/ox/src/ox/std/vector.hpp

@@ -34,10 +34,10 @@ struct VectorAllocator {
 		ox::Array<AllocAlias<T>, Size> m_data = {};
 	protected:
 		constexpr VectorAllocator() noexcept = default;
-		constexpr VectorAllocator(const VectorAllocator&) noexcept = default;
+		constexpr VectorAllocator(VectorAllocator const&) noexcept = default;
 		constexpr VectorAllocator(VectorAllocator&&) noexcept = default;
 
-		constexpr void allocate(T **items, std::size_t cap) noexcept {
+		constexpr void allocate(T **items, std::size_t const cap) noexcept {
 			// small vector optimization cannot be done it constexpr, but it doesn't really matter in constexpr
 			if (std::is_constant_evaluated() || cap > Size) {
 				*items = Allocator{}.allocate(cap);
@@ -49,42 +49,26 @@ struct VectorAllocator {
 		constexpr void moveConstructItemsFrom(
 				T **items,
 				VectorAllocator *src,
-				const std::size_t count,
+				std::size_t const count,
-				const std::size_t cap) noexcept {
+				std::size_t const cap) noexcept {
 			// this totally idiotic redundant check (&& count <= Size) is required to address a bug in devkitARM,
 			// try removing it later
 			if (!std::is_constant_evaluated()) {
 				if (cap <= m_data.size() && count <= m_data.size()) {
 					for (auto i = 0u; i < count; ++i) {
-						const auto dstItem = reinterpret_cast<T *>(&m_data[i]);
+						auto const srcItem = std::launder(reinterpret_cast<T*>(&src->m_data[i]));
-						const auto srcItem = reinterpret_cast<T *>(&src->m_data[i]);
+						new (&m_data[i]) T(std::move(*srcItem));
-						std::construct_at<T>(dstItem, std::move(*srcItem));
 					}
+					if (count) {
+						*items = std::launder(reinterpret_cast<T*>(m_data.data()));
+					} else {
 						*items = reinterpret_cast<T*>(m_data.data());
 					}
 				}
 			}
-
-		constexpr void moveItemsFrom(
-				T **items,
-				VectorAllocator *src,
-				const std::size_t count,
-				const std::size_t cap) noexcept {
-			// this totally idiotic redundant check (&& count <= Size) is required to address a bug in devkitARM,
-			// try removing it later
-			if (!std::is_constant_evaluated()) {
-				if (cap <= m_data.size() && count <= m_data.size()) {
-					for (std::size_t i = 0; i < count; ++i) {
-						const auto dstItem = reinterpret_cast<T *>(&m_data[i]);
-						const auto srcItem = reinterpret_cast<T *>(&src->m_data[i]);
-						*dstItem = std::move(*srcItem);
-					}
-					*items = reinterpret_cast<T*>(m_data.data());
-				}
-			}
 		}
 
-		constexpr void deallocate(T *items, std::size_t cap) noexcept {
+		constexpr void deallocate(T *const items, std::size_t const cap) noexcept {
 			// small vector optimization cannot be done it constexpr, but it doesn't really matter in constexpr
 			if (std::is_constant_evaluated()) {
 				if (items) {
@@ -103,10 +87,10 @@ template<typename T, typename Allocator>
 struct VectorAllocator<T, Allocator, 0> {
 	protected:
 		constexpr VectorAllocator() noexcept = default;
-		constexpr VectorAllocator(const VectorAllocator&) noexcept = default;
+		constexpr VectorAllocator(VectorAllocator const&) noexcept = default;
 		constexpr VectorAllocator(VectorAllocator&&) noexcept = default;
 
-		constexpr void allocate(T **items, std::size_t cap) noexcept {
+		constexpr void allocate(T **items, std::size_t const cap) noexcept {
 			*items = Allocator{}.allocate(cap);
 		}
 
@@ -114,15 +98,15 @@ struct VectorAllocator<T, Allocator, 0> {
 		constexpr void moveConstructItemsFrom(
 				T**,
 				VectorAllocator*,
-				const std::size_t,
+				std::size_t const,
-				const std::size_t) noexcept {
+				std::size_t const) noexcept {
 		}
 
 		[[maybe_unused]]
-		constexpr void moveItemsFrom(T**, VectorAllocator*, const std::size_t, const std::size_t) noexcept {
+		constexpr void moveItemsFrom(T**, VectorAllocator*, std::size_t const, std::size_t const) noexcept {
 		}
 
-		constexpr void deallocate(T *items, std::size_t cap) noexcept {
+		constexpr void deallocate(T *const items, std::size_t const cap) noexcept {
 			if (items) {
 				Allocator{}.deallocate(items, cap);
 			}
@@ -263,6 +247,8 @@ class Vector: detail::VectorAllocator<T, Allocator, SmallVectorSize> {
 
 		constexpr void resize(std::size_t size) noexcept(useNoexcept);
 
+		constexpr void reserveResize(std::size_t size) noexcept(useNoexcept);
+
 		[[nodiscard]]
 		constexpr T *data() noexcept {
 			return m_items;
@@ -287,7 +273,9 @@ class Vector: detail::VectorAllocator<T, Allocator, SmallVectorSize> {
 		template<typename... Args>
 		constexpr T &emplace_back(Args&&... args) noexcept(useNoexcept);
 
-		constexpr void push_back(T item) noexcept(useNoexcept);
+		constexpr void push_back(T const &item) noexcept(useNoexcept);
+
+		constexpr void push_back(T &&item) noexcept(useNoexcept);
 
 		constexpr void pop_back() noexcept(useNoexcept);
 
@@ -421,7 +409,7 @@ constexpr Vector<T, SmallVectorSize, Allocator> &Vector<T, SmallVectorSize, Allo
 		m_size = other.m_size;
 		m_cap = other.m_cap;
 		m_items = other.m_items;
-		this->moveItemsFrom(&m_items, &other, m_size, m_cap);
+		this->moveConstructItemsFrom(&m_items, &other, m_size, m_cap);
 		other.m_size = 0;
 		other.m_cap = 0;
 		other.m_items = nullptr;
@@ -431,13 +419,13 @@ constexpr Vector<T, SmallVectorSize, Allocator> &Vector<T, SmallVectorSize, Allo
 
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
 constexpr T &Vector<T, SmallVectorSize, Allocator>::operator[](std::size_t i) noexcept {
-	boundsCheck(__FILE__, __LINE__, i, size(), "Vector access overflow");
+	boundsCheck(i, size(), "Vector access overflow");
 	return m_items[i];
 }
 
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
 constexpr const T &Vector<T, SmallVectorSize, Allocator>::operator[](std::size_t i) const noexcept {
-	boundsCheck(__FILE__, __LINE__, i, size(), "Vector access overflow");
+	boundsCheck(i, size(), "Vector access overflow");
 	return m_items[i];
 }
 
@@ -531,6 +519,12 @@ constexpr void Vector<T, SmallVectorSize, Allocator>::resize(std::size_t size) n
 	m_size = size;
 }
 
+template<typename T, std::size_t SmallVectorSize, typename Allocator>
+constexpr void Vector<T, SmallVectorSize, Allocator>::reserveResize(std::size_t const size) noexcept(useNoexcept) {
+	reserve(size);
+	resize(size);
+}
+
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
 constexpr bool Vector<T, SmallVectorSize, Allocator>::contains(MaybeView_t<T> const &v) const noexcept {
 	for (std::size_t i = 0; i < m_size; ++i) {
@@ -617,7 +611,16 @@ constexpr T &Vector<T, SmallVectorSize, Allocator>::emplace_back(Args&&... args)
 }
 
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
-constexpr void Vector<T, SmallVectorSize, Allocator>::push_back(T item) noexcept(useNoexcept) {
+constexpr void Vector<T, SmallVectorSize, Allocator>::push_back(T const &item) noexcept(useNoexcept) {
+	if (m_size == m_cap) {
+		reserve(m_cap ? m_cap * 2 : initialCap);
+	}
+	std::construct_at(&m_items[m_size], item);
+	++m_size;
+}
+
+template<typename T, std::size_t SmallVectorSize, typename Allocator>
+constexpr void Vector<T, SmallVectorSize, Allocator>::push_back(T &&item) noexcept(useNoexcept) {
 	if (m_size == m_cap) {
 		reserve(m_cap ? m_cap * 2 : initialCap);
 	}

deps/teagba/include/teagba/addresses.hpp

@@ -99,23 +99,23 @@ volatile OffsetPair &regBgOfs(auto const bgIdx) noexcept {
 /////////////////////////////////////////////////////////////////
 // Memory Addresses
 
-#define MEM_EWRAM (*reinterpret_cast<ox::Array<uint16_t, 0x0203'FFFF - 0x0200'0000>*>(0x0200'0000))
+#define MEM_EWRAM (*(reinterpret_cast<ox::Array<uint16_t, 0x0203'FFFF - 0x0200'0000>*>(0x0200'0000)))
 
-#define MEM_IWRAM (*reinterpret_cast<ox::Array<uint8_t, 0x0300'7FFF - 0x0300'0000>*>(0x0300'0000))
+#define MEM_IWRAM (*(reinterpret_cast<ox::Array<uint8_t, 0x0300'7FFF - 0x0300'0000>*>(0x0300'0000)))
 
 #define REG_BLNDCTL (*reinterpret_cast<uint16_t*>(0x0400'0050))
 
 using Palette = ox::Array<uint16_t, 128>;
-#define MEM_BG_PALETTE (*reinterpret_cast<::Palette*>(0x0500'0000))
+#define MEM_BG_PALETTE (*(reinterpret_cast<::Palette*>(0x0500'0000)))
-#define MEM_SPRITE_PALETTE (*reinterpret_cast<::Palette*>(0x0500'0200))
+#define MEM_SPRITE_PALETTE (*(reinterpret_cast<::Palette*>(0x0500'0200)))
 
 using BgMapTile = ox::Array<uint16_t, 8192>;
-#define MEM_BG_TILES (*reinterpret_cast<ox::Array<BgMapTile, 4>*>(0x0600'0000))
+#define MEM_BG_TILES (*(reinterpret_cast<ox::Array<BgMapTile, 4>*>(0x0600'0000)))
-#define MEM_BG_MAP (*reinterpret_cast<ox::Array<BgMapTile, 4>*>(0x0600'e000))
+#define MEM_BG_MAP (*(reinterpret_cast<ox::Array<BgMapTile, 4>*>(0x0600'e000)))
 
-#define MEM_SPRITE_TILES (*reinterpret_cast<ox::Array<uint16_t, 32 * ox::units::KB>*>(0x0601'0000))
+#define MEM_SPRITE_TILES (*(reinterpret_cast<ox::Array<uint16_t, 32 * ox::units::KB>*>(0x0601'0000)))
-#define MEM_OAM (*reinterpret_cast<ox::Array<uint64_t, 64>*>(0x0700'0000))
+#define MEM_OAM (*(reinterpret_cast<ox::Array<uint64_t, 64>*>(0x0700'0000)))
 
-#define MEM_ROM (*reinterpret_cast<ox::Array<char, 32 * ox::units::MB>*>(0x0700'0000))
+#define MEM_ROM (*(reinterpret_cast<ox::Array<char, 32 * ox::units::MB>*>(0x0700'0000)))
 
-#define MEM_SRAM (*reinterpret_cast<ox::Array<char, 64 * ox::units::KB>*>(0x0e00'0000))
+#define MEM_SRAM (*(reinterpret_cast<ox::Array<char, 64 * ox::units::KB>*>(0x0e00'0000)))

deps/teagba/include/teagba/gfx.hpp

@@ -43,6 +43,4 @@ void applySpriteUpdates() noexcept;
 
 void setBgOffset(uint16_t bg, int16_t x, int16_t y) noexcept;
 
-void scrollBgOffset(uint16_t bg, int16_t x, int16_t y) noexcept;
-
 }

deps/teagba/src/gfx.cpp

@@ -18,7 +18,7 @@ GbaSpriteAttrUpdate &spriteAttr(size_t const i) noexcept {
 
 void addSpriteUpdate(GbaSpriteAttrUpdate const &upd) noexcept {
 	const auto ie = REG_IE; // disable vblank interrupt handler
-	REG_IE = REG_IE & static_cast<uint16_t>(~teagba::Int_vblank); // disable vblank interrupt handler
+	REG_IE = REG_IE & static_cast<uint16_t>(~Int_vblank); // disable vblank interrupt handler
 	g_spriteBuffer[upd.idx] = upd;
 	REG_IE = ie; // enable vblank interrupt handler
 }
@@ -35,10 +35,4 @@ void setBgOffset(uint16_t const bg, int16_t const x, int16_t const y) noexcept {
 	o.y = y;
 }
 
-void scrollBgOffset(uint16_t const bg, int16_t const x, int16_t const y) noexcept {
-	auto &o = regBgOfs(bg);
-	o.x = o.x + x;
-	o.y = o.y + y;
-}
-
 }

developer-handbook.md

@@ -27,9 +27,9 @@ All components have a platform indicator next to them:
       * opengl - OpenGL implementation (P-)
       * studio - studio plugin for core (P-)
       * keel - keel plugin for core (PG)
-    * scene - defines & processes map data (PG)
+    * sound - sound system for Nostalgia (PG)
-      * studio - studio plugin for scene (P-)
+      * studio - studio plugin for sound (P-)
-      * keel - keel plugin for scene (PG)
+      * keel - keel plugin for sound (PG)
   * player - plays the games (PG)
   * studio - makes the games (P-)
   * tools - command line tools (P-)
@@ -89,7 +89,8 @@ The GBA has two major resources for learning about its hardware:
 
 On the surface, it seems like C++ changes the way we do things from C for no
 reason, but there are reasons for many of these duplications of functionality.
-The C++ language designers aren't stupid. Question them, but don't ignore them.
+The C++ language designers aren't stupid.
+Question them, but don't ignore them.
 
 #### Casting
 
@@ -163,10 +164,11 @@ The Ox way of doing things is the Olympic way of doing things.
 ### Error Handling
 
 Instead of throwing exceptions, generally try to use
-[ox::Errors](deps/ox/ox-docs.md#error-handling) for error reporting,
+[ox::Error](deps/ox/ox-docs.md#error-handling) for error reporting.
-but exceptions may be used where they make sense.
+Exceptions may be used where errors-as-values will not work, but catch them and
+convert them to ```ox::Error``` as soon as possible.
 
-Exceptions should generally just use ```OxException```, which is bascially an
+Exceptions should generally just use ```ox::Exception```, which is basically an
 exception form of ```ox::Error```.
 
 ### File I/O

src/nostalgia/modules/gfx/src/gfx-gba.cpp

@@ -23,17 +23,15 @@ struct BgCbbData {
 	unsigned bpp = 4;
 };
 
-class Context {
+class Context final {
 
 	public:
 		turbine::Context &turbineCtx;
 		ox::Array<BgCbbData, 4> cbbData;
+		ox::Array<OffsetPair, 4> bgOffsets;
 
 		explicit Context(turbine::Context &tctx) noexcept: turbineCtx{tctx} {}
-		Context(Context &other) noexcept = delete;
 		Context(Context const &other) noexcept = delete;
-		Context(Context const &&other) noexcept = delete;
-		virtual ~Context() noexcept = default;
 
 };
 
@@ -295,12 +293,16 @@ void setBgPriority(Context&, uint_t const bgIdx, uint_t const priority) noexcept
 	bgCtl = (bgCtl & 0b1111'1111'1111'1100u) | (priority & 0b11);
 }
 
-void setBgOffset(Context&, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+void setBgOffset(Context &ctx, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+	ctx.bgOffsets[bg] = {.x = x, .y = y};
 	teagba::setBgOffset(bg, x, y);
 }
 
-void scrollBgOffset(Context&, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+void scrollBgOffset(Context &ctx, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
-	teagba::scrollBgOffset(bg, x, y);
+	auto &o = ctx.bgOffsets[bg];
+	o.x += x;
+	o.y += y;
+	teagba::setBgOffset(bg, o.x, o.y);
 }
 
 void hideSprite(Context&, unsigned const idx) noexcept {
@@ -319,23 +321,23 @@ void showSprite(Context&, unsigned const idx) noexcept {
 	});
 }
 
-void setSprite(Context&, uint_t const idx, Sprite const &s) noexcept {
+void setSprite(Context&, uint_t const idx, Sprite const &sprite) noexcept {
 	//oxAssert(g_spriteUpdates < config::GbaSpriteBufferLen, "Sprite update buffer overflow");
-	uint16_t const eightBpp = s.bpp == 8;
+	uint16_t const eightBpp = sprite.bpp == 8;
 	teagba::addSpriteUpdate({
 		.attr0 = static_cast<uint16_t>(
-			  (static_cast<uint16_t>(s.y & ox::onMask<uint8_t>(0b111'1111)))
+			  (static_cast<uint16_t>(sprite.y & ox::onMask<uint8_t>(0b111'1111)))
 			| (static_cast<uint16_t>(1) << 10) // enable alpha
 			| (static_cast<uint16_t>(eightBpp) << 13)
-			| (static_cast<uint16_t>(s.spriteShape) << 14)),
+			| (static_cast<uint16_t>(sprite.spriteShape) << 14)),
 		.attr1 = static_cast<uint16_t>(
-			  (static_cast<uint16_t>(s.x) & ox::onMask<uint8_t>(8))
+			  (static_cast<uint16_t>(sprite.x) & ox::onMask<uint8_t>(8))
-			| (static_cast<uint16_t>(s.flipX) << 12)
+			| (static_cast<uint16_t>(sprite.flipX) << 12)
-			| (static_cast<uint16_t>(s.spriteSize) << 14)),
+			| (static_cast<uint16_t>(sprite.spriteSize) << 14)),
 		.attr2 = static_cast<uint16_t>(
 			// double tileIdx if 8 bpp
-			  (static_cast<uint16_t>((s.tileIdx * (1 + eightBpp)) & ox::onMask<uint16_t>(8)))
+			  (static_cast<uint16_t>((sprite.tileIdx * (1 + eightBpp)) & ox::onMask<uint16_t>(8)))
-			| (static_cast<uint16_t>(s.priority & 0b11) << 10)),
+			| (static_cast<uint16_t>(sprite.priority & 0b11) << 10)),
 		.idx = static_cast<uint16_t>(idx),
 	});
 }
@@ -348,7 +350,7 @@ uint_t spriteCount(Context const &) noexcept {
 
 namespace ox {
 
-void panic(char const *file, int line, char const *panicMsg, ox::Error const &err) noexcept {
+void panic(char const*panicMsg, Error const&err, std::source_location const &src) noexcept {
 	using namespace nostalgia::gfx;
 	// reset heap to make sure we have enough memory to allocate context data
 	OX_ALLOW_UNSAFE_BUFFERS_BEGIN
@@ -372,7 +374,7 @@ void panic(char const *file, int line, char const *panicMsg, ox::Error const &er
 	}
 	consoleWrite(*ctx, 32 + 1, 15, "PLEASE RESTART THE SYSTEM");
 	// print to terminal if in mGBA
-	oxErrf("\033[31;1;1mPANIC:\033[0m [{}:{}]: {}\n", file, line, panicMsg);
+	oxErrf("\033[31;1;1mPANIC:\033[0m [{}:{}]: {}\n", src.file_name(), src.line(), panicMsg);
 	if (err.msg) {
 		oxErrf("\tError Message:\t{}\n", err.msg);
 	}

src/nostalgia/modules/gfx/src/gfx-opengl.cpp

@@ -87,9 +87,7 @@ class Context {
 			blocksPerSprite{params.glBlocksPerSprite} {
 		}
 		Context(Context const&) = delete;
-		Context(Context&&) = delete;
 		Context &operator=(Context const&) = delete;
-		Context &operator=(Context&&) = delete;
 		~Context() noexcept {
 			turbine::gl::removeDrawer(turbineCtx, &drawer);
 		}
@@ -113,7 +111,7 @@ namespace renderer {
 static constexpr auto Scale = 1;
 static constexpr auto PriorityScale = 0.01f;
 
-static constexpr ox::CStringView bgvshadTmpl = R"glsl(
+static constexpr ox::StringLiteral bgvshadTmpl{R"glsl(
 	{}
 	in vec2 vTexCoord;
 	in vec3 vPosition;
@@ -135,9 +133,9 @@ static constexpr ox::CStringView bgvshadTmpl = R"glsl(
 			vTexCoord.x,
 			vTexCoord.y * vTileHeight + vTileIdx * vTileHeight);
 		fPalOffset = vPalOffset;
-	})glsl";
+	})glsl"};
 
-static constexpr ox::CStringView bgfshadTmpl = R"glsl(
+static constexpr ox::StringLiteral bgfshadTmpl{R"glsl(
 	{}
 	out vec4 outColor;
 	in float fPalOffset;
@@ -151,9 +149,9 @@ static constexpr ox::CStringView bgfshadTmpl = R"glsl(
 		if (outColor.a == 0) {
 			discard;
 		}
-	})glsl";
+	})glsl"};
 
-static constexpr ox::CStringView spritevshadTmpl = R"glsl(
+static constexpr ox::StringLiteral spritevshadTmpl{R"glsl(
 	{}
 	in float vEnabled;
 	in vec3 vPosition;
@@ -170,9 +168,9 @@ static constexpr ox::CStringView spritevshadTmpl = R"glsl(
 				vPosition.z - 0.004,
 				1.0) * vEnabled;
 		fTexCoord = vTexCoord * vec2(1, vTileHeight);
-	})glsl";
+	})glsl"};
 
-static constexpr ox::CStringView spritefshadTmpl = R"glsl(
+static constexpr ox::StringLiteral spritefshadTmpl{R"glsl(
 	{}
 	out vec4 outColor;
 	in vec2 fTexCoord;
@@ -185,7 +183,7 @@ static constexpr ox::CStringView spritefshadTmpl = R"glsl(
 		if (outColor.a == 0) {
 			discard;
 		}
-	})glsl";
+	})glsl"};
 
 [[nodiscard]]
 static constexpr auto bgVertexRow(uint_t const x, uint_t const y) noexcept {
@@ -841,6 +839,12 @@ void setBgPriority(Context &ctx, uint_t const bgIdx, uint_t const priority) noex
 	bg.priority = static_cast<float>(priority & 0b11);
 }
 
+void setBgOffset(Context&, uint16_t const, int16_t const, int16_t const) noexcept {
+}
+
+void scrollBgOffset(Context&, uint16_t const, int16_t const, int16_t const) noexcept {
+}
+
 void hideSprite(Context &ctx, uint_t const idx) noexcept {
 	auto &s = ctx.spriteStates[idx];
 	s.enabled = false;

src/nostalgia/modules/gfx/src/studio/subcommands/export-tilesheet/export-tilesheet.hpp

@@ -5,6 +5,13 @@
 #pragma once
 
 #include <ox/std/error.hpp>
+#include <ox/std/span.hpp>
+#include <ox/std/stringview.hpp>
+
+#include <studio/project.hpp>
+
+#include <nostalgia/gfx/palette.hpp>
+#include <nostalgia/gfx/tilesheet.hpp>
 
 namespace nostalgia::gfx {
 

src/nostalgia/modules/gfx/src/studio/tilesheeteditor/tilesheeteditor-imgui.cpp

@@ -3,7 +3,6 @@
  */
 
 #include <imgui.h>
-#include <lodepng.h>
 
 #include <ox/std/point.hpp>
 #include <keel/media.hpp>

src/nostalgia/modules/gfx/src/studio/tilesheeteditor/tilesheeteditor-imgui.hpp

@@ -57,7 +57,6 @@ class TileSheetEditorImGui: public studio::Editor {
 		ox::Vec2 m_prevMouseDownPos;
 		TileSheetTool m_tool = TileSheetTool::Draw;
 		bool m_palPathFocused{};
-		ox::Vector<ox::UPtr<studio::UndoCommand>, 1> m_deferredCmds;
 
 	public:
 		TileSheetEditorImGui(studio::Context &sctx, ox::StringParam path);

src/nostalgia/modules/gfx/src/studio/tilesheeteditor/tilesheetpixelgrid.cpp

@@ -69,7 +69,7 @@ void TileSheetGrid::update(ox::Vec2 const &paneSize, TileSheet::SubSheet const &
 	glBindVertexArray(m_bufferSet.vao);
 	setBufferObjects(paneSize, subsheet);
 	glutils::sendVbo(m_bufferSet);
-	glutils::sendEbo(m_bufferSet);
+	//glutils::sendEbo(m_bufferSet);
 }
 
 void TileSheetGrid::setBufferObject(
@@ -89,7 +89,6 @@ void TileSheetGrid::setBufferObject(
 
 void TileSheetGrid::setBufferObjects(ox::Vec2 const &paneSize, TileSheet::SubSheet const &subsheet) noexcept {
 	if (subsheet.columns < 1 || subsheet.rows < 1) {
-		m_bufferSet.elements.clear();
 		m_bufferSet.vertices.clear();
 		return;
 	}

src/nostalgia/modules/gfx/test/CMakeLists.txt

@@ -8,4 +8,4 @@ target_link_libraries(
 		NostalgiaGfx
 )
 
-add_test("[NostalgiaGfx] readWriteTileSheet" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/NostalgiaGfxTest readWriteTileSheet)
+add_test("[nostalgia/gfx] readWriteTileSheet" ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/NostalgiaGfxTest readWriteTileSheet)

src/nostalgia/modules/gfx/test/tests.cpp

@@ -18,7 +18,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			gfx::TileSheet const in;
 			OX_REQUIRE(buff, ox::writeMC(in));
 			OX_REQUIRE(out, ox::readMC<gfx::TileSheet>(buff));
-			oxAssert(in.subsheet.name == out.subsheet.name, "subsheet.name serialization broken");
+			ox::expect(in.subsheet.name, out.subsheet.name);
 			return {};
 		}
 	},

src/nostalgia/studio/CMakeLists.txt

@@ -15,7 +15,7 @@ target_link_libraries(
 
 target_compile_definitions(
 	NostalgiaStudio PUBLIC
-		OLYMPIC_APP_VERSION="d2025.07.0"
+		OLYMPIC_APP_VERSION="dev build"
 )
 
 install(

src/nostalgia/studio/Info.plist

@@ -18,7 +18,7 @@
 	<string>APPL</string>
 
 	<key>CFBundleVersion</key>
-	<string>d2025.07.0</string>
+	<string>dev build</string>
 
 	<key>LSMinimumSystemVersion</key>
 	<string>12.0.0</string>

src/olympic/keel/include/keel/asset.hpp

@@ -13,7 +13,7 @@ namespace keel {
 
 constexpr auto K1HdrSz = 40;
 
-ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept;
+ox::Result<ox::UUID> readUuidHeader(ox::BufferView const &buff) noexcept;
 
 ox::Result<ox::UUID> regenerateUuidHeader(ox::Buffer &buff) noexcept;
 
@@ -35,15 +35,15 @@ ox::Result<T> readAsset(ox::BufferView buff) noexcept {
 	return out;
 }
 
-ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView buff) noexcept;
+ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView const &buff) noexcept;
 
 struct AssetHdr {
 	ox::UUID uuid;
 	ox::ClawHeader clawHdr;
 };
 
-ox::Result<ox::StringView> readAssetTypeId(ox::BufferView buff) noexcept;
+ox::Result<ox::StringView> readAssetTypeId(ox::BufferView const &buff) noexcept;
 
-ox::Result<AssetHdr> readAssetHeader(ox::BufferView buff) noexcept;
+ox::Result<AssetHdr> readAssetHeader(ox::BufferView const &buff) noexcept;
 
 }

src/olympic/keel/include/keel/media.hpp

@@ -147,7 +147,7 @@ template<typename T>
 ox::Result<AssetRef<T>> readObj(
 		Context &ctx,
 		ox::StringViewCR assetId,
-		[[maybe_unused]] bool forceLoad = false) noexcept {
+		[[maybe_unused]] bool const forceLoad = false) noexcept {
 #ifndef OX_BARE_METAL
 	return readObjFile<T>(ctx, assetId, forceLoad);
 #else
@@ -159,7 +159,7 @@ template<typename T>
 ox::Result<AssetRef<T>> readObj(
 		Context &ctx,
 		ox::FileAddress const &file,
-		[[maybe_unused]] bool forceLoad = false) noexcept {
+		[[maybe_unused]] bool const forceLoad = false) noexcept {
 #ifndef OX_BARE_METAL
 	OX_REQUIRE(assetId, file.getPath());
 	return readObj<T>(ctx, ox::StringView(assetId), forceLoad);
@@ -178,7 +178,7 @@ ox::Error writeObj(
 		Context &ctx,
 		ox::FileAddress const &file,
 		T const &obj,
-		ox::ClawFormat fmt = ox::ClawFormat::Metal) noexcept {
+		ox::ClawFormat const fmt = ox::ClawFormat::Metal) noexcept {
 	OX_REQUIRE(objBuff, ox::writeClaw(obj, fmt));
 	return ctx.rom->write(file, objBuff.data(), objBuff.size());
 }

src/olympic/keel/include/keel/typeconv.hpp

@@ -214,7 +214,7 @@ class Converter {
 		}
 		[[nodiscard]]
 		BaseConverter const &converter() const noexcept {
-			return *m_buff.data();
+			return *std::launder(m_buff.data());
 		}
 };
 

src/olympic/keel/include/keel/typestore.hpp

@@ -16,7 +16,7 @@ class TypeStore: public ox::TypeStore {
 		ox::String m_descPath;
 
 	public:
-		explicit TypeStore(ox::FileSystem &fs, ox::StringView descPath) noexcept;
+		explicit TypeStore(ox::FileSystem &fs, ox::StringViewCR descPath) noexcept;
 
 	protected:
 		ox::Result<ox::UPtr<ox::DescriptorType>> loadDescriptor(ox::StringView typeId) noexcept override;

src/olympic/keel/src/asset.cpp

@@ -6,7 +6,7 @@
 
 namespace keel {
 
-ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept {
+ox::Result<ox::UUID> readUuidHeader(ox::BufferView const &buff) noexcept {
 	if (buff.size() < K1HdrSz) [[unlikely]] {
 		return ox::Error{1, "Insufficient data to contain complete Keel header"};
 	}
@@ -27,16 +27,15 @@ ox::Result<ox::UUID> regenerateUuidHeader(ox::Buffer &buff) noexcept {
 	return id;
 }
 
-ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView buff) noexcept {
+ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView const &buff) noexcept {
 	std::size_t offset = 0;
 	if (!readUuidHeader(buff).error) {
 		offset = K1HdrSz;
 	}
-	buff += offset;
+	return ox::readClaw(ts, buff + offset);
-	return ox::readClaw(ts, buff);
 }
 
-ox::Result<ox::StringView> readAssetTypeId(ox::BufferView const buff) noexcept {
+ox::Result<ox::StringView> readAssetTypeId(ox::BufferView const &buff) noexcept {
 	auto const err = readUuidHeader(buff).error;
 	auto const offset = err ? 0u : K1HdrSz;
 	if (offset >= buff.size()) [[unlikely]] {
@@ -45,15 +44,14 @@ ox::Result<ox::StringView> readAssetTypeId(ox::BufferView const buff) noexcept {
 	return ox::readClawTypeId(buff + offset);
 }
 
-ox::Result<AssetHdr> readAssetHeader(ox::BufferView buff) noexcept {
+ox::Result<AssetHdr> readAssetHeader(ox::BufferView const &buff) noexcept {
 	ox::Result<AssetHdr> out;
 	auto const err = readUuidHeader(buff).moveTo(out.value.uuid);
 	auto const offset = err ? 0u : K1HdrSz;
 	if (offset >= buff.size()) [[unlikely]] {
 		return ox::Error(1, "Buffer too small for expected data");
 	}
-	buff += offset;
+	OX_RETURN_ERROR(ox::readClawHeader(buff + offset).moveTo(out.value.clawHdr));
-	OX_RETURN_ERROR(ox::readClawHeader(buff).moveTo(out.value.clawHdr));
 	return out;
 }
 

src/olympic/keel/src/pack.cpp

@@ -187,7 +187,7 @@ static ox::Error copy(
 			OX_DEFER [&status] {
 				oxOutf(" {}\n", status);
 			};
-			OX_REQUIRE_M(buff, src.read(currentFile));
+			OX_REQUIRE(buff, src.read(currentFile));
 			// write file to dest
 			OX_RETURN_ERROR(dest.write(currentFile, buff));
 			status = "OK";

src/olympic/keel/src/typestore.cpp

@@ -6,7 +6,7 @@
 
 namespace keel {
 
-TypeStore::TypeStore(ox::FileSystem &fs, ox::StringView descPath) noexcept:
+TypeStore::TypeStore(ox::FileSystem &fs, ox::StringViewCR descPath) noexcept:
 	m_fs(fs),
 	m_descPath(descPath) {
 }

src/olympic/keel/test/tests.cpp

@@ -19,13 +19,13 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			ox::Array<char, hdr.size()> buff;
 			ox::CharBuffWriter bw(buff);
 			OX_RETURN_ERROR(keel::writeUuidHeader(bw, uuid));
-			oxExpect(ox::StringView(buff.data(), buff.size()), hdr);
+			ox::expect(ox::StringView(buff.data(), buff.size()), hdr);
 			return {};
 		}
 	},
 };
 
-int main(int argc, char const **argv) {
+int main(int const argc, char const **argv) {
 	int retval = -1;
 	if (argc > 0) {
 		auto const args = ox::Span{argv, static_cast<size_t>(argc)};

src/olympic/studio/modlib/include/studio/imguiutil.hpp

@@ -31,7 +31,7 @@ ox::Result<T> getDragDropPayload(ox::CStringViewCR name) noexcept {
 		return ox::Error(1, "No drag/drop payload");
 	}
 	return ox::readClaw<T>({
-			reinterpret_cast<char const*>(payload->Data),
+			std::launder(reinterpret_cast<char const*>(payload->Data)),
 			static_cast<size_t>(payload->DataSize)});
 }
 

src/olympic/studio/modlib/src/context.cpp

@@ -8,13 +8,18 @@ namespace studio {
 
 void navigateTo(Context &ctx, ox::StringParam filePath, ox::StringParam navArgs) noexcept {
 	ox::String path = std::move(filePath);
-	if (beginsWith(path, "uuid://")) {
+	if (keel::isUuidUrl(path)) {
 		auto const [p, err] = keel::uuidUrlToPath(keelCtx(ctx), path);
 		if (err) {
 			return;
 		}
 		path = p;
 	}
+	//if (
+	//	auto const [np, err] = ctx.navStack.back();
+	//	!err && np->filePath == path && np->navArgs == navArgs.view()) {
+	//	return;
+	//}
 	ctx.navStack.resize(ctx.navIdx + 1);
 	ctx.navStack.emplace_back(ox::String{path}, ox::String{navArgs.view()});
 	try {
@@ -49,8 +54,9 @@ void navigateBack(Context &ctx) noexcept {
 }
 
 void navigateForward(Context &ctx) noexcept {
-	while (ctx.navIdx < ctx.navStack.size()) {
+	auto const nextIdx = ctx.navIdx + 1;
-		auto const &n = ctx.navStack[ctx.navIdx];
+	while (nextIdx < ctx.navStack.size()) {
+		auto const &n = ctx.navStack[nextIdx];
 		try {
 			ctx.navCallback(n.filePath, n.navArgs);
 		} catch (std::exception const &e) {
@@ -58,7 +64,7 @@ void navigateForward(Context &ctx) noexcept {
 			oxErrf("navigateForward failed: {}", e.what());
 		}
 		if (!ctx.project->exists(n.filePath)) {
-			std::ignore = ctx.navStack.erase(ctx.navIdx);
+			std::ignore = ctx.navStack.erase(nextIdx);
 			continue;
 		}
 		++ctx.navIdx;

src/olympic/turbine/src/glfw/turbine.cpp

@@ -285,11 +285,11 @@ static void handleKeyPress(Context &ctx, int const key, bool const down) noexcep
 		map[GLFW_KEY_ESCAPE]        = Key::Escape;
 		return map;
 	}();
-	auto const eventHandler = keyEventHandler(ctx);
 	auto const keyIdx = static_cast<std::size_t>(key);
 	if (keyIdx < keyMap.size()) {
 		auto const k = keyMap[keyIdx];
 		setKeyDownStatus(ctx, k, down);
+		auto const eventHandler = keyEventHandler(ctx);
 		if (eventHandler) {
 			eventHandler(ctx, k, down);
 		}
@@ -306,8 +306,10 @@ static void handleGlfwMouseButtonEvent(
 	int) noexcept {
 	auto &ctx = *static_cast<Context*>(glfwGetWindowUserPointer(window));
 	setMandatoryRefreshPeriod(ctx, ticksMs(ctx) + config::MandatoryRefreshPeriod);
+	if (ctx.mouseButtonEventHandler) {
 		ctx.mouseButtonEventHandler(ctx, btn, action == 1);
 	}
+}
 
 static void handleGlfwKeyEvent(GLFWwindow *window, int const key, int, int const action, int) noexcept {
 	auto &ctx = *static_cast<Context*>(glfwGetWindowUserPointer(window));