Make CLArgs::getBool use underlying m_bools member variable

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/src/ox/clargs/clargs.cpp

@@ -40,7 +40,7 @@ ClArgs::ClArgs(ox::SpanView<const char*> args) noexcept {
 }
 
 bool ClArgs::getBool(ox::StringViewCR arg, bool defaultValue) const noexcept {
-	auto const [value, err] = m_ints.at(arg);
+	auto const [value, err] = m_bools.at(arg);
 	return !err ? *value : defaultValue;
 }
 

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/mc/test/tests.cpp

@@ -157,7 +157,6 @@ 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);
 				oxAssert(testIn.List[0]             == testOut.List[0],             "List[0] value mismatch");
 				oxAssert(testIn.List[1]             == testOut.List[1],             "List[1] value mismatch");

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/assert.cpp

@@ -33,7 +33,7 @@ void panic(StringViewCR file, int const line, StringViewCR panicMsg, Error const
 #endif
 }
 
-#if __GNUC__
+#if __GNUC__ && !_WIN32
 __attribute__((weak))
 #endif
 void panic(const char *file, int const line, char const*panicMsg, Error const&err) noexcept {

deps/ox/src/ox/std/ignore.hpp

@@ -16,7 +16,7 @@
 
 namespace std {
 
-inline constexpr struct {
+inline constexpr struct ignore_t {
 	constexpr void operator=(auto&&) const noexcept {}
 } ignore;
 

deps/ox/src/ox/std/memory.hpp

@@ -213,8 +213,7 @@ class UniquePtr {
 			return m_t;
 		}
 
-		template<typename U, typename UDeleter>
-		constexpr void reset(UniquePtr<U, UDeleter> &&other = UniquePtr()) {
+		constexpr void reset(UniquePtr &&other = UniquePtr()) {
 			auto t = m_t;
 			m_t = other.release();
 			Deleter()(t);

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

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

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

@@ -163,6 +163,24 @@ class Span {
 			return *this;
 		}
 
+		constexpr Span operator++(int) noexcept {
+			++m_items;
+			--m_size;
+			if (!m_size) [[unlikely]] {
+				m_items = nullptr;
+			}
+			return *this;
+		}
+
+		constexpr Span operator++() noexcept {
+			++m_items;
+			--m_size;
+			if (!m_size) [[unlikely]] {
+				m_items = nullptr;
+			}
+			return *this;
+		}
+
 		[[nodiscard]]
 		constexpr auto data() const noexcept {
 			return m_items;

deps/ox/src/ox/std/string.hpp

@@ -139,7 +139,7 @@ class BasicString {
 
 		constexpr BasicString &operator+=(Integer_c auto i) noexcept;
 
-		constexpr BasicString &operator+=(StringView src) noexcept;
+		constexpr BasicString &operator+=(StringViewCR src) noexcept;
 
 		constexpr BasicString &operator+=(BasicString const&src) noexcept;
 
@@ -185,7 +185,7 @@ class BasicString {
 			return {};
 		}
 
-		constexpr Error append(ox::StringView sv) noexcept {
+		constexpr Error append(StringViewCR sv) noexcept {
 			return append(sv.data(), sv.size());
 		}
 
@@ -376,7 +376,7 @@ constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operat
 }
 
 template<std::size_t SmallStringSize_v>
-constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operator+=(StringView s) noexcept {
+constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operator+=(StringViewCR s) noexcept {
 	std::size_t strLen = s.bytes();
 	std::ignore = append(s.data(), strLen);
 	return *this;
@@ -456,7 +456,7 @@ constexpr bool BasicString<SmallStringSize_v>::operator==(const char *other) con
 
 template<std::size_t SmallStringSize_v>
 constexpr bool BasicString<SmallStringSize_v>::operator==(OxString_c auto const&other) const noexcept {
-	return ox::StringView(*this) == ox::StringView(other);
+	return StringView(*this) == StringView(other);
 }
 
 template<std::size_t SmallStringSize_v>
@@ -548,28 +548,28 @@ using StringCR = String const&;
 
 
 [[nodiscard]]
-constexpr ox::String toString(ox::StringViewCR sv) noexcept {
+constexpr String toString(StringViewCR sv) noexcept {
 	return ox::String(sv);
 }
 
 
 template<typename PlatSpec, std::size_t SmallStringSize_v>
 [[nodiscard]]
-constexpr auto sizeOf(const ox::BasicString<SmallStringSize_v>*) noexcept {
+constexpr auto sizeOf(BasicString<SmallStringSize_v> const*) noexcept {
 	VectorMemMap<PlatSpec> v{.smallVecSize = SmallStringSize_v};
 	return sizeOf<PlatSpec>(&v);
 }
 
 template<typename PlatSpec, std::size_t SmallStringSize_v>
 [[nodiscard]]
-constexpr auto alignOf(const ox::BasicString<SmallStringSize_v>&) noexcept {
+constexpr auto alignOf(BasicString<SmallStringSize_v> const&) noexcept {
 	VectorMemMap<PlatSpec> v{.smallVecSize = SmallStringSize_v};
 	return alignOf<PlatSpec>(&v);
 }
 
 template<size_t sz>
-struct MaybeView<ox::BasicString<sz>> {
-	using type = ox::StringView;
+struct MaybeView<BasicString<sz>> {
+	using type = StringView;
 };
 
 }

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

@@ -19,7 +19,7 @@ namespace ox {
  */
 class StringLiteral: public detail::BaseStringView {
 	public:
-		consteval StringLiteral() noexcept = default;
+		constexpr StringLiteral() noexcept = default;
 
 		constexpr StringLiteral(StringLiteral const &sv) noexcept = default;
 

deps/ox/src/ox/std/strops.hpp

@@ -21,7 +21,7 @@ OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
 namespace ox {
 
 [[nodiscard]]
-constexpr ox::StringView substr(ox::StringView const&str, std::size_t pos) noexcept {
+constexpr StringView substr(StringViewCR str, std::size_t const pos) noexcept {
 	if (str.size() >= pos) {
 		return {&str[pos], str.size() - pos};
 	}
@@ -29,13 +29,23 @@ constexpr ox::StringView substr(ox::StringView const&str, std::size_t pos) noexc
 }
 
 [[nodiscard]]
-constexpr ox::StringView substr(ox::StringView const&str, std::size_t start, std::size_t end) noexcept {
+constexpr StringView substr(StringViewCR str, std::size_t const start, std::size_t const end) noexcept {
 	if (str.size() >= start && end >= start) {
 		return {&str[start], end - start};
 	}
 	return {};
 }
 
+[[nodiscard]]
+constexpr bool beginsWith(StringViewCR base, char const beginning) noexcept {
+	return base.size() && base[0] == beginning;
+}
+
+[[nodiscard]]
+constexpr bool endsWith(StringViewCR base, char const ending) noexcept {
+	return base.size() && base[base.size() - 1] == ending;
+}
+
 [[nodiscard]]
 constexpr bool beginsWith(StringViewCR base, StringViewCR beginning) noexcept {
 	const auto beginningLen = ox::min(beginning.size(), base.size());
@@ -49,7 +59,7 @@ constexpr bool endsWith(StringViewCR base, StringViewCR ending) noexcept {
 }
 
 [[nodiscard]]
-constexpr std::size_t find(StringViewCR str, char search) noexcept {
+constexpr std::size_t find(StringViewCR str, char const search) noexcept {
 	std::size_t i = 0;
 	for (; i < str.size(); ++i) {
 		if (str[i] == search) {
@@ -72,7 +82,7 @@ constexpr std::size_t find(StringViewCR str, StringViewCR search) noexcept {
 
 template<std::size_t smallSz = 0>
 [[nodiscard]]
-constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, char del) noexcept {
+constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, char const del) noexcept {
 	ox::Vector<ox::StringView, smallSz> out;
 	constexpr auto nextSeg = [](StringViewCR current, char del) {
 		return substr(current, find(current, del) + 1);
@@ -105,7 +115,7 @@ constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, StringView
 }
 
 [[nodiscard]]
-constexpr ox::Result<std::size_t> lastIndexOf(ox::StringViewCR str, int character) noexcept {
+constexpr ox::Result<std::size_t> lastIndexOf(ox::StringViewCR str, int const character) noexcept {
 	ox::Result<std::size_t> retval = ox::Error(1, "Character not found");
 	for (auto i = static_cast<int>(str.bytes() - 1); i >= 0; --i) {
 		if (str[static_cast<std::size_t>(i)] == character) {

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

@@ -337,7 +337,6 @@ OX_CLANG_NOWARN_END
 			oxExpect(si["asdf"], 0);
 			oxAssert(si["aoeu"] == 100, "aoeu != 100");
 			auto si2 = si;
-			oxDebugf("{}", si2["asdf"]);
 			oxExpect(si2["asdf"], 0);
 			oxAssert(si2["aoeu"] == 100, "aoeu != 100");
 			ox::HashMap<int, int> ii;

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/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,45 +49,31 @@ 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()) {
-				Allocator{}.deallocate(items, cap);
+				if (items) {
+					Allocator{}.deallocate(items, cap);
+				}
 			} else {
 				if (items && static_cast<void*>(items) != static_cast<void*>(m_data.data())) {
 					Allocator{}.deallocate(items, cap);
@@ -101,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);
 		}
 
@@ -112,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);
 			}
@@ -285,7 +271,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);
 
@@ -419,7 +407,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;
@@ -615,7 +603,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

@@ -54,25 +54,41 @@ inline volatile BgCtl &regBgCtl(uintptr_t const bgIdx) noexcept {
 }
 
 // background horizontal scrolling registers
-#define REG_BG0HOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'0010))
-#define REG_BG1HOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'0014))
-#define REG_BG2HOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'0018))
-#define REG_BG3HOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'001c))
+#define REG_BG0HOFS (*reinterpret_cast<volatile int16_t*>(0x0400'0010))
+#define REG_BG1HOFS (*reinterpret_cast<volatile int16_t*>(0x0400'0014))
+#define REG_BG2HOFS (*reinterpret_cast<volatile int16_t*>(0x0400'0018))
+#define REG_BG3HOFS (*reinterpret_cast<volatile int16_t*>(0x0400'001c))
 
 [[nodiscard]]
-volatile uint32_t &regBgHofs(auto const bgIdx) noexcept {
-	return *reinterpret_cast<volatile uint32_t*>(0x0400'0010 + 4 * bgIdx);
+volatile int16_t &regBgHofs(auto const bgIdx) noexcept {
+	return *reinterpret_cast<volatile int16_t*>(0x0400'0010 + 4 * bgIdx);
 }
 
 // background vertical scrolling registers
-#define REG_BG0VOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'0012))
-#define REG_BG1VOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'0016))
-#define REG_BG2VOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'001a))
-#define REG_BG3VOFS (*reinterpret_cast<volatile uint32_t*>(0x0400'001e))
+#define REG_BG0VOFS (*reinterpret_cast<volatile int16_t*>(0x0400'0012))
+#define REG_BG1VOFS (*reinterpret_cast<volatile int16_t*>(0x0400'0016))
+#define REG_BG2VOFS (*reinterpret_cast<volatile int16_t*>(0x0400'001a))
+#define REG_BG3VOFS (*reinterpret_cast<volatile int16_t*>(0x0400'001e))
 
 [[nodiscard]]
-volatile uint32_t &regBgVofs(auto const bgIdx) noexcept {
-	return *reinterpret_cast<volatile uint32_t*>(0x0400'0012 + 4 * bgIdx);
+volatile int16_t &regBgVofs(auto const bgIdx) noexcept {
+	return *reinterpret_cast<volatile int16_t*>(0x0400'0012 + 4 * bgIdx);
+}
+
+// background scrolling registers
+
+struct OffsetPair {
+	int16_t x{}, y{};
+};
+
+#define REG_BG0OFS (*reinterpret_cast<volatile OffsetPair*>(0x0400'0010))
+#define REG_BG1OFS (*reinterpret_cast<volatile OffsetPair*>(0x0400'0014))
+#define REG_BG2OFS (*reinterpret_cast<volatile OffsetPair*>(0x0400'0018))
+#define REG_BG3OFS (*reinterpret_cast<volatile OffsetPair*>(0x0400'001c))
+
+[[nodiscard]]
+volatile OffsetPair &regBgOfs(auto const bgIdx) noexcept {
+	return *reinterpret_cast<volatile OffsetPair*>(0x0400'0010 + sizeof(OffsetPair) * bgIdx);
 }
 
 /////////////////////////////////////////////////////////////////

deps/teagba/include/teagba/gfx.hpp

@@ -41,4 +41,8 @@ void addSpriteUpdate(GbaSpriteAttrUpdate const &upd) noexcept;
 
 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

@@ -12,7 +12,7 @@ namespace teagba {
 
 static ox::Array<GbaSpriteAttrUpdate, 128> g_spriteBuffer;
 
-GbaSpriteAttrUpdate &spriteAttr(size_t i) noexcept {
+GbaSpriteAttrUpdate &spriteAttr(size_t const i) noexcept {
 	return g_spriteBuffer[i];
 }
 
@@ -29,4 +29,16 @@ void applySpriteUpdates() noexcept {
 	}
 }
 
+void setBgOffset(uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+	auto &o = regBgOfs(bg);
+	o.x = x;
+	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;
+}
+
 }

release-notes.md

@@ -1,3 +1,9 @@
+# d2025.07.0
+
+* Add sub-command for exporting TileSheets as PNG files.
+* Add 'Reload Project' menu item under File.
+* Fix opening a project to mark an unopenable file as closed in the config file on startup.
+
 # d2025.06.0
 
 * Add ability to remember recent projects in config

src/nostalgia/modules/gfx/include/nostalgia/gfx/consts.hpp

@@ -21,9 +21,28 @@ constexpr ox::Array<ox::StringLiteral, 2> FileExts_TileSheet{
 	FileExt_ng,
 };
 
+constexpr ox::Array<ox::StringLiteral, 2> FileExts_Palette{
+	FileExt_npal,
+};
+
 [[nodiscard]]
 constexpr bool isTileSheet(ox::StringViewCR path) noexcept {
-	return endsWith(path, FileExt_nts) || endsWith(path, FileExt_ng);
+	return ox::any_of(
+		FileExts_TileSheet.begin(),
+		FileExts_TileSheet.end(),
+		[path](ox::StringLiteral const &ext) {
+			return endsWith(path, ext);
+		});
+}
+
+[[nodiscard]]
+constexpr bool isPalette(ox::StringViewCR path) noexcept {
+	return ox::any_of(
+		FileExts_Palette.begin(),
+		FileExts_Palette.end(),
+		[path](ox::StringLiteral const &ext) {
+			return endsWith(path, ext);
+		});
 }
 
 }

src/nostalgia/modules/gfx/include/nostalgia/gfx/gfx.hpp

@@ -238,6 +238,10 @@ void setBgCbb(Context &ctx, unsigned bgIdx, unsigned cbbIdx) noexcept;
 
 void setBgPriority(Context &ctx, uint_t bgIdx, uint_t priority) noexcept;
 
+void setBgOffset(Context &ctx, uint16_t bg, int16_t x, int16_t y) noexcept;
+
+void scrollBgOffset(Context &ctx, uint16_t bg, int16_t x, int16_t y) noexcept;
+
 void hideSprite(Context &ctx, unsigned) noexcept;
 
 void showSprite(Context &ctx, unsigned) noexcept;
@@ -260,8 +264,8 @@ constexpr ox::CStringView GlslVersion = "#version 330";
 [[nodiscard]]
 ox::Size drawSize(int scale = 5) noexcept;
 
-void draw(gfx::Context &ctx, ox::Size const &renderSz) noexcept;
+void draw(Context &ctx, ox::Size const &renderSz) noexcept;
 
-void draw(gfx::Context&, int scale = 5) noexcept;
+void draw(Context&, int scale = 5) noexcept;
 
 }

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

@@ -169,8 +169,8 @@ ox::Error loadBgTileSheet(
 		unsigned const cbb,
 		CompactTileSheet const &ts,
 		ox::Optional<unsigned> const &paletteBank) noexcept {
-	auto const cnt = (ts.pixels.size() * PixelsPerTile) / (1 + (ts.bpp == 4));
-	for (size_t i = 0; i < cnt; ++i) {
+	auto const cnt = ts.pixels.size() >> (ts.bpp == 4);
+	for (size_t i{}; i < cnt; ++i) {
 		auto const srcIdx = i * 2;
 		auto const p1 = static_cast<uint16_t>(ts.pixels[srcIdx]);
 		auto const p2 = static_cast<uint16_t>(ts.pixels[srcIdx + 1]);
@@ -218,10 +218,11 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		CompactTileSheet const &ts,
 		bool const loadDefaultPalette) noexcept {
-	for (size_t i = 0; i < ts.pixels.size(); i += 2) {
-		uint16_t v = ts.pixels[i];
-		v |= static_cast<uint16_t>(ts.pixels[i + 1] << 8);
-		MEM_SPRITE_TILES[i] = v;
+	for (size_t i{}; i < ts.pixels.size(); i += 2) {
+		MEM_SPRITE_TILES[i >> 1] =
+			static_cast<uint16_t>(
+				ts.pixels[i] |
+				(static_cast<uint16_t>(ts.pixels[i + 1]) << 8));
 	}
 	if (loadDefaultPalette && ts.defaultPalette) {
 		OX_RETURN_ERROR(loadSpritePalette(ctx, ts.defaultPalette));
@@ -294,6 +295,14 @@ 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 {
+	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 hideSprite(Context&, unsigned const idx) noexcept {
 	//oxAssert(g_spriteUpdates < config::GbaSpriteBufferLen, "Sprite update buffer overflow");
 	teagba::addSpriteUpdate({

src/nostalgia/modules/gfx/src/gfx.cpp

@@ -249,7 +249,7 @@ void setBgTile(
 }
 
 ox::Error initConsole(Context &ctx) noexcept {
-	constexpr ox::FileAddress TilesheetAddr = ox::StringLiteral("/TileSheets/Charset.ng");
+	constexpr ox::FileAddress TilesheetAddr = ox::StringLiteral("/TileSheets/Charset.nts");
 	constexpr ox::FileAddress PaletteAddr = ox::StringLiteral("/Palettes/Charset.npal");
 	setBgStatus(ctx, 0b0001);
 	setBgCbb(ctx, 0, 0);

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

@@ -72,7 +72,7 @@ PaletteEditorImGui::PaletteEditorImGui(studio::Context &sctx, ox::StringParam pa
 		Editor(sctx, std::move(path)),
 		m_sctx(sctx),
 		m_tctx(sctx.tctx),
-		m_pal(*keel::readObj<Palette>(keelCtx(m_tctx), itemPath()).unwrapThrow()) {
+		m_pal(m_sctx.project->loadObj<Palette>(itemPath()).unwrapThrow()) {
 	undoStack()->changeTriggered.connect(this, &PaletteEditorImGui::handleCommand);
 	m_pageRenameDlg.inputSubmitted.connect(this, &PaletteEditorImGui::renamePage);
 }

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/tilesheeteditormodel.cpp

@@ -49,7 +49,7 @@ TileSheetEditorModel::TileSheetEditorModel(
 		m_sctx{sctx},
 		m_tctx{m_sctx.tctx},
 		m_path{std::move(path)},
-		m_img{*readObj<TileSheet>(keelCtx(m_tctx), m_path).unwrapThrow()},
+		m_img{m_sctx.project->loadObj<TileSheet>(m_path).unwrapThrow()},
 		// ignore failure to load palette
 		m_pal{readObj<Palette>(keelCtx(m_tctx), m_img.defaultPalette).value},
 		m_undoStack{undoStack} {

src/olympic/CMakeLists.txt

@@ -19,6 +19,9 @@ else()
 endif()
 
 add_subdirectory(applib)
+#if(NOT APPLE)
+#    add_subdirectory(hull)
+#endif()
 add_subdirectory(keel)
 add_subdirectory(turbine)
 if(${OLYMPIC_BUILD_STUDIO})

src/olympic/hull/CMakeLists.txt

@@ -0,0 +1,12 @@
+
+add_library(Hull)
+target_sources(
+    Hull PUBLIC
+        FILE_SET CXX_MODULES FILES
+            hull.cpp
+)
+
+target_link_libraries(
+	Hull PUBLIC
+		OxStd
+)

src/olympic/hull/hull.cpp

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2016 - 2025 Gary Talent (gary@drinkingtea.net). All rights reserved.
+ */
+
+module;
+
+#include <ox/std/string.hpp>
+
+export module hull;
+
+namespace hull {
+
+export
+template<typename Str = ox::String, size_t SmallVecSz = 0>
+constexpr ox::Result<ox::Vector<Str, SmallVecSz>> parseCmd(ox::StringViewCR cmd) noexcept
+	requires(ox::is_same_v<Str, ox::String> || ox::is_same_v<Str, ox::StringView>) {
+	auto const tokens = split(cmd, ' ');
+	ox::Vector<Str, SmallVecSz> args;
+	char waitingFor{};
+	auto const handleString = [&waitingFor, &args](
+		ox::StringViewCR token,
+		char const delimiter) {
+		if (endsWith(token, delimiter)) {
+			args.emplace_back(substr(token, 1, token.size() - 1));
+		} else {
+			waitingFor = delimiter;
+			args.emplace_back(substr(token, 1));
+		}
+	};
+	for (auto const &token : tokens) {
+		if (waitingFor) {
+			if (endsWith(token, waitingFor)) {
+				waitingFor = 0;
+			}
+			auto &tgt = *args.back().value;
+			if constexpr (ox::is_same_v<Str, ox::String>) {
+				tgt += substr(token, 0, token.size() - 1);
+			} else {
+				tgt = {tgt.data(), tgt.size() + token.size() - 1};
+			}
+		} else if (beginsWith(token, '"')) {
+			handleString(token, '"');
+		} else if (beginsWith(token, '\'')) {
+			handleString(token, '\'');
+		} else {
+			args.emplace_back(token);
+		}
+	}
+	if (waitingFor) {
+		return ox::Error{1, "unterminated string"};
+	}
+	return args;
+}
+
+template<typename Str = ox::String>
+[[nodiscard]]
+static constexpr bool testParse(ox::StringViewCR cmd, std::initializer_list<ox::StringView> const &expected) noexcept {
+	auto const [args, err] = parseCmd<Str>(cmd);
+	static constexpr auto equals = [](auto const &a, auto const &b) {
+		if (a.size() != b.size()) {
+			return false;
+		}
+		for (auto i = 0u; i < a.size(); ++i) {
+			if (a[i] != b[i]) {
+				return false;
+			}
+		}
+		return true;
+	};
+	return !err && equals(args, ox::Vector(expected));
+}
+
+static_assert(testParse("echo asdf", {"echo", "asdf"}));
+static_assert(testParse<ox::String>("echo asdf", {"echo", "asdf"}));
+
+static_assert(testParse("echo \"asdf\"", {"echo", "asdf"}));
+static_assert(testParse<ox::String>("echo \"asdf\"", {"echo", "asdf"}));
+
+static_assert(testParse("echo 'asdf'", {"echo", "asdf"}));
+static_assert(testParse<ox::String>("echo 'asdf'", {"echo", "asdf"}));
+
+static_assert(testParse("echo 'asdf' aoue", {"echo", "asdf", "aoue"}));
+static_assert(testParse<ox::String>("echo 'asdf' aoue", {"echo", "asdf", "aoue"}));
+
+export class Prompt {
+
+	private:
+		ox::String m_cmd;
+		ox::String m_workingDir{"/"};
+		ox::Vector<ox::String> m_prevCmds;
+
+	public:
+
+	private:
+
+};
+
+}

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(';');
@@ -25,26 +25,25 @@ ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const&uuid) noexce
 
 template<typename T>
 ox::Result<T> readAsset(ox::BufferView buff) noexcept {
-	std::size_t offset = 0;
 	auto const err = readUuidHeader(buff).error;
 	if (!err) {
-		offset = K1HdrSz; // the size of K1 headers
+		buff += K1HdrSz; // the size of K1 headers
 	}
-	auto out = ox::readClaw<T>(buff + offset);
+	auto out = ox::readClaw<T>(buff);
 	OX_RETURN_ERROR(out);
 	OX_RETURN_ERROR(ensureValid(out.value));
 	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

@@ -64,11 +64,13 @@ class AssetContainer {
 
 	protected:
 		constexpr void incRefs() const noexcept {
+			oxAssert(m_references < ox::MaxValue<decltype(m_references)>, "reference count exceeds maximum");
 			++m_references;
 		}
 
 		constexpr void decRefs() const noexcept {
 			--m_references;
+			oxAssert(m_references >= 0, "negative references");
 		}
 
 		[[nodiscard]]
@@ -162,6 +164,7 @@ template<typename T>
 constexpr AssetRef<T>::AssetRef(AssetContainer<T> const*c) noexcept: m_ctr(c) {
 	if (m_ctr) {
 		m_ctr->updated.connect(this, &AssetRef::emitUpdated);
+		m_ctr->incRefs();
 	}
 }
 
@@ -348,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;
@@ -261,6 +261,9 @@ namespace keel {
 ox::Error setRomFs(Context &ctx, ox::UPtr<ox::FileSystem> &&fs, DuplicateSet &duplicateSet) noexcept {
 	ctx.rom = std::move(fs);
 	clearUuidMap(ctx);
+#ifndef OX_BARE_METAL
+	ctx.assetManager.gc();
+#endif
 	return buildUuidMap(ctx, &duplicateSet);
 }
 

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

@@ -25,7 +25,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 	},
 };
 
-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/applib/src/studioui.cpp

@@ -250,6 +250,9 @@ void StudioUI::drawMenu() noexcept {
 			if (ImGui::MenuItem("Open Project...", STUDIO_CTRL "+O")) {
 				m_taskRunner.add(*ox::make<FileDialogManager>(this, &StudioUI::openProjectPath));
 			}
+			if (ImGui::MenuItem("Reload Project")) {
+				oxLogError(openProjectPath(m_project->projectPath()));
+			}
 			if (ImGui::BeginMenu("Recent Projects", m_recentProjects.size() > 1)) {
 				for (size_t i = 1; i < m_recentProjects.size(); ++i) {
 					auto const &p = m_recentProjects[i];
@@ -636,6 +639,9 @@ ox::Error StudioUI::createOpenProject(ox::StringViewCR path) noexcept {
 
 ox::Error StudioUI::openProjectPath(ox::StringParam path) noexcept {
 	OX_REQUIRE_M(fs, keel::loadRomFs(path.view()));
+	m_project.reset();
+	m_openFiles.clear();
+	m_editors.clear();
 	keel::DuplicateSet ds;
 	OX_RETURN_ERROR(keel::setRomFs(keelCtx(m_tctx), std::move(fs), ds));
 	if (ds.size()) {
@@ -649,8 +655,8 @@ ox::Error StudioUI::openProjectPath(ox::StringParam path) noexcept {
 		m_messagePopup.show(msg);
 	}
 	OX_RETURN_ERROR(
-			ox::make_unique_catch<Project>(keelCtx(m_tctx), std::move(path), m_projectDataDir)
-			        .moveTo(m_project));
+		ox::make_unique_catch<Project>(keelCtx(m_tctx), std::move(path), m_projectDataDir)
+				.moveTo(m_project));
 	m_sctx.project = m_project.get();
 	m_activeEditor = nullptr;
 	m_activeEditorOnLastDraw = nullptr;
@@ -665,8 +671,6 @@ ox::Error StudioUI::openProjectPath(ox::StringParam path) noexcept {
 	m_project->dirDeleted.connect(this, &StudioUI::handleDeleteDir);
 	m_project->fileDeleted.connect(this, &StudioUI::handleDeleteFile);
 	m_project->fileMoved.connect(this, &StudioUI::handleMoveFile);
-	m_openFiles.clear();
-	m_editors.clear();
 	studio::editConfig<StudioConfig>(keelCtx(m_tctx), [&](StudioConfig &config) {
 		auto const pcIt = std::find_if(
 			config.projects.begin(), config.projects.end(),

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/include/studio/project.hpp

@@ -189,6 +189,10 @@ ox::Result<T> Project::loadObj(ox::StringViewCR path) const noexcept {
 	if constexpr(ox::is_same_v<T, ox::ModelObject>) {
 		return keel::readAsset(m_typeStore, buff);
 	} else {
+		OX_REQUIRE(typeId, keel::readAssetTypeId(buff));
+		if (typeId != ox::ModelTypeId_v<T>) {
+			return keel::convert<T>(m_kctx, buff);
+		}
 		return keel::readAsset<T>(buff);
 	}
 }

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;