[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
-file and line of the error.
-The ```OxError(x)``` macro should only be used for the initial instantiation of
-an ```ox::Error```.
+```ox::Error```s will also include the file and line of the 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());
-				oxExpect(testIn.IString,               testOut.IString);
+				ox::expect(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);
 		}
@@ -187,7 +187,7 @@ class ModelValue {
 		constexpr Type type() const noexcept;
 
 		constexpr Error setType(
-				DescriptorType const*type,
+				DescriptorType const *type,
 				SubscriptStack const& = {},
 				int subscriptLevels = 0) noexcept;
 
@@ -275,7 +275,7 @@ class ModelValueArray {
 		}
 
 		constexpr Error setType(
-				DescriptorType const*type,
+				DescriptorType const *type,
 				SubscriptStack subscriptStack,
 				int subscriptLevels) noexcept {
 			oxAssert(subscriptLevels <= static_cast<int>(subscriptStack.size()), "subscript level mismatch");
@@ -418,7 +418,7 @@ class ModelValueVector {
 		}
 
 		constexpr Error setType(
-				DescriptorType const*type,
+				DescriptorType const *type,
 				SubscriptStack subscriptStack,
 				int subscriptLevels) noexcept {
 			oxAssert(subscriptLevels <= static_cast<int>(subscriptStack.size()), "subscript level mismatch");
@@ -821,7 +821,7 @@ class ModelUnion {
 
 template<typename PlatSpec>
 [[nodiscard]]
-constexpr std::size_t sizeOf(ModelValueArray const*v) noexcept {
+constexpr std::size_t sizeOf(ModelValueArray const *v) noexcept {
 	return sizeOf<PlatSpec>(&(*v)[0]) * v->size();
 }
 
@@ -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 StringView BString     = "net.drinkingtea.ox.BString";
-constexpr StringView String      = "B.string";
-constexpr StringView Bool        = "B.bool";
-constexpr StringView Uint8       = "B.uint8";
-constexpr StringView Uint16      = "B.uint16";
-constexpr StringView Uint32      = "B.uint32";
-constexpr StringView Uint64      = "B.uint64";
-constexpr StringView Int8        = "B.int8";
-constexpr StringView Int16       = "B.int16";
-constexpr StringView Int32       = "B.int32";
-constexpr StringView Int64       = "B.int64";
+constexpr StringLiteral BasicString = "net.drinkingtea.ox.BasicString";
+constexpr StringLiteral IString     = "net.drinkingtea.ox.IString";
+constexpr StringLiteral String      = "B.string";
+constexpr StringLiteral Bool        = "B.bool";
+constexpr StringLiteral Uint8       = "B.uint8";
+constexpr StringLiteral Uint16      = "B.uint16";
+constexpr StringLiteral Uint32      = "B.uint32";
+constexpr StringLiteral Uint64      = "B.uint64";
+constexpr StringLiteral Int8        = "B.int8";
+constexpr StringLiteral Int16       = "B.int16";
+constexpr StringLiteral Int32       = "B.int32";
+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 {
-	oxErrf("\033[31;1;1mPANIC:\033[0m [{}:{}]: {}\n", file, line, panicMsg);
+void panic(Error const &err, StringViewCR panicMsg, std::source_location const &src) noexcept {
+	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 {
-	panic(StringView{file}, line, StringView{panicMsg}, err);
+void panic(Error const &err, char const*panicMsg, std::source_location const &src) noexcept {
+	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);
-	oxTracef("assert", "Failed assert: {} ({}) [{}:{}]", msg, assertTxt, file, line);
-	constexprPanic(file, line, msg);
+	oxErrf(
+		"\n\033[31;1;1mASSERT FAILURE:\033[0m [{}:{}]: {}\n",
+		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,
+	[[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,
+	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,
+	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 &actual,
+	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("expected: {}\nactual:   {}\n", detail::toStringView<true>(expected), detail::toStringView<true>(actual));
+			oxErrf(
+				"\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

@@ -17,7 +17,7 @@ class exception {
 		virtual ~exception() = default;
 
 		[[nodiscard]]
-		virtual char const*what() const noexcept {
+		virtual char const *what() const noexcept {
 			return "";
 		}
 };
@@ -44,7 +44,7 @@ struct [[nodiscard]] Error {
 
 	explicit constexpr Error(
 		ErrorCode const errCode,
-		std::source_location const&src = std::source_location::current()) noexcept:
+		std::source_location const &src = std::source_location::current()) noexcept:
 		src{src},
 		errCode{errCode}
 	{}
@@ -52,7 +52,7 @@ struct [[nodiscard]] Error {
 	explicit constexpr Error(
 		ErrorCode const errCode,
 		ox::CString msg,
-		std::source_location const&src = std::source_location::current()) noexcept:
+		std::source_location const &src = std::source_location::current()) noexcept:
 		src{src},
 		msg{msg},
 		errCode{errCode}
@@ -65,13 +65,13 @@ struct [[nodiscard]] Error {
 };
 
 [[nodiscard]]
-constexpr auto errCode(Error const&err) noexcept {
+constexpr auto errCode(Error const &err) noexcept {
 	return err.errCode;
 }
 
 template<typename T = char const*>
 [[nodiscard]]
-constexpr auto toStr(Error const&err) noexcept {
+constexpr auto toStr(Error const &err) noexcept {
 	return err.msg ? T{err.msg} : "";
 }
 
@@ -82,19 +82,19 @@ struct Exception: public std::exception {
 
 	explicit Exception(
 		ErrorCode const errCode,
-		std::source_location const&src = std::source_location::current()) noexcept:
+		std::source_location const &src = std::source_location::current()) noexcept:
 		src{src},
 		errCode{errCode} {}
 
 	explicit Exception(
 		ErrorCode const errCode,
 		ox::CString msg,
-		std::source_location const&src = std::source_location::current()) noexcept:
+		std::source_location const &src = std::source_location::current()) noexcept:
 		src{src},
 		msg{msg},
 		errCode{errCode} {}
 
-	explicit Exception(Error const&err) noexcept:
+	explicit Exception(Error const &err) noexcept:
 		src{err.src},
 		msg{err.msg ? err.msg : ""},
 		errCode{err.errCode} {}
@@ -104,13 +104,16 @@ struct Exception: public std::exception {
 	}
 
 	[[nodiscard]]
-	char const*what() const noexcept override {
+	char const *what() const noexcept override {
 		return msg;
 	}
 };
 
 [[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 {
@@ -124,25 +127,25 @@ struct [[nodiscard]] Result {
 	}
 
 	template<typename U>
-	constexpr Result(Result<U> const&other) noexcept: value(other.value), error(other.error) {
+	constexpr Result(Result<U> const &other) noexcept: value(other.value), error(other.error) {
 	}
 
 	template<typename U>
 	constexpr Result(Result<U> &&other) noexcept: value(std::move(other.value)), error(std::move(other.error)) {
 	}
 
-	constexpr Result(Error const&error) noexcept: value(), error(error) {
+	constexpr Result(Error const &error) noexcept: value(), error(error) {
 	}
 
-	constexpr Result(type const&value, Error const&error = {}) noexcept: value(value), error(error) {
+	constexpr Result(type const &value, Error const &error = {}) noexcept: value(value), error(error) {
 	}
 
-	constexpr Result(type &&value, Error const&error = {}) noexcept: value(std::move(value)), error(error) {
+	constexpr Result(type &&value, Error const &error = {}) noexcept: value(std::move(value)), error(error) {
 	}
 
 	constexpr ~Result() noexcept = default;
 
-	explicit constexpr operator type const&() const noexcept {
+	explicit constexpr operator type const &() const noexcept {
 		return value;
 	}
 
@@ -156,7 +159,7 @@ struct [[nodiscard]] Result {
 	}
 
 	template<typename U>
-	constexpr Error copyTo(U &val) const& noexcept {
+	constexpr Error copyTo(U &val) const & noexcept {
 		if (!error) [[likely]] {
 			val = value;
 		}
@@ -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,15 +193,15 @@ struct [[nodiscard]] Result {
 	[[nodiscard]]
 	constexpr T &&unwrap() && noexcept {
 		if (error) {
-			oxPanic(error, "Failed unwrap");
+			ox::panic(error, "Failed unwrap");
 		}
 		return std::move(value);
 	}
 
 	[[nodiscard]]
-	constexpr T const&unwrap() const & noexcept {
+	constexpr T const &unwrap() const & noexcept {
 		if (error) [[unlikely]] {
-			oxPanic(error, "Failed unwrap");
+			ox::panic(error, "Failed unwrap");
 		}
 		return value;
 	}
@@ -220,7 +223,7 @@ struct [[nodiscard]] Result {
 	}
 
 	[[nodiscard]]
-	constexpr T const&unwrapThrow() const & {
+	constexpr T const &unwrapThrow() const & {
 		if (error) {
 			throw ox::Exception(error);
 		}
@@ -244,7 +247,7 @@ struct [[nodiscard]] Result {
 	}
 
 	template<typename U = T>
-	constexpr ox::Result<U> to(auto const&f) & noexcept {
+	constexpr ox::Result<U> to(auto const &f) & noexcept {
 		if (error) [[unlikely]] {
 			return error;
 		}
@@ -252,7 +255,7 @@ struct [[nodiscard]] Result {
 	}
 
 	template<typename U = T>
-	constexpr ox::Result<U> to(auto const&f) && noexcept {
+	constexpr ox::Result<U> to(auto const &f) && noexcept {
 		if (error) [[unlikely]] {
 			return error;
 		}
@@ -264,7 +267,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T or_value(T &&alt) const& noexcept {
+	constexpr T or_value(T &&alt) const & noexcept {
 		if (error) {
 			return std::move(alt);
 		}
@@ -288,7 +291,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T or_value(T const&alt) const& noexcept {
+	constexpr T or_value(T const &alt) const & noexcept {
 		if (error) {
 			return alt;
 		}
@@ -300,7 +303,7 @@ struct [[nodiscard]] Result {
 	 * @param alt
 	 * @return value of Result or alt
 	 */
-	constexpr T or_value(T const&alt) && noexcept {
+	constexpr T or_value(T const &alt) && noexcept {
 		if (error) {
 			return alt;
 		}
@@ -318,34 +321,36 @@ struct [[nodiscard]] Result {
 
 namespace detail {
 
-constexpr Error toError(Error const&e) noexcept {
+constexpr Error toError(Error const &e) noexcept {
 	return e;
 }
 
 template<typename T>
-constexpr Error toError(Result<T> const&r) noexcept {
+constexpr Error toError(Result<T> const &r) noexcept {
 	return r.error;
 }
 
 }
 
-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,22 +30,60 @@ 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 {
 #ifdef __cpp_exceptions
 	try {
 		return new T(ox::forward<Args>(args)...);
-	} catch (std::exception const&ex) {
-		oxPanic(ox::Error(1, ex.what()), ex.what());
+	} catch (std::exception const &ex) {
+		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

@@ -47,7 +47,7 @@ class Span {
 		}
 
 		template<std::size_t sz>
-		constexpr Span(std::array<ox::remove_const_t<T>, sz> const&a) noexcept:
+		constexpr Span(std::array<ox::remove_const_t<T>, sz> const &a) noexcept:
 			m_items(a.data()),
 			m_size(a.size()) {
 		}
@@ -60,7 +60,7 @@ class Span {
 		}
 
 		template<std::size_t sz>
-		constexpr Span(ox::Array<ox::remove_const_t<T>, sz> const&a) noexcept:
+		constexpr Span(ox::Array<ox::remove_const_t<T>, sz> const &a) noexcept:
 			m_items(a.data()),
 			m_size(a.size()) {
 		}
@@ -72,7 +72,7 @@ class Span {
 		}
 
 		template<std::size_t sz, typename Allocator>
-		constexpr Span(ox::Vector<ox::remove_const_t<T>, sz, Allocator> const&v) noexcept:
+		constexpr Span(ox::Vector<ox::remove_const_t<T>, sz, Allocator> const &v) noexcept:
 			m_items(v.data()),
 			m_size(v.size()) {
 		}
@@ -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,35 +17,41 @@
 namespace ox {
 
 template<Integer_c Integer>
-constexpr ox::Error writeItoa(Integer v, ox::Writer_c auto &writer) noexcept {
-		if (v) {
-			ox::ResizedInt_t<Integer, 64> mod = 1000000000000000000;
-			ox::ResizedInt_t<Integer, 64> val = v;
-			constexpr auto base = 10;
-			auto it = 0;
-			if (val < 0) {
-				OX_RETURN_ERROR(writer.put('-'));
+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;
+		constexpr auto base = 10;
+		auto it = 0;
+		if (val < 0) {
+			OX_RETURN_ERROR(writer.put('-'));
+			val = ~val + 1;
+		}
+		if constexpr(sizeof(v) == 8 && !ox::is_signed_v<Integer>) {
+			auto digit = val / mod;
+			val %= mod;
+			mod /= base;
+			if (digit) {
+				digit -= 10;
+				OX_RETURN_ERROR(writer.put('1'));
+				OX_RETURN_ERROR(writer.put(static_cast<char>('0' + digit)));
 				++it;
 			}
-			while (mod) {
-				auto digit = val / mod;
-				val %= mod;
-				mod /= base;
-				if (it || digit) {
-					ox::ResizedInt_t<Integer, 64> start = '0';
-					if (digit >= 10) {
-						start = 'a';
-						digit -= 10;
-					}
-					OX_RETURN_ERROR(writer.put(static_cast<char>(start + digit)));
-					++it;
-				}
-			}
-		} else {
-			// 0 is a special case
-			OX_RETURN_ERROR(writer.put('0'));
 		}
-		return {};
+		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;
+			}
+		}
+	} else {
+		// 0 is a special case
+		OX_RETURN_ERROR(writer.put('0'));
+	}
+	return {};
 }
 
 }

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
@@ -43,15 +43,16 @@ uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	// start
 	auto const startTime = steadyNowMs();
 	for (int i = 0; i < lookups; ++i) {
-		auto const&k = keys[rand.gen() % keys.size()];
+		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
@@ -64,13 +65,13 @@ uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	// start
 	auto const startTime = steadyNowMs();
 	for (int i = 0; i < lookups; ++i) {
-		auto const&k = keys[rand.gen() % keys.size()];
-		oxExpect(map[k], k.toString());
+		auto const &k = keys[rand.gen() % keys.size()];
+		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");
-				oxExpect(v[1], "aoeu");
-				oxExpect(v.capacity(), 2u);
+				ox::expect(v[0], "asdf");
+				ox::expect(v[1], "aoeu");
+				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");
-				oxExpect(v[1], "aoeu");
-				oxExpect(v.capacity(), 2u);
+				ox::expect(v[0], "asdf");
+				ox::expect(v[1], "aoeu");
+				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);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u);
-			oxExpect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u);
-			oxExpect(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(), "zero").or_value(5), 0u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "one").or_value(5), 1u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "two").or_value(5), 2u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "three").or_value(5), 3u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "four").or_value(5), 4u);
+			ox::expect(ox::findIdx(v.begin(), v.end(), "five").or_value(5), 5u);
+			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");
-			oxExpect(map.size(), 1u);
-			oxExpect(map["aoeu"], "");
-			oxExpect(map.size(), 2u);
+			ox::expect(map["asdf"], "aoeu");
+			ox::expect(map.size(), 1u);
+			ox::expect(map["aoeu"], "");
+			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) {
+			auto constexpr constTest = [](ox::SmallMap<ox::String, ox::String> const &map) {
 				OX_REQUIRE(asdf, map.at("asdf"));
-				oxExpect(*asdf, "aoeu");
-				oxExpect(map.size(), 1u);
+				ox::expect(*asdf, "aoeu");
+				ox::expect(map.size(), 1u);
 				auto const aoeu = map.at("aoeu");
-				oxExpect(aoeu.ok(), false);
-				oxExpect(map.size(), 1u);
+				ox::expect(aoeu.ok(), false);
+				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"]);
-			oxExpect(si2["asdf"], 0);
+			ox::expect(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}));
-			oxExpect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0}));
-			oxExpect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0}));
-			oxExpect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0}));
-			oxExpect(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<int32_t>(4).unwrap(), BA({4, 0, 0, 0}));
+			ox::expect(ox::serialize<int32_t>(256).unwrap(), BA({0, 1, 0, 0}));
+			ox::expect(ox::serialize<int32_t>(257).unwrap(), BA({1, 1, 0, 0}));
+			ox::expect(ox::serialize<uint32_t>(4).unwrap(), BA({4, 0, 0, 0}));
+			ox::expect(ox::serialize<uint32_t>(256).unwrap(), BA({0, 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}));
-			return ox::Error(0);
+			ox::expect(ox::serialize<uint32_t>(0xffff'ffff).unwrap(), BA({neg1, neg1, neg1, neg1}));
+			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);
-			oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeu");
+			ox::expect(b.size(), 8u);
+			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);
-			oxExpect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty");
-			return ox::Error(0);
+			ox::expect(b.size(), 14u);
+			ox::expect(ox::StringView(b.data(), b.size()), "asdfaoeuqwerty");
+			return ox::Error{};
 		}
 	},
 	{
 		"FromHex",
 		[] {
-			oxExpect(ox::detail::fromHex("01").unwrap(), 0x01);
-			oxExpect(ox::detail::fromHex("02").unwrap(), 0x02);
-			oxExpect(ox::detail::fromHex("03").unwrap(), 0x03);
-			oxExpect(ox::detail::fromHex("04").unwrap(), 0x04);
-			oxExpect(ox::detail::fromHex("05").unwrap(), 0x05);
-			oxExpect(ox::detail::fromHex("06").unwrap(), 0x06);
-			oxExpect(ox::detail::fromHex("07").unwrap(), 0x07);
-			oxExpect(ox::detail::fromHex("08").unwrap(), 0x08);
-			oxExpect(ox::detail::fromHex("0d").unwrap(), 0x0d);
-			oxExpect(ox::detail::fromHex("0e").unwrap(), 0x0e);
-			oxExpect(ox::detail::fromHex("0f").unwrap(), 0x0f);
-			oxExpect(ox::detail::fromHex("0F").unwrap(), 0x0f);
-			oxExpect(ox::detail::fromHex("fF").unwrap(), 0xff);
-			oxExpect(ox::detail::fromHex("ff").unwrap(), 0xff);
-			oxExpect(ox::detail::fromHex("a0").unwrap(), 0xa0);
-			oxExpect(ox::detail::fromHex("93").unwrap(), 0x93);
-			oxExpect(ox::detail::fromHex("40").unwrap(), 0x40);
-			return ox::Error(0);
+			ox::expect(ox::detail::fromHex("01").unwrap(), 0x01);
+			ox::expect(ox::detail::fromHex("02").unwrap(), 0x02);
+			ox::expect(ox::detail::fromHex("03").unwrap(), 0x03);
+			ox::expect(ox::detail::fromHex("04").unwrap(), 0x04);
+			ox::expect(ox::detail::fromHex("05").unwrap(), 0x05);
+			ox::expect(ox::detail::fromHex("06").unwrap(), 0x06);
+			ox::expect(ox::detail::fromHex("07").unwrap(), 0x07);
+			ox::expect(ox::detail::fromHex("08").unwrap(), 0x08);
+			ox::expect(ox::detail::fromHex("0d").unwrap(), 0x0d);
+			ox::expect(ox::detail::fromHex("0e").unwrap(), 0x0e);
+			ox::expect(ox::detail::fromHex("0f").unwrap(), 0x0f);
+			ox::expect(ox::detail::fromHex("0F").unwrap(), 0x0f);
+			ox::expect(ox::detail::fromHex("fF").unwrap(), 0xff);
+			ox::expect(ox::detail::fromHex("ff").unwrap(), 0xff);
+			ox::expect(ox::detail::fromHex("a0").unwrap(), 0xa0);
+			ox::expect(ox::detail::fromHex("93").unwrap(), 0x93);
+			ox::expect(ox::detail::fromHex("40").unwrap(), 0x40);
+			return ox::Error{};
 		}
 	},
 	{
 		"ToHex",
 		[] {
-			oxExpect(ox::detail::toHex(0x01), "01");
-			oxExpect(ox::detail::toHex(0x02), "02");
-			oxExpect(ox::detail::toHex(0x03), "03");
-			oxExpect(ox::detail::toHex(0x04), "04");
-			oxExpect(ox::detail::toHex(0x05), "05");
-			oxExpect(ox::detail::toHex(0x06), "06");
-			oxExpect(ox::detail::toHex(0x07), "07");
-			oxExpect(ox::detail::toHex(0x08), "08");
-			oxExpect(ox::detail::toHex(0x0d), "0d");
-			oxExpect(ox::detail::toHex(0x0e), "0e");
-			oxExpect(ox::detail::toHex(0x0f), "0f");
-			oxExpect(ox::detail::toHex(0x93), "93");
-			oxExpect(ox::detail::toHex(0x40), "40");
-			oxExpect(ox::detail::toHex(0xf0), "f0");
-			return ox::Error(0);
+			ox::expect(ox::detail::toHex(0x01), "01");
+			ox::expect(ox::detail::toHex(0x02), "02");
+			ox::expect(ox::detail::toHex(0x03), "03");
+			ox::expect(ox::detail::toHex(0x04), "04");
+			ox::expect(ox::detail::toHex(0x05), "05");
+			ox::expect(ox::detail::toHex(0x06), "06");
+			ox::expect(ox::detail::toHex(0x07), "07");
+			ox::expect(ox::detail::toHex(0x08), "08");
+			ox::expect(ox::detail::toHex(0x0d), "0d");
+			ox::expect(ox::detail::toHex(0x0e), "0e");
+			ox::expect(ox::detail::toHex(0x0f), "0f");
+			ox::expect(ox::detail::toHex(0x93), "93");
+			ox::expect(ox::detail::toHex(0x40), "40");
+			ox::expect(ox::detail::toHex(0xf0), "f0");
+			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);
-			oxExpect(ox::UUID{}.isNull(), true);
-			oxExpect(ox::UUID::fromString(uuidStr).value.isNull(), false);
-			return ox::Error(0);
+			ox::expect(uuid.toString(), uuidStr);
+			ox::expect(ox::UUID{}.isNull(), true);
+			ox::expect(ox::UUID::fromString(uuidStr).value.isNull(), false);
+			return ox::Error{};
 		}
 	},
 	{
 		"UUID::generate",
 		[] {
 			ox::UUID::seedGenerator({1234, 4321});
-			oxExpect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827");
-			oxExpect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf");
-			oxExpect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e");
-			return ox::Error(0);
+			ox::expect(ox::UUID::generate().unwrap().toString(), "5c3f4b5e-ccbf-4727-7f03-3053dedc8827");
+			ox::expect(ox::UUID::generate().unwrap().toString(), "90d0274a-2774-4afa-88e5-0c1d60ba3abf");
+			ox::expect(ox::UUID::generate().unwrap().toString(), "7df77910-841c-48ba-ea2e-44521ac47c2e");
+			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);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
 			sv = "ab.cd.fg";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 3u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
-			oxExpect(list[2], "fg");
+			ox::expect(list.size(), 3u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
+			ox::expect(list[2], "fg");
 			sv = "ab.cd.";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 2u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
 			sv = ".ab.cd.";
 			list = ox::split(sv, ".");
-			oxExpect(list.size(), 2u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			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);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
 			sv = "ab.cd.fg";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 3u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
-			oxExpect(list[2], "fg");
+			ox::expect(list.size(), 3u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
+			ox::expect(list[2], "fg");
 			sv = "ab.cd.";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 2u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			ox::expect(list[1], "cd");
 			sv = ".ab.cd.";
 			list = ox::split(sv, '.');
-			oxExpect(list.size(), 2u);
-			oxExpect(list[0], "ab");
-			oxExpect(list[1], "cd");
+			ox::expect(list.size(), 2u);
+			ox::expect(list[0], "ab");
+			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);
-			return ox::Error(0);
+			ox::expect(list.size(), 0u);
+			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,
-				const std::size_t cap) noexcept {
+				std::size_t const count,
+				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]);
-						const auto srcItem = reinterpret_cast<T *>(&src->m_data[i]);
-						std::construct_at<T>(dstItem, std::move(*srcItem));
+						auto const srcItem = std::launder(reinterpret_cast<T*>(&src->m_data[i]));
+						new (&m_data[i]) T(std::move(*srcItem));
+					}
+					if (count) {
+						*items = std::launder(reinterpret_cast<T*>(m_data.data()));
+					} else {
+						*items = reinterpret_cast<T*>(m_data.data());
 					}
-					*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,
-				const std::size_t) noexcept {
+				std::size_t const,
+				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;
@@ -277,7 +263,7 @@ class Vector: detail::VectorAllocator<T, Allocator, SmallVectorSize> {
 		constexpr bool contains(MaybeView_t<T> const&) const noexcept;
 
 		constexpr iterator<T&, T*, false> insert(
-				std::size_t pos, std::size_t cnt, T const&val) noexcept(useNoexcept);
+				std::size_t pos, std::size_t cnt, T const &val) noexcept(useNoexcept);
 
 		constexpr iterator<T&, T*, false> insert(std::size_t pos, T val) noexcept(useNoexcept);
 
@@ -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];
 }
 
@@ -532,7 +520,13 @@ constexpr void Vector<T, SmallVectorSize, Allocator>::resize(std::size_t size) n
 }
 
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
-constexpr bool Vector<T, SmallVectorSize, Allocator>::contains(MaybeView_t<T> const&v) const noexcept {
+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) {
 		if (m_items[i] == v) {
 			return true;
@@ -544,7 +538,7 @@ constexpr bool Vector<T, SmallVectorSize, Allocator>::contains(MaybeView_t<T> co
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
 constexpr typename Vector<T, SmallVectorSize, Allocator>::template iterator<T&, T*, false>
 Vector<T, SmallVectorSize, Allocator>::insert(
-		std::size_t pos, std::size_t cnt, T const&val) noexcept(useNoexcept) {
+		std::size_t pos, std::size_t cnt, T const &val) noexcept(useNoexcept) {
 	if (m_size + cnt > m_cap) {
 		reserveInsert(m_cap ? m_size + cnt : initialCap, pos, cnt);
 	}
@@ -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_SPRITE_PALETTE (*reinterpret_cast<::Palette*>(0x0500'0200))
+#define MEM_BG_PALETTE (*(reinterpret_cast<::Palette*>(0x0500'0000)))
+#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_MAP (*reinterpret_cast<ox::Array<BgMapTile, 4>*>(0x0600'e000))
+#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_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_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_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)
-      * studio - studio plugin for scene (P-)
-      * keel - keel plugin for scene (PG)
+    * sound - sound system for Nostalgia (PG)
+      * studio - studio plugin for sound (P-)
+      * keel - keel plugin for sound (PG)
   * player - plays the games (PG)
   * studio - makes the games (P-)
   * tools - command line tools (P-)
@@ -48,7 +48,7 @@ All components have a platform indicator next to them:
     Not really that external... (PG)
   * GlUtils - OpenGL helpers (P-)
   * teagba - GBA assembly startup code (mostly pulled from devkitPro under MPL
-	          2.0), and custom GBA hardware interop code (-G)
+	         2.0), and custom GBA hardware interop code (-G)
 
 Most GBA code is built on PC because it is small and helps to work on both
 projects with the same CMake build dir, but GBA code is never linked with any
@@ -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,
-but exceptions may be used where they make sense.
+[ox::Error](deps/ox/ox-docs.md#error-handling) for error reporting.
+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 {
-	teagba::scrollBgOffset(bg, x, y);
+void scrollBgOffset(Context &ctx, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+	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>(s.flipX) << 12)
-			| (static_cast<uint16_t>(s.spriteSize) << 14)),
+			  (static_cast<uint16_t>(sprite.x) & ox::onMask<uint8_t>(8))
+			| (static_cast<uint16_t>(sprite.flipX) << 12)
+			| (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>(s.priority & 0b11) << 10)),
+			  (static_cast<uint16_t>((sprite.tileIdx * (1 + eightBpp)) & ox::onMask<uint16_t>(8)))
+			| (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,11 +13,11 @@ 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;
 
-ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const&uuid) noexcept {
+ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const &uuid) noexcept {
 	OX_RETURN_ERROR(write(writer, "K1;"));
 	OX_RETURN_ERROR(uuid.toString(writer));
 	return writer.put(';');
@@ -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/assetmanager.hpp

@@ -351,23 +351,23 @@ class AssetManager {
 template<typename T>
 class AssetRef {
 	private:
-		T const* m_obj = nullptr;
+		T const *m_obj = nullptr;
 
 	public:
 		constexpr AssetRef() noexcept = default;
 
-		explicit constexpr AssetRef(T const*obj) noexcept: m_obj(obj) {
+		explicit constexpr AssetRef(T const *obj) noexcept: m_obj(obj) {
 		}
 
-		constexpr T const*get() const noexcept {
+		constexpr T const *get() const noexcept {
 			return m_obj;
 		}
 
-		constexpr T const&operator*() const & noexcept {
+		constexpr T const &operator*() const & noexcept {
 			return *m_obj;
 		}
 
-		constexpr T const*operator->() const noexcept {
+		constexpr T const *operator->() const noexcept {
 			return m_obj;
 		}
 

src/olympic/keel/include/keel/context.hpp

@@ -35,7 +35,7 @@ class Context {
 };
 
 constexpr ox::SpanView<PackTransform> packTransforms(
-		[[maybe_unused]] Context const&ctx) noexcept {
+		[[maybe_unused]] Context const &ctx) noexcept {
 #ifndef OX_BARE_METAL
 	return ctx.packTransforms;
 #else
@@ -44,7 +44,7 @@ constexpr ox::SpanView<PackTransform> packTransforms(
 }
 
 constexpr ox::SpanView<Converter> converters(
-		[[maybe_unused]] Context const&ctx) noexcept {
+		[[maybe_unused]] Context const &ctx) noexcept {
 #ifndef OX_BARE_METAL
 	return ctx.converters;
 #else

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

@@ -29,22 +29,22 @@ OX_MODEL_BEGIN(PreloadPtr)
 	OX_MODEL_FIELD(preloadAddr)
 OX_MODEL_END()
 
-ox::Result<std::size_t> getPreloadAddr(Context &ctx, ox::FileAddress const&addr) noexcept;
+ox::Result<std::size_t> getPreloadAddr(Context &ctx, ox::FileAddress const &addr) noexcept;
 ox::Result<std::size_t> getPreloadAddr(Context &ctx, ox::StringViewCR path) noexcept;
 
 
-void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const&uuid) noexcept;
+void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const &uuid) noexcept;
 
 // map of UUIDs to paths
 using DuplicateSet = ox::HashMap<ox::UUID, ox::Vector<ox::String>>;
 
 ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept;
 
-ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const &fileAddr) noexcept;
 
 ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringViewCR path) noexcept;
 
-ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const &fileAddr) noexcept;
 
 ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringViewCR fileId) noexcept;
 
@@ -58,7 +58,7 @@ ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringViewCR uuid) n
 
 ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noexcept;
 
-ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept;
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const &uuid) noexcept;
 
 [[nodiscard]]
 constexpr bool isUuidUrl(ox::StringViewCR path) noexcept {
@@ -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
@@ -158,8 +158,8 @@ ox::Result<AssetRef<T>> readObj(
 template<typename T>
 ox::Result<AssetRef<T>> readObj(
 		Context &ctx,
-		ox::FileAddress const&file,
-		[[maybe_unused]] bool forceLoad = false) noexcept {
+		ox::FileAddress const &file,
+		[[maybe_unused]] bool const forceLoad = false) noexcept {
 #ifndef OX_BARE_METAL
 	OX_REQUIRE(assetId, file.getPath());
 	return readObj<T>(ctx, ox::StringView(assetId), forceLoad);
@@ -176,9 +176,9 @@ ox::Result<AssetRef<T>> readObj(
 template<typename T>
 ox::Error writeObj(
 		Context &ctx,
-		ox::FileAddress const&file,
-		T const&obj,
-		ox::ClawFormat fmt = ox::ClawFormat::Metal) noexcept {
+		ox::FileAddress const &file,
+		T const &obj,
+		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/module.hpp

@@ -40,6 +40,6 @@ class Module {
 void registerModule(Module const*mod) noexcept;
 
 [[nodiscard]]
-ox::Vector<keel::Module const*> const&modules() noexcept;
+ox::Vector<keel::Module const*> const &modules() noexcept;
 
 }

src/olympic/keel/include/keel/pack.hpp

@@ -125,7 +125,7 @@ ox::Error preloadObj(
 		OX_RETURN_ERROR(err);
 		keel::PreloadPtr const p{.preloadAddr = a};
 		OX_RETURN_ERROR(ox::writeMC(p).moveTo(buff));
-		auto const&pbufSz = pl.buff().size();
+		auto const &pbufSz = pl.buff().size();
 		oxOutf("preloaded {} as a {} @ {} to {} / {}, total size: {}\n",
 			path, obj.type()->typeName, a, a + size, pbufSz - 1, pbufSz - a);
 	} else {
@@ -148,7 +148,7 @@ ox::Error preloadDir(
 	// copy
 	oxTracef("pack.preload", "path: {}", path);
 	OX_REQUIRE(fileList, romFs.ls(path));
-	for (auto const&name : fileList) {
+	for (auto const &name : fileList) {
 		auto const filePath = ox::sfmt("{}{}", path, name);
 		OX_REQUIRE(stat, romFs.stat(filePath));
 		if (stat.fileType == ox::FileType::Directory) {
@@ -169,7 +169,7 @@ ox::Error preloadDir(
 }
 
 template<typename PlatSpec>
-ox::Error appendBinary(ox::Buffer &binBuff, ox::SpanView<char> const&fsBuff, ox::Preloader<PlatSpec> &pl) noexcept {
+ox::Error appendBinary(ox::Buffer &binBuff, ox::SpanView<char> const &fsBuff, ox::Preloader<PlatSpec> &pl) noexcept {
 	constexpr auto padbin = [](ox::BufferWriter &w, unsigned factor) noexcept -> ox::Error {
 		return w.write(nullptr, factor - w.buff().size() % factor);
 	};
@@ -185,7 +185,7 @@ ox::Error appendBinary(ox::Buffer &binBuff, ox::SpanView<char> const&fsBuff, ox:
 	OX_RETURN_ERROR(padbin(w, hdrSize));
 	OX_RETURN_ERROR(w.write(preloadHdr.data(), preloadHdr.bytes()));
 	OX_RETURN_ERROR(pl.offsetPtrs(binBuff.size()));
-	auto const&plBuff = pl.buff();
+	auto const &plBuff = pl.buff();
 	OX_RETURN_ERROR(w.write(plBuff.data(), plBuff.size()));
 	return {};
 }

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

@@ -122,7 +122,7 @@ class BaseConverter {
 		virtual ox::Result<ox::UPtr<Wrap>> convertPtrToPtr(keel::Context &ctx, Wrap &src) const noexcept = 0;
 
 		virtual ox::Result<ox::UPtr<Wrap>> convertBuffToPtr(
-				Context &ctx, ox::BufferView const&srcBuff) const noexcept = 0;
+				Context &ctx, ox::BufferView const &srcBuff) const noexcept = 0;
 
 		[[nodiscard]]
 		constexpr bool matches(
@@ -187,7 +187,7 @@ class ConverterFunc final: public BaseConverter {
 		}
 
 		ox::Result<ox::UPtr<Wrap>> convertBuffToPtr(
-				Context &ctx, ox::BufferView const&srcBuff) const noexcept override {
+				Context &ctx, ox::BufferView const &srcBuff) const noexcept override {
 			OX_REQUIRE_M(src, readAsset<SrcType>(srcBuff));
 			ox::Result<ox::UPtr<Wrap>> dst{makeWrap<DstType>()};
 			OX_RETURN_ERROR(convert(ctx, src, wrapCast<DstType>(*dst.value)));
@@ -214,13 +214,13 @@ class Converter {
 		}
 		[[nodiscard]]
 		BaseConverter const &converter() const noexcept {
-			return *m_buff.data();
+			return *std::launder(m_buff.data());
 		}
 };
 
 ox::Result<ox::UPtr<Wrap>> convert(
 		Context &ctx,
-		ox::BufferView const&srcBuffer,
+		ox::BufferView const &srcBuffer,
 		ox::StringViewCR dstTypeName,
 		int dstTypeVersion) noexcept;
 
@@ -241,7 +241,7 @@ ox::Result<ox::UPtr<Wrap>> convert(
 
 ox::Result<ox::UPtr<Wrap>> convert(
 		Context &ctx,
-		auto const&src,
+		auto const &src,
 		ox::StringViewCR dstTypeName,
 		int const dstTypeVersion) noexcept {
 	auto srcCpy = src;
@@ -258,13 +258,13 @@ ox::Result<DstType> convertObjToObj(
 }
 
 template<typename DstType>
-ox::Result<DstType> convert(Context &ctx, ox::BufferView const&src) noexcept {
+ox::Result<DstType> convert(Context &ctx, ox::BufferView const &src) noexcept {
 	OX_REQUIRE(out, convert(ctx, src, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
 	return std::move(wrapCast<DstType>(*out));
 }
 
 template<typename DstType>
-ox::Error convert(Context &ctx, ox::BufferView const&buff, DstType &outObj) noexcept {
+ox::Error convert(Context &ctx, ox::BufferView const &buff, DstType &outObj) noexcept {
 	OX_REQUIRE(out, convert(ctx, buff, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
 	outObj = std::move(wrapCast<DstType>(*out));
 	return {};
@@ -279,7 +279,7 @@ ox::Error convertObjToObj(Context &ctx, auto &src, DstType &outObj) noexcept {
 
 template<typename DstType>
 ox::Result<ox::Buffer> convertBuffToBuff(
-		Context &ctx, ox::BufferView const&src, ox::ClawFormat const fmt) noexcept {
+		Context &ctx, ox::BufferView const &src, ox::ClawFormat const fmt) noexcept {
 	OX_REQUIRE(out, convert(ctx, src, ox::ModelTypeName_v<DstType>, ox::ModelTypeVersion_v<DstType>));
 	return ox::writeClaw<DstType>(wrapCast<DstType>(*out), fmt);
 }

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);
+	return ox::readClaw(ts, buff + offset);
 }
 
-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).moveTo(out.value.clawHdr));
+	OX_RETURN_ERROR(ox::readClawHeader(buff + offset).moveTo(out.value.clawHdr));
 	return out;
 }
 

src/olympic/keel/src/keel.cpp

@@ -16,7 +16,7 @@ static ox::Error init(
 		setRomFs(ctx, std::move(fs), *duplicateSet) :
 		setRomFs(ctx, std::move(fs));
 #ifndef OX_BARE_METAL
-	auto const&mods = modules();
+	auto const &mods = modules();
 	for (auto &mod : mods) {
 		// register type converters
 		for (auto const c : mod->converters()) {

src/olympic/keel/src/media.cpp

@@ -24,10 +24,10 @@ ox::Result<char*> loadRom(ox::StringViewCR path) noexcept {
 		auto buff = new char[static_cast<std::size_t>(size)];
 		file.read(buff, size);
 		return buff;
-	} catch (std::ios_base::failure const&e) {
+	} catch (std::ios_base::failure const &e) {
 		oxErrorf("Could not read ROM file due to file IO failure: {}", e.what());
 		return ox::Error(2, "Could not read ROM file");
-	} catch (std::bad_alloc const&e) {
+	} catch (std::bad_alloc const &e) {
 		oxErrorf("Could not read ROM file due to new failure: {}", e.what());
 		return ox::Error(2, "Could not allocate memory for ROM file");
 	}
@@ -42,14 +42,14 @@ static void clearUuidMap(Context &ctx) noexcept {
 	ctx.pathToUuid.clear();
 }
 
-void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const&uuid) noexcept {
+void createUuidMapping(Context &ctx, ox::StringViewCR filePath, ox::UUID const &uuid) noexcept {
 	ctx.pathToUuid[filePath] = uuid;
 	ctx.uuidToPath[uuid.toString()] = filePath;
 }
 
 static ox::Error buildUuidMap(Context &ctx, ox::StringViewCR path, DuplicateSet *duplicates) noexcept {
 	OX_REQUIRE(files, ctx.rom->ls(path));
-	for (auto const&f : files) {
+	for (auto const &f : files) {
 		OX_REQUIRE_M(filePath, ox::join("/", ox::Array<ox::StringView, 2>{path, f}));
 		OX_REQUIRE(stat, ctx.rom->stat(filePath));
 		if (stat.fileType == ox::FileType::NormalFile) {
@@ -97,7 +97,7 @@ ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::StringViewCR path) noexcept {
 #endif
 }
 
-ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const &fileAddr) noexcept {
 	OX_REQUIRE(path, fileAddr.getPath());
 	return getUuid(ctx, path);
 }
@@ -111,7 +111,7 @@ ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringViewCR path) noexcept {
 	}
 }
 
-ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const &fileAddr) noexcept {
 	OX_REQUIRE(path, fileAddr.getPath());
 	if (beginsWith(path, "uuid://")) {
 		auto const uuid = substr(path, 7);
@@ -173,7 +173,7 @@ ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::StringViewCR uuid) noex
 #endif
 }
 
-ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const &uuid) noexcept {
 #ifndef OX_BARE_METAL
 	OX_REQUIRE_M(out, ctx.uuidToPath.at(uuid.toString()));
 	return ox::CStringView(*out);
@@ -240,7 +240,7 @@ ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::StringViewCR path
 	return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
 }
 
-ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&addr) noexcept {
+ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const &addr) noexcept {
 	OX_REQUIRE(stat, ctx.rom->stat(addr));
 	OX_REQUIRE(buff, static_cast<ox::MemFS&>(*ctx.rom).directAccess(addr));
 	PreloadPtr p;

src/olympic/keel/src/module.cpp

@@ -8,14 +8,14 @@ namespace keel {
 
 static ox::Vector<Module const*> mods;
 
-void registerModule(Module const*mod) noexcept {
+void registerModule(Module const *mod) noexcept {
 	if (mod) {
 		mods.emplace_back(mod);
 	}
 }
 
 [[nodiscard]]
-ox::Vector<Module const*> const&modules() noexcept {
+ox::Vector<Module const*> const &modules() noexcept {
 	return mods;
 }
 

src/olympic/keel/src/pack-applib.cpp

@@ -32,7 +32,7 @@ static ox::Result<ox::Buffer> readFileBuff(ox::StringViewCR path) noexcept {
 		file.seekg(0, std::ios::beg);
 		file.read(buff.data(), static_cast<std::streamsize>(buff.size()));
 		return buff;
-	} catch (std::ios_base::failure const&e) {
+	} catch (std::ios_base::failure const &e) {
 		oxErrorf("Could not read OxFS file: {}", e.what());
 		return ox::Error(2, "Could not read OxFS file");
 	}

src/olympic/keel/src/pack.cpp

@@ -144,7 +144,7 @@ static ox::Error transformClaw(
 	// copy
 	oxTracef("pack.transformClaw", "path: {}", path);
 	OX_REQUIRE(fileList, dest.ls(path));
-	for (auto const&name : fileList) {
+	for (auto const &name : fileList) {
 		auto const filePath = ox::sfmt("{}{}", path, name);
 		OX_REQUIRE(stat, dest.stat(filePath));
 		if (stat.fileType == ox::FileType::Directory) {
@@ -171,7 +171,7 @@ static ox::Error copy(
 	auto const childLogPrefix = ox::sfmt("{}\t", logPrefix);
 	// copy
 	OX_REQUIRE(fileList, src.ls(path));
-	for (auto const&name : fileList) {
+	for (auto const &name : fileList) {
 		auto const currentFile = ox::sfmt("{}{}", path, name);
 		if (beginsWith(name, ".")) {
 			continue;
@@ -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/typeconv.cpp

@@ -9,12 +9,12 @@
 namespace keel {
 
 static ox::Result<BaseConverter const*> findConverter(
-		ox::SpanView<Converter> const&converters,
+		ox::SpanView<Converter> const &converters,
 		ox::StringViewCR srcTypeName,
 		int const srcTypeVersion,
 		ox::StringViewCR dstTypeName,
 		int const dstTypeVersion) noexcept {
-	for (auto const&c : converters) {
+	for (auto const &c : converters) {
 		if (c.converter().matches(srcTypeName, srcTypeVersion, dstTypeName, dstTypeVersion)) {
 			return &c.converter();
 		}
@@ -22,17 +22,17 @@ static ox::Result<BaseConverter const*> findConverter(
 	return ox::Error{1, "Could not find converter"};
 };
 
-static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const&c, Context &ctx, ox::BufferView const&src) noexcept {
+static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const &c, Context &ctx, ox::BufferView const &src) noexcept {
 	return c.convertBuffToPtr(ctx, src);
 }
 
-static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const&c, Context &ctx, Wrap &src) noexcept {
+static ox::Result<ox::UPtr<Wrap>> convert(BaseConverter const &c, Context &ctx, Wrap &src) noexcept {
 	return c.convertPtrToPtr(ctx, src);
 }
 
 static ox::Result<ox::UPtr<Wrap>> convert(
 		Context &ctx,
-		ox::SpanView<Converter> const&converters,
+		ox::SpanView<Converter> const &converters,
 		auto &src,
 		ox::StringViewCR srcTypeName,
 		int const srcTypeVersion,
@@ -45,7 +45,7 @@ static ox::Result<ox::UPtr<Wrap>> convert(
 		return convert(*c, ctx, src);
 	}
 	// try to chain multiple converters
-	for (auto const&subConverter : converters) {
+	for (auto const &subConverter : converters) {
 		if (!subConverter.converter().dstMatches(dstTypeName, dstTypeVersion)) {
 			continue;
 		}
@@ -61,7 +61,7 @@ static ox::Result<ox::UPtr<Wrap>> convert(
 
 ox::Result<ox::UPtr<Wrap>> convert(
 		Context &ctx,
-		ox::BufferView const&srcBuffer,
+		ox::BufferView const &srcBuffer,
 		ox::StringViewCR dstTypeName,
 		int const dstTypeVersion) noexcept {
 	OX_REQUIRE(hdr, readAssetHeader(srcBuffer));

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 &n = ctx.navStack[ctx.navIdx];
+	auto const nextIdx = ctx.navIdx + 1;
+	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,7 +306,9 @@ static void handleGlfwMouseButtonEvent(
 	int) noexcept {
 	auto &ctx = *static_cast<Context*>(glfwGetWindowUserPointer(window));
 	setMandatoryRefreshPeriod(ctx, ticksMs(ctx) + config::MandatoryRefreshPeriod);
-	ctx.mouseButtonEventHandler(ctx, btn, action == 1);
+	if (ctx.mouseButtonEventHandler) {
+		ctx.mouseButtonEventHandler(ctx, btn, action == 1);
+	}
 }
 
 static void handleGlfwKeyEvent(GLFWwindow *window, int const key, int, int const action, int) noexcept {