[keel] Cleanup

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/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);
 			}
@@ -421,7 +405,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;

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

@@ -13,11 +13,11 @@ namespace keel {
 
 constexpr auto K1HdrSz = 40;
 
-ox::Result<ox::UUID> readUuidHeader(ox::BufferView buff) noexcept;
+ox::Result<ox::UUID> readUuidHeader(ox::BufferView const &buff) noexcept;
 
 ox::Result<ox::UUID> regenerateUuidHeader(ox::Buffer &buff) noexcept;
 
-ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const&uuid) noexcept {
+ox::Error writeUuidHeader(ox::Writer_c auto &writer, ox::UUID const &uuid) noexcept {
 	OX_RETURN_ERROR(write(writer, "K1;"));
 	OX_RETURN_ERROR(uuid.toString(writer));
 	return writer.put(';');
@@ -35,15 +35,15 @@ ox::Result<T> readAsset(ox::BufferView buff) noexcept {
 	return out;
 }
 
-ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView buff) noexcept;
+ox::Result<ox::ModelObject> readAsset(ox::TypeStore &ts, ox::BufferView const &buff) noexcept;
 
 struct AssetHdr {
 	ox::UUID uuid;
 	ox::ClawHeader clawHdr;
 };
 
-ox::Result<ox::StringView> readAssetTypeId(ox::BufferView buff) noexcept;
+ox::Result<ox::StringView> readAssetTypeId(ox::BufferView const &buff) noexcept;
 
-ox::Result<AssetHdr> readAssetHeader(ox::BufferView buff) noexcept;
+ox::Result<AssetHdr> readAssetHeader(ox::BufferView const &buff) noexcept;
 
 }

src/olympic/keel/include/keel/assetmanager.hpp

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

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

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

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

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

src/olympic/keel/include/keel/module.hpp

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

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

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

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

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

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

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

src/olympic/keel/src/asset.cpp

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

src/olympic/keel/src/keel.cpp

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

src/olympic/keel/src/media.cpp

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

src/olympic/keel/src/module.cpp

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

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

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

src/olympic/keel/src/pack.cpp

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

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