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/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/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,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);
 			}
@@ -287,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);
 
@@ -421,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;
@@ -617,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);
 	}

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/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/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

@@ -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;

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/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;