[keel,studio] Fix hotloading for files that get loaded as multiple types

Also, provide foundation for making file types configurable for default Claw format.

deps/glutils/include/glutils/glutils.hpp

@@ -13,6 +13,7 @@
 #include <ox/std/error.hpp>
 #include <ox/std/size.hpp>
 #include <ox/std/string.hpp>
+#include <ox/std/vec.hpp>
 #include <ox/std/vector.hpp>
 
 namespace glutils {
@@ -137,6 +138,22 @@ struct FrameBuffer {
 	constexpr operator const GLuint&() const noexcept {
 		return fbo.id;
 	}
+
+	[[nodiscard]]
+	constexpr ox::Vec2 sizef() const noexcept {
+		return {
+			static_cast<float>(width),
+			static_cast<float>(height),
+		};
+	}
+
+	[[nodiscard]]
+	constexpr ox::Size size() const noexcept {
+		return {
+			width,
+			height,
+		};
+	}
 };
 
 class FrameBufferBind {

deps/glutils/src/glutils.cpp

@@ -102,7 +102,7 @@ void setupShaderParams(
 		ox::Vector<ShaderVarSet> const&vars,
 		GLsizei vertexRowLen) noexcept {
 	// setup vars
-	for (auto lenWritten = 0LU; auto const&v : vars) {
+	for (size_t lenWritten = 0; auto const&v : vars) {
 		auto const attr = static_cast<GLuint>(glGetAttribLocation(shader, v.name.c_str()));
 		glEnableVertexAttribArray(attr);
 		glVertexAttribPointer(

deps/ox/src/ox/claw/format.hpp

@@ -10,7 +10,7 @@
 
 namespace ox {
 
-enum class ClawFormat: int {
+enum class ClawFormat {
 	None,
 	Metal,
 	Organic,

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

@@ -99,6 +99,21 @@ class FileSystem {
 
 		Result<FileStat> stat(const FileAddress &addr) const noexcept;
 
+		[[nodiscard]]
+		inline bool exists(uint64_t inode) const noexcept {
+			return statInode(inode).ok();
+		}
+
+		[[nodiscard]]
+		inline bool exists(ox::StringView path) const noexcept {
+			return statPath(path).ok();
+		}
+
+		[[nodiscard]]
+		inline bool exists(FileAddress const&addr) const noexcept {
+			return stat(addr).ok();
+		}
+
 		[[nodiscard]]
 		virtual uint64_t spaceNeeded(uint64_t size) const noexcept = 0;
 

deps/ox/src/ox/model/desctypes.hpp

@@ -34,15 +34,16 @@ constexpr auto buildTypeId() noexcept {
 	return ox::sfmt("{};{}", name, version);
 }
 
-static constexpr auto buildTypeId(CRStringView name, int version,
-                                  const TypeParamPack &typeParams = {}) noexcept {
+static constexpr auto buildTypeId(
+		CRStringView name, int version,
+		const TypeParamPack &typeParams = {}) noexcept {
 	String tp;
 	if (!typeParams.empty()) {
 		tp = "#";
 		for (const auto &p : typeParams) {
 			tp += p + ",";
 		}
-		tp.resize(tp.len() - 1);
+		tp.resize(tp.len());
 		tp += "#";
 	}
 	return ox::sfmt("{}{};{}", name, tp, version);

deps/ox/src/ox/preloader/preloader.hpp

@@ -381,8 +381,6 @@ constexpr ox::Error Preloader<PlatSpec>::fieldVector(
 
 template<typename PlatSpec>
 constexpr ox::Error Preloader<PlatSpec>::fieldArray(CRStringView, ox::ModelValueArray const*val) noexcept {
-	oxDebugf("array size: {}", val->size());
-	oxDebugf("array sizeOf: {}", sizeOf<PlatSpec>(val));
 	oxReturnError(pad(&(*val)[0]));
 	for (auto const&v : *val) {
 		oxReturnError(this->interface()->field({}, &v));

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

@@ -96,6 +96,7 @@ install(
 		buildinfo.hpp
 		byteswap.hpp
 		concepts.hpp
+		conv.hpp
 		def.hpp
 		defer.hpp
 		defines.hpp

deps/ox/src/ox/std/bit.hpp

@@ -32,7 +32,7 @@ constexpr To bit_cast(const From &src) noexcept requires(sizeof(To) == sizeof(Fr
 namespace ox {
 
 template<typename To, typename From>
-constexpr typename enable_if<sizeof(To) == sizeof(From), To>::type cbit_cast(From src) noexcept {
+constexpr To cbit_cast(From src) noexcept requires(sizeof(To) == sizeof(From)) {
 	To dst = {};
 	ox::memcpy(&dst, &src, sizeof(src));
 	return dst;

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

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "bit.hpp"
 #include "typetraits.hpp"
 
 namespace ox {
@@ -29,4 +30,6 @@ concept OxString_c = isOxString_v<T>;
 template<typename T>
 concept Integral_c = ox::is_integral_v<T>;
 
+template<typename T, size_t max>
+concept IntegerRange_c = ox::is_integer_v<T> && ox::MaxValue<T> >= max;
 }

deps/ox/src/ox/std/conv.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2015 - 2024 gary@drinkingtea.net
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "point.hpp"
+#include "size.hpp"
+#include "vec.hpp"
+
+namespace ox {
+
+constexpr Vec2::operator Point() const noexcept {
+	return {
+			static_cast<int32_t>(x),
+			static_cast<int32_t>(y),
+	};
+}
+
+constexpr Vec2::operator Size() const noexcept {
+	return {
+			static_cast<int32_t>(x),
+			static_cast<int32_t>(y),
+	};
+}
+
+constexpr Point::operator Vec2() const noexcept {
+	return {
+			static_cast<float>(x),
+			static_cast<float>(y),
+	};
+}
+
+constexpr Size::operator Vec2() const noexcept {
+	return {
+		static_cast<float>(width),
+		static_cast<float>(height),
+	};
+}
+
+}

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

@@ -128,6 +128,10 @@ struct SpanIterator {
 			return operator-=(1);
 		}
 
+		constexpr PtrType operator->() const noexcept {
+			return &m_t[m_offset];
+		}
+
 		constexpr RefType operator*() const noexcept {
 			return m_t[m_offset];
 		}

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

@@ -102,6 +102,7 @@ class MallocaPtr {
 		}
 
 		constexpr ~MallocaPtr() noexcept {
+			m_val->~T();
 			if (m_onHeap && m_val) {
 				delete[] reinterpret_cast<uint8_t*>(m_val);
 			}

deps/ox/src/ox/std/point.hpp

@@ -17,8 +17,8 @@ class Point {
 	public:
 		static constexpr auto TypeName = "net.drinkingtea.ox.Point";
 		static constexpr auto TypeVersion = 1;
-		int x = 0;
-		int y = 0;
+		int32_t x = 0;
+		int32_t y = 0;
 
 		constexpr Point() noexcept = default;
 
@@ -64,6 +64,7 @@ class Point {
 
 		constexpr bool operator!=(const Point&) const noexcept;
 
+		explicit constexpr operator class Vec2() const noexcept;
 };
 
 constexpr Point::Point(int x, int y) noexcept {

deps/ox/src/ox/std/reader.cpp

@@ -8,7 +8,7 @@
 
 
 #ifdef OX_USE_STDLIB
-#include <cstdio>
+#include <istream>
 
 #include "array.hpp"
 #include "reader.hpp"
@@ -16,41 +16,56 @@
 namespace ox {
 
 [[nodiscard]]
-constexpr int sdMap(ox::ios_base::seekdir in) noexcept {
+constexpr std::ios_base::seekdir sdMap(ox::ios_base::seekdir in) noexcept {
 	switch (in) {
 		case ox::ios_base::beg:
-			return SEEK_SET;
+			return std::ios_base::beg;
 		case ox::ios_base::end:
-			return SEEK_END;
+			return std::ios_base::end;
 		case ox::ios_base::cur:
-			return SEEK_CUR;
+			return std::ios_base::cur;
 	}
-	return -1;
+	return std::ios_base::beg;
 }
 
-ox::Result<char> FileReader::peek() const noexcept {
-	auto const c = fgetc(m_file);
-	auto const ok = c != EOF;
-	if (ok && ungetc(c, m_file)) [[unlikely]] {
-		return OxError(1, "Unable to unget character");
+ox::Result<char> StreamReader::peek() const noexcept {
+	try {
+		char c{};
+		m_strm.get(c);
+		auto const ok = c != EOF;
+		if (ok && m_strm.unget()) [[unlikely]] {
+			return OxError(1, "Unable to unget character");
+		}
+		return {static_cast<char>(c), OxError(!ok, "File peek failed")};
+	} catch (std::exception const&) {
+		return OxError(1, "peek failed");
 	}
-	return {static_cast<char>(c), OxError(!ok, "File peek failed")};
 }
 
-ox::Result<std::size_t> FileReader::read(char *v, std::size_t cnt) noexcept {
-	return fread(v, 1, cnt, m_file);
+ox::Result<std::size_t> StreamReader::read(char *v, std::size_t cnt) noexcept {
+	return static_cast<size_t>(m_strm.read(v, static_cast<std::streamsize>(cnt)).gcount());
 }
 
-ox::Error FileReader::seekg(std::size_t p) noexcept {
-	return OxError(fseek(m_file, static_cast<int64_t>(p), SEEK_CUR) != 0);
+ox::Error StreamReader::seekg(std::size_t p) noexcept {
+	try {
+		m_strm.seekg(static_cast<long long int>(p), std::ios_base::cur);
+	} catch (std::exception const&) {
+		return OxError(1, "seekg failed");
+	}
+	return {};
 }
 
-ox::Error FileReader::seekg(int64_t p, ios_base::seekdir sd) noexcept {
-	return OxError(fseek(m_file, p, sdMap(sd)) != 0);
+ox::Error StreamReader::seekg(int64_t p, ios_base::seekdir sd) noexcept {
+	try {
+		m_strm.seekg(p, sdMap(sd));
+	} catch (std::exception const&) {
+		return OxError(1, "seekg failed");
+	}
+	return {};
 }
 
-ox::Result<std::size_t> FileReader::tellg() noexcept {
-	const auto sz = ftell(m_file);
+ox::Result<std::size_t> StreamReader::tellg() noexcept {
+	const auto sz = m_strm.tellg();
 	return {static_cast<std::size_t>(sz), OxError(sz == -1)};
 }
 

deps/ox/src/ox/std/reader.hpp

@@ -9,7 +9,7 @@
 #pragma once
 
 #ifdef OX_USE_STDLIB
-#include <cstdio>
+#include <istream>
 #endif
 
 #include "concepts.hpp"
@@ -65,11 +65,11 @@ class ReaderT: public Reader_v {
 };
 
 #ifdef OX_USE_STDLIB
-class FileReader: public Reader_v {
+class StreamReader: public Reader_v {
 	private:
-		FILE *m_file = nullptr;
+		std::istream &m_strm;
 	public:
-		constexpr explicit FileReader(FILE *file) noexcept: m_file(file) {}
+		constexpr explicit StreamReader(std::istream &stream) noexcept: m_strm(stream) {}
 		ox::Result<char> peek() const noexcept override;
 		ox::Result<std::size_t> read(char *v, std::size_t cnt) noexcept override;
 		ox::Error seekg(std::size_t p) noexcept override;

deps/ox/src/ox/std/size.hpp

@@ -17,8 +17,8 @@ class Size {
 	public:
 		static constexpr auto TypeName = "net.drinkingtea.ox.Size";
 		static constexpr auto TypeVersion = 1;
-		int width = 0;
-		int height = 0;
+		int32_t width = 0;
+		int32_t height = 0;
 
 		constexpr Size() noexcept = default;
 
@@ -64,6 +64,7 @@ class Size {
 
 		constexpr bool operator!=(const Size&) const noexcept;
 
+		explicit constexpr operator class Vec2() const noexcept;
 };
 
 constexpr Size::Size(int width, int height) noexcept {

deps/ox/src/ox/std/smallmap.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "algorithm.hpp"
+#include "def.hpp"
 #include "hash.hpp"
 #include "ignore.hpp"
 #include "stringview.hpp"
@@ -28,7 +28,7 @@ class SmallMap {
 			T value{};
 		};
 
-	private:
+	protected:
 		using PairVector = Vector<Pair, SmallSz>;
 		PairVector m_pairs;
 
@@ -39,8 +39,6 @@ class SmallMap {
 
 		constexpr SmallMap(SmallMap &&other) noexcept;
 
-		constexpr ~SmallMap();
-
 		constexpr bool operator==(SmallMap const&other) const;
 
 		constexpr SmallMap &operator=(SmallMap const&other);
@@ -79,6 +77,11 @@ class SmallMap {
 		[[nodiscard]]
 		constexpr Pair &get(size_t i) noexcept;
 
+		[[nodiscard]]
+		constexpr ox::SpanView<Pair> pairs() const noexcept {
+			return m_pairs;
+		}
+
 		constexpr void clear();
 
 	private:
@@ -100,11 +103,6 @@ constexpr SmallMap<K, T, SmallSz>::SmallMap(SmallMap<K, T, SmallSz> &&other) noe
 	m_pairs = std::move(other.m_pairs);
 }
 
-template<typename K, typename T, size_t SmallSz>
-constexpr SmallMap<K, T, SmallSz>::~SmallMap() {
-	clear();
-}
-
 template<typename K, typename T, size_t SmallSz>
 constexpr bool SmallMap<K, T, SmallSz>::operator==(SmallMap const&other) const {
 	return m_pairs == other.m_pairs;
@@ -204,12 +202,12 @@ constexpr T &SmallMap<K, T, SmallSz>::value(size_t i) noexcept {
 }
 
 template<typename K, typename T, size_t SmallSz>
-constexpr SmallMap<K, T, SmallSz>::Pair const&SmallMap<K, T, SmallSz>::get(size_t i) const noexcept {
+constexpr typename SmallMap<K, T, SmallSz>::Pair const&SmallMap<K, T, SmallSz>::get(size_t i) const noexcept {
 	return m_pairs[i];
 }
 
 template<typename K, typename T, size_t SmallSz>
-constexpr SmallMap<K, T, SmallSz>::Pair &SmallMap<K, T, SmallSz>::get(size_t i) noexcept {
+constexpr typename SmallMap<K, T, SmallSz>::Pair &SmallMap<K, T, SmallSz>::get(size_t i) noexcept {
 	return m_pairs[i];
 }
 
@@ -246,4 +244,12 @@ constexpr typename SmallMap<K, T, SmallSz>::Pair &SmallMap<K, T, SmallSz>::acces
 	return pairs.emplace_back();
 }
 
+template<typename T, typename K, typename V, size_t SmallSz>
+constexpr Error model(T *io, ox::CommonPtrWith<SmallMap<K, V, SmallSz>> auto *obj) noexcept {
+	using Map = SmallMap<K, V, SmallSz>;
+	oxReturnError(io->template setTypeInfo<Map>());
+	oxReturnError(io->field("pairs", &obj->m_pairs));
+	return {};
+}
+
 }

deps/ox/src/ox/std/stacktrace.cpp

@@ -26,7 +26,7 @@
 namespace ox {
 
 #if defined(OX_USE_STDLIB) && __has_include(<unistd.h>)
-[[nodiscard]]
+[[nodiscard]] [[maybe_unused]]
 static auto symbolicate([[maybe_unused]]void **frames,
                         [[maybe_unused]]std::size_t frameCnt,
                         [[maybe_unused]]const char *linePrefix) {

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

@@ -16,6 +16,7 @@
 #include "istring.hpp"
 #include "byteswap.hpp"
 #include "concepts.hpp"
+#include "conv.hpp"
 #include "cstringview.hpp"
 #include "cstrops.hpp"
 #include "def.hpp"

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

@@ -194,6 +194,7 @@ class BasicString {
 
 		constexpr void resize(size_t sz) noexcept {
 			m_buff.resize(sz);
+			m_buff[sz - 1] = 0;
 		}
 
 		[[nodiscard]]

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

@@ -18,12 +18,12 @@
 #include <ox/std/std.hpp>
 
 [[nodiscard]]
-static uint64_t nowMs() {
+static uint64_t steadyNowMs() {
 #if __has_include(<chrono>)
 	using namespace std::chrono;
 	return static_cast<uint64_t>(
 			duration_cast<milliseconds>(
-					system_clock::now().time_since_epoch()).count());
+					steady_clock::now().time_since_epoch()).count());
 #else
 	return 0;
 #endif
@@ -41,13 +41,13 @@ uint64_t timeMapStrToUuid(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	auto const keys = map.keys();
 	ox::Random rand;
 	// start
-	auto const startTime = nowMs();
+	auto const startTime = steadyNowMs();
 	for (int i = 0; i < lookups; ++i) {
 		auto const&k = keys[rand.gen() % keys.size()];
 		map[k];
 		oxExpect(map[k], ox::UUID::fromString(k).unwrap());
 	}
-	return nowMs() - startTime;
+	return steadyNowMs() - startTime;
 }
 
 template<typename Map = ox::SmallMap<ox::UUID, ox::String>>
@@ -62,16 +62,16 @@ uint64_t timeMapUuidToStr(int elemCnt, int lookups, uint64_t seed = 4321) noexce
 	auto const keys = map.keys();
 	ox::Random rand;
 	// start
-	auto const startTime = nowMs();
+	auto const startTime = steadyNowMs();
 	for (int i = 0; i < lookups; ++i) {
 		auto const&k = keys[rand.gen() % keys.size()];
 		oxExpect(map[k], k.toString());
 	}
-	return nowMs() - startTime;
+	return steadyNowMs() - startTime;
 }
 
 static ox::Error compareMaps(int lookupCnt = 1'000'000) {
-	auto const seed = nowMs();
+	auto const seed = steadyNowMs();
 	uint64_t hashTime{};
 	uint64_t smallTime{};
 	int elemCnt = 1;

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

@@ -185,6 +185,8 @@ struct enable_if<true, T> {
 	using type = T;
 };
 
+template<bool B, typename T>
+using enable_if_t = typename enable_if<B, T>::type;
 
 template<typename T>
 struct is_pointer {

deps/ox/src/ox/std/vec.hpp

@@ -23,17 +23,16 @@
 
 namespace ox {
 
-template<typename T>
-struct Vec {
+class Vec2 {
 	public:
-		using value_type = T;
+		using value_type = float;
 		using size_type = std::size_t;
 
 		static constexpr auto TypeName = "net.drinkingtea.ox.Point";
 		static constexpr auto TypeVersion = 1;
 
-		T x = 0;
-		T y = 0;
+		float x = 0;
+		float y = 0;
 
 		template<typename RefType = value_type&, typename PtrType = value_type*, bool reverse = false>
 		struct iterator: public ox::Iterator<std::bidirectional_iterator_tag, value_type> {
@@ -141,14 +140,14 @@ struct Vec {
 
 		};
 
-		constexpr Vec() noexcept = default;
+		constexpr Vec2() noexcept = default;
 
 		template<typename ...Args>
-		constexpr Vec(T pX, T pY) noexcept: x(pX), y(pY) {
+		constexpr Vec2(float pX, float pY) noexcept: x(pX), y(pY) {
 		}
 
 #if __has_include(<imgui.h>)
-		explicit constexpr Vec(const ImVec2 &v) noexcept: Vec(v.x, v.y) {
+		explicit constexpr Vec2(const ImVec2 &v) noexcept: Vec2(v.x, v.y) {
 		}
 
 		explicit inline operator ImVec2() const noexcept {
@@ -228,7 +227,7 @@ struct Vec {
 			}
 		}
 
-		constexpr auto operator==(const Vec &v) const noexcept {
+		constexpr auto operator==(const Vec2 &v) const noexcept {
 			for (auto i = 0u; i < v.size(); ++i) {
 				if ((*this)[i] != v[i]) {
 					return false;
@@ -237,29 +236,71 @@ struct Vec {
 			return true;
 		}
 
-		constexpr auto operator!=(const Vec &v) const noexcept {
+		constexpr auto operator!=(const Vec2 &v) const noexcept {
 			return !operator==(v);
 		}
 
+		explicit constexpr operator class Point() const noexcept;
+
+		explicit constexpr operator class Size() const noexcept;
+
 		[[nodiscard]]
 		constexpr std::size_t size() const noexcept {
 			return 2;
 		}
 
+		constexpr Vec2 operator+(float i) const noexcept {
+			return {x + i, y + i};
+		}
+
+		constexpr Vec2 operator+=(float i) noexcept {
+			x += i;
+			y += i;
+			return *this;
+		}
+
+		constexpr Vec2 operator-(float i) const noexcept {
+			return {x - i, y - i};
+		}
+
+		constexpr Vec2 operator-=(float i) noexcept {
+			x -= i;
+			y -= i;
+			return *this;
+		}
+
+		constexpr Vec2 operator*(float i) const noexcept {
+			return {x * i, y * i};
+		}
+
+		constexpr Vec2 operator*=(float i) noexcept {
+			x *= i;
+			y *= i;
+			return *this;
+		}
+
+		constexpr Vec2 operator/(float i) const noexcept {
+			return {x / i, y / i};
+		}
+
+		constexpr Vec2 operator/=(float i) noexcept {
+			x /= i;
+			y /= i;
+			return *this;
+		}
+
 	protected:
 		[[nodiscard]]
-		constexpr T *start() noexcept {
-			return &x;
+		constexpr float *start() noexcept {
+			return&x;
 		}
 
 		[[nodiscard]]
-		constexpr const T *start() const noexcept {
+		constexpr const float *start() const noexcept {
 			return &x;
 		}
 };
 
-using Vec2 = Vec<float>;
-
 template<typename T>
 constexpr Error model(T *io, ox::CommonPtrWith<Vec2> auto *obj) noexcept {
 	oxReturnError(io->template setTypeInfo<Vec2>());

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

@@ -271,7 +271,7 @@ class Vector: detail::VectorAllocator<T, Allocator, SmallVectorSize> {
 		constexpr bool contains(MaybeView_t<T> const&) const noexcept;
 
 		constexpr iterator<T&, T*, false> insert(
-				std::size_t pos, std::size_t cnt, T val) noexcept(useNoexcept);
+				std::size_t pos, std::size_t cnt, T const&val) noexcept(useNoexcept);
 
 		constexpr iterator<T&, T*, false> insert(std::size_t pos, T val) noexcept(useNoexcept);
 
@@ -531,29 +531,23 @@ constexpr bool Vector<T, SmallVectorSize, Allocator>::contains(MaybeView_t<T> co
 template<typename T, std::size_t SmallVectorSize, typename Allocator>
 constexpr typename Vector<T, SmallVectorSize, Allocator>::template iterator<T&, T*, false>
 Vector<T, SmallVectorSize, Allocator>::insert(
-		std::size_t pos, std::size_t cnt, T val) noexcept(useNoexcept) {
+		std::size_t pos, std::size_t cnt, T const&val) noexcept(useNoexcept) {
 	if (m_size + cnt > m_cap) {
 		reserveInsert(m_cap ? m_size + cnt : initialCap, pos, cnt);
-		if (pos < m_size) {
-			m_items[pos] = std::move(val);
-		} else {
-			for (auto i = 0u; i < cnt; ++i) {
-				std::construct_at(&m_items[pos + i], m_items[pos]);
-			}
+	}
+	if (pos < m_size) {
+		for (auto i = m_size + cnt - 1; i > pos; --i) {
+			std::construct_at(&m_items[i], std::move(m_items[i - cnt]));
+		}
+		for (auto i = pos; i < pos + cnt; ++i) {
+			m_items[i] = val;
 		}
 	} else {
-		if (pos < m_size) {
-			for (auto i = m_size + cnt - 1; i > pos; --i) {
-				std::construct_at(&m_items[i], std::move(m_items[i - cnt]));
-			}
-			m_items[pos] = std::move(val);
-		} else {
-			for (auto i = 0u; i < cnt; ++i) {
-				std::construct_at(&m_items[pos + i], m_items[pos]);
-			}
+		for (auto i = 0u; i < cnt; ++i) {
+			std::construct_at(&m_items[pos + i], m_items[pos]);
 		}
 	}
-	++m_size;
+	m_size += cnt;
 	return begin() + pos;
 }
 
@@ -562,20 +556,14 @@ constexpr typename Vector<T, SmallVectorSize, Allocator>::template iterator<T&,
 Vector<T, SmallVectorSize, Allocator>::insert(std::size_t pos, T val) noexcept(useNoexcept) {
 	if (m_size == m_cap) {
 		reserveInsert(m_cap ? m_cap * 2 : initialCap, pos);
-		if (pos < m_size) {
-			m_items[pos] = std::move(val);
-		} else {
-			std::construct_at(&m_items[pos], m_items[pos]);
+	}
+	if (pos < m_size) {
+		for (auto i = m_size; i > pos; --i) {
+			std::construct_at(&m_items[i], std::move(m_items[i - 1]));
 		}
+		m_items[pos] = std::move(val);
 	} else {
-		if (pos < m_size) {
-			for (auto i = m_size; i > pos; --i) {
-				std::construct_at(&m_items[i], std::move(m_items[i - 1]));
-			}
-			m_items[pos] = std::move(val);
-		} else {
-			std::construct_at(&m_items[pos], m_items[pos]);
-		}
+		std::construct_at(&m_items[pos], std::move(val));
 	}
 	++m_size;
 	return begin() + pos;

src/nostalgia/modules/core/include/nostalgia/core/color.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <ox/std/math.hpp>
 #include <ox/std/types.hpp>
 
 namespace nostalgia::core {
@@ -135,7 +136,7 @@ constexpr Color16 color16(int r, int g, int b, int a = 0) noexcept {
 	return static_cast<Color16>(ox::min<uint8_t>(static_cast<uint8_t>(r), 31))
 	     | static_cast<Color16>(ox::min<uint8_t>(static_cast<uint8_t>(g), 31) << 5)
 	     | static_cast<Color16>(ox::min<uint8_t>(static_cast<uint8_t>(b), 31) << 10)
-        | static_cast<Color16>(a << 15);
+         | static_cast<Color16>(a << 15);
 }
 
 [[nodiscard]]
@@ -151,4 +152,13 @@ static_assert(color16(16, 31, 0) == 1008);
 static_assert(color16(16, 31, 8) == 9200);
 static_assert(color16(16, 32, 8) == 9200);
 
+[[nodiscard]]
+constexpr Color16 applySelectionColor(Color16 const color) noexcept {
+	namespace core = nostalgia::core;
+	auto const r = core::red16(color) / 2;
+	auto const g = (core::green16(color) + 20) / 2;
+	auto const b = (core::blue16(color) + 31) / 2;
+	return core::color16(r, g, b);
+}
+
 }

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

@@ -103,6 +103,12 @@ oxModelEnd()
 
 void addEntry(TileSheetSet &set, ox::FileAddress path, int32_t begin = 0, int32_t size = -1) noexcept;
 
+[[nodiscard]]
+int tileColumns(Context&) noexcept;
+
+[[nodiscard]]
+int tileRows(Context&) noexcept;
+
 ox::Error loadBgPalette(
 		Context &ctx,
 		size_t palBank,

src/nostalgia/modules/core/include/nostalgia/core/tilesheet.hpp

@@ -222,6 +222,14 @@ ox::Error setPixelCount(TileSheet::SubSheet &ss, int8_t pBpp, std::size_t cnt) n
 [[nodiscard]]
 unsigned pixelCnt(TileSheet::SubSheet const&ss, int8_t pBpp) noexcept;
 
+/**
+ *
+ * @param ss
+ * @param pBpp
+ * @param sz size of Subsheet in tiles (not pixels)
+ */
+ox::Error resizeSubsheet(TileSheet::SubSheet &ss, int8_t pBpp, ox::Size const&sz) noexcept;
+
 /**
  * validateSubSheetIdx takes a SubSheetIdx and moves the index to the
  * preceding or parent sheet if the current corresponding sheet does

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

@@ -22,8 +22,6 @@
 
 namespace nostalgia::core {
 
-constexpr auto GbaTileColumns = 32;
-constexpr auto GbaTileRows = 32;
 constexpr auto SpriteCount = 128;
 
 struct GbaTileMapTarget {
@@ -284,8 +282,8 @@ ox::Error loadSpriteTileSheet(
 	return {};
 }
 
-void setBgTile(Context&, uint_t bgIdx, int column, int row, BgTile const&tile) noexcept {
-	auto const tileIdx = static_cast<std::size_t>(row * GbaTileColumns + column);
+void setBgTile(Context &ctx, uint_t bgIdx, int column, int row, BgTile const&tile) noexcept {
+	auto const tileIdx = static_cast<std::size_t>(row * tileColumns(ctx) + column);
 	// see Tonc 9.3
 	MEM_BG_MAP[bgIdx][tileIdx] =
 			static_cast<uint16_t>(tile.tileIdx & 0b1'1111'1111) |
@@ -294,8 +292,8 @@ void setBgTile(Context&, uint_t bgIdx, int column, int row, BgTile const&tile) n
 			static_cast<uint16_t>(tile.palBank << 0xc);
 }
 
-void clearBg(Context&, uint_t bgIdx) noexcept {
-	memset(MEM_BG_MAP[bgIdx].data(), 0, GbaTileRows * GbaTileColumns);
+void clearBg(Context &ctx, uint_t bgIdx) noexcept {
+	memset(MEM_BG_MAP[bgIdx].data(), 0, static_cast<size_t>(tileRows(ctx) * tileColumns(ctx)));
 }
 
 uint8_t bgStatus(Context&) noexcept {

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

@@ -6,6 +6,17 @@
 
 namespace nostalgia::core {
 
+constexpr auto GbaTileColumns = 32;
+constexpr auto GbaTileRows = 32;
+
+int tileColumns(Context&) noexcept {
+	return GbaTileColumns;
+}
+
+int tileRows(Context&) noexcept {
+	return GbaTileRows;
+}
+
 // map ASCII values to the nostalgia charset
 constexpr ox::Array<char, 128> charMap = {
 	0,

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

@@ -385,7 +385,8 @@ static void setSprite(
 		uint_t const idx,
 		Sprite const&s) noexcept {
 	// Tonc Table 8.4
-	static constexpr ox::Array<ox::Vec<uint_t>, 12> dimensions{
+	struct Sz { uint_t x{}, y{}; };
+	static constexpr ox::Array<Sz, 12> dimensions{
 			// col 0
 			{1, 1}, // 0, 0
 			{2, 2}, // 0, 1

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

@@ -79,13 +79,13 @@ void PaletteEditorImGui::drawColorsEditor() noexcept {
 		if (ImGui::Button("Add", sz)) {
 			auto const colorSz = static_cast<int>(colors(m_pal, m_page));
 			constexpr Color16 c = 0;
-			undoStack()->push(ox::make_unique<AddColorCommand>(&m_pal, c, m_page, colorSz));
+			std::ignore = undoStack()->push(ox::make_unique<AddColorCommand>(&m_pal, c, m_page, colorSz));
 		}
 		ImGui::SameLine();
 		ImGui::BeginDisabled(m_selectedColorRow >= colors(m_pal, m_page));
 		{
 			if (ImGui::Button("Remove", sz)) {
-				undoStack()->push(
+				std::ignore = undoStack()->push(
 						ox::make_unique<RemoveColorCommand>(
 								&m_pal,
 								color(m_pal, m_page, static_cast<std::size_t>(m_selectedColorRow)),
@@ -97,7 +97,7 @@ void PaletteEditorImGui::drawColorsEditor() noexcept {
 			ImGui::BeginDisabled(m_selectedColorRow <= 0);
 			{
 				if (ImGui::Button("Move Up", sz)) {
-					undoStack()->push(ox::make_unique<MoveColorCommand>(&m_pal, m_page, m_selectedColorRow, -1));
+					std::ignore = undoStack()->push(ox::make_unique<MoveColorCommand>(&m_pal, m_page, m_selectedColorRow, -1));
 					--m_selectedColorRow;
 				}
 			}
@@ -106,7 +106,7 @@ void PaletteEditorImGui::drawColorsEditor() noexcept {
 			ImGui::BeginDisabled(m_selectedColorRow >= colors(m_pal, m_page) - 1);
 			{
 				if (ImGui::Button("Move Down", sz)) {
-					undoStack()->push(ox::make_unique<MoveColorCommand>(&m_pal, m_page, m_selectedColorRow, 1));
+					std::ignore = undoStack()->push(ox::make_unique<MoveColorCommand>(&m_pal, m_page, m_selectedColorRow, 1));
 					++m_selectedColorRow;
 				}
 			}
@@ -155,17 +155,17 @@ void PaletteEditorImGui::drawPagesEditor() noexcept {
 	constexpr auto toolbarHeight = 40;
 	auto const btnSz = ImVec2(paneSz.x / 3 - 5.5f, 24);
 	if (ImGui::Button("Add", btnSz)) {
-		undoStack()->push(ox::make_unique<AddPageCommand>(m_pal));
+		std::ignore = undoStack()->push(ox::make_unique<AddPageCommand>(m_pal));
 		m_page = m_pal.pages.size() - 1;
 	}
 	ImGui::SameLine();
 	if (ImGui::Button("Remove", btnSz)) {
-		undoStack()->push(ox::make_unique<RemovePageCommand>(m_pal, m_page));
+		std::ignore = undoStack()->push(ox::make_unique<RemovePageCommand>(m_pal, m_page));
 		m_page = std::min(m_page, m_pal.pages.size() - 1);
 	}
 	ImGui::SameLine();
 	if (ImGui::Button("Duplicate", btnSz)) {
-		undoStack()->push(ox::make_unique<DuplicatePageCommand>(m_pal, m_page, m_pal.pages.size()));
+		std::ignore = undoStack()->push(ox::make_unique<DuplicatePageCommand>(m_pal, m_page, m_pal.pages.size()));
 	}
 	ImGui::BeginTable("PageSelect", 2, tableFlags, ImVec2(paneSz.x, paneSz.y - (toolbarHeight + 5)));
 	{
@@ -198,7 +198,7 @@ void PaletteEditorImGui::drawColorEditor() noexcept {
 	ImGui::InputInt("Blue", &b, 1, 5);
 	auto const newColor = color16(r, g, b, a);
 	if (c != newColor) {
-		undoStack()->push(ox::make_unique<UpdateColorCommand>(
+		std::ignore = undoStack()->push(ox::make_unique<UpdateColorCommand>(
 				&m_pal, m_page, static_cast<int>(m_selectedColorRow), c, newColor));
 	}
 }

src/nostalgia/modules/core/src/studio/paletteeditor/paletteeditor.cpp

@@ -14,12 +14,13 @@ int AddPageCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::AddPage);
 }
 
-void AddPageCommand::redo() noexcept {
+ox::Error AddPageCommand::redo() noexcept {
 	m_pal.pages.emplace_back();
+	return {};
 }
 
-void AddPageCommand::undo() noexcept {
-	std::ignore = m_pal.pages.erase(static_cast<std::size_t>(m_pal.pages.size() - 1));
+ox::Error AddPageCommand::undo() noexcept {
+	return m_pal.pages.erase(static_cast<std::size_t>(m_pal.pages.size() - 1)).error;
 }
 
 
@@ -37,13 +38,14 @@ int DuplicatePageCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::DuplicatePage);
 }
 
-void DuplicatePageCommand::redo() noexcept {
+ox::Error DuplicatePageCommand::redo() noexcept {
 	m_pal.pages.emplace(m_dstIdx, std::move(m_page));
+	return {};
 }
 
-void DuplicatePageCommand::undo() noexcept {
+ox::Error DuplicatePageCommand::undo() noexcept {
 	m_page = std::move(m_pal.pages[m_dstIdx]);
-	std::ignore = m_pal.pages.erase(static_cast<std::size_t>(m_dstIdx));
+	return m_pal.pages.erase(static_cast<std::size_t>(m_dstIdx)).error;
 }
 
 size_t DuplicatePageCommand::insertIdx() const noexcept {
@@ -60,13 +62,14 @@ int RemovePageCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::RemovePage);
 }
 
-void RemovePageCommand::redo() noexcept {
+ox::Error RemovePageCommand::redo() noexcept {
 	m_page = std::move(m_pal.pages[m_idx]);
-	std::ignore = m_pal.pages.erase(static_cast<std::size_t>(m_idx));
+	return m_pal.pages.erase(static_cast<std::size_t>(m_idx)).error;
 }
 
-void RemovePageCommand::undo() noexcept {
+ox::Error RemovePageCommand::undo() noexcept {
 	m_pal.pages.insert(m_idx, std::move(m_page));
+	return {};
 }
 
 
@@ -81,12 +84,13 @@ int AddColorCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::AddColor);
 }
 
-void AddColorCommand::redo() noexcept {
+ox::Error AddColorCommand::redo() noexcept {
 	m_pal->pages[m_page].insert(static_cast<std::size_t>(m_idx), m_color);
+	return {};
 }
 
-void AddColorCommand::undo() noexcept {
-	std::ignore = m_pal->pages[m_page].erase(static_cast<std::size_t>(m_idx));
+ox::Error AddColorCommand::undo() noexcept {
+	return m_pal->pages[m_page].erase(static_cast<std::size_t>(m_idx)).error;
 }
 
 
@@ -101,12 +105,13 @@ int RemoveColorCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::RemoveColor);
 }
 
-void RemoveColorCommand::redo() noexcept {
-	std::ignore = m_pal->pages[m_page].erase(static_cast<std::size_t>(m_idx));
+ox::Error RemoveColorCommand::redo() noexcept {
+	return m_pal->pages[m_page].erase(static_cast<std::size_t>(m_idx)).error;
 }
 
-void RemoveColorCommand::undo() noexcept {
-m_pal->pages[m_page].insert(static_cast<std::size_t>(m_idx), m_color);
+ox::Error RemoveColorCommand::undo() noexcept {
+	m_pal->pages[m_page].insert(static_cast<std::size_t>(m_idx), m_color);
+	return {};
 }
 
 
@@ -124,11 +129,11 @@ UpdateColorCommand::UpdateColorCommand(
 	//setObsolete(m_oldColor == m_newColor);
 }
 
-bool UpdateColorCommand::mergeWith(const UndoCommand *cmd) noexcept {
-	if (cmd->commandId() != static_cast<int>(PaletteEditorCommandId::UpdateColor)) {
+bool UpdateColorCommand::mergeWith(UndoCommand const&cmd) noexcept {
+	if (cmd.commandId() != static_cast<int>(PaletteEditorCommandId::UpdateColor)) {
 		return false;
 	}
-	auto ucCmd = static_cast<const UpdateColorCommand*>(cmd);
+	auto ucCmd = static_cast<UpdateColorCommand const*>(&cmd);
 	if (m_idx != ucCmd->m_idx) {
 		return false;
 	}
@@ -141,12 +146,14 @@ int UpdateColorCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::UpdateColor);
 }
 
-void UpdateColorCommand::redo() noexcept {
+ox::Error UpdateColorCommand::redo() noexcept {
 	m_pal->pages[m_page][static_cast<std::size_t>(m_idx)] = m_newColor;
+	return {};
 }
 
-void UpdateColorCommand::undo() noexcept {
+ox::Error UpdateColorCommand::undo() noexcept {
 	m_pal->pages[m_page][static_cast<std::size_t>(m_idx)] = m_oldColor;
+	return {};
 }
 
 
@@ -161,12 +168,14 @@ int MoveColorCommand::commandId() const noexcept {
 	return static_cast<int>(PaletteEditorCommandId::MoveColor);
 }
 
-void MoveColorCommand::redo() noexcept {
+ox::Error MoveColorCommand::redo() noexcept {
 	moveColor(static_cast<int>(m_idx), m_offset);
+	return {};
 }
 
-void MoveColorCommand::undo() noexcept {
+ox::Error MoveColorCommand::undo() noexcept {
 	moveColor(static_cast<int>(m_idx) + m_offset, -m_offset);
+	return {};
 }
 
 void MoveColorCommand::moveColor(int idx, int offset) noexcept {

src/nostalgia/modules/core/src/studio/paletteeditor/paletteeditor.hpp

@@ -35,9 +35,9 @@ class AddPageCommand: public studio::UndoCommand {
 		[[nodiscard]]
 		int commandId() const noexcept final;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 };
 
@@ -55,9 +55,9 @@ class DuplicatePageCommand: public studio::UndoCommand {
 		[[nodiscard]]
 		int commandId() const noexcept final;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		size_t insertIdx() const noexcept;
@@ -78,9 +78,9 @@ class RemovePageCommand: public studio::UndoCommand {
 		[[nodiscard]]
 		int commandId() const noexcept final;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 };
 
@@ -99,9 +99,9 @@ class AddColorCommand: public studio::UndoCommand {
 		[[nodiscard]]
 		int commandId() const noexcept override;
 
-		void redo() noexcept override;
+		ox::Error redo() noexcept override;
 
-		void undo() noexcept override;
+		ox::Error undo() noexcept override;
 
 };
 
@@ -120,9 +120,9 @@ class RemoveColorCommand: public studio::UndoCommand {
 		[[nodiscard]]
 		int commandId() const noexcept override;
 
-		void redo() noexcept override;
+		ox::Error redo() noexcept override;
 
-		void undo() noexcept override;
+		ox::Error undo() noexcept override;
 
 };
 
@@ -140,14 +140,14 @@ class UpdateColorCommand: public studio::UndoCommand {
 		~UpdateColorCommand() noexcept override = default;
 
 		[[nodiscard]]
-		bool mergeWith(const UndoCommand *cmd) noexcept final;
+		bool mergeWith(const UndoCommand &cmd) noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 };
 
@@ -167,9 +167,9 @@ class MoveColorCommand: public studio::UndoCommand {
 		int commandId() const noexcept override;
 
 	public:
-		void redo() noexcept override;
+		ox::Error redo() noexcept override;
 
-		void undo() noexcept override;
+		ox::Error undo() noexcept override;
 
 	private:
 		void moveColor(int idx, int offset) noexcept;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/addsubsheetcommand.cpp

@@ -24,7 +24,7 @@ AddSubSheetCommand::AddSubSheetCommand(
 	}
 }
 
-void AddSubSheetCommand::redo() noexcept {
+ox::Error AddSubSheetCommand::redo() noexcept {
 	auto &parent = getSubSheet(m_img, m_parentIdx);
 	if (m_addedSheets.size() < 2) {
 		auto i = parent.subsheets.size();
@@ -35,9 +35,10 @@ void AddSubSheetCommand::redo() noexcept {
 		parent.columns = 0;
 		parent.subsheets.emplace_back(m_img.idIt++, "Subsheet 1", 1, 1, m_img.bpp);
 	}
+	return {};
 }
 
-void AddSubSheetCommand::undo() noexcept {
+ox::Error AddSubSheetCommand::undo() noexcept {
 	auto &parent = getSubSheet(m_img, m_parentIdx);
 	if (parent.subsheets.size() == 2) {
 		auto s = parent.subsheets[0];
@@ -47,9 +48,10 @@ void AddSubSheetCommand::undo() noexcept {
 		parent.subsheets.clear();
 	} else {
 		for (auto idx = m_addedSheets.rbegin(); idx != m_addedSheets.rend(); ++idx) {
-			oxLogError(rmSubSheet(m_img, *idx));
+			oxReturnError(rmSubSheet(m_img, *idx));
 		}
 	}
+	return {};
 }
 
 int AddSubSheetCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/addsubsheetcommand.hpp

@@ -17,9 +17,9 @@ class AddSubSheetCommand: public TileSheetCommand {
 	public:
 		AddSubSheetCommand(TileSheet &img, TileSheet::SubSheetIdx parentIdx) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/cutpastecommand.cpp

@@ -41,18 +41,20 @@ CutPasteCommand::CutPasteCommand(
 	}
 }
 
-void CutPasteCommand::redo() noexcept {
+ox::Error CutPasteCommand::redo() noexcept {
 	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
 		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.newPalIdx));
 	}
+	return {};
 }
 
-void CutPasteCommand::undo() noexcept {
+ox::Error CutPasteCommand::undo() noexcept {
 	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
 		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
 	}
+	return {};
 }
 
 int CutPasteCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/cutpastecommand.hpp

@@ -69,9 +69,9 @@ class CutPasteCommand: public TileSheetCommand {
 				ox::Point const&dstEnd,
 				TileSheetClipboard const&cb) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/deletetilescommand.cpp

@@ -28,7 +28,7 @@ core::DeleteTilesCommand::DeleteTilesCommand(
 	}
 }
 
-void core::DeleteTilesCommand::redo() noexcept {
+ox::Error core::DeleteTilesCommand::redo() noexcept {
 	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	auto srcPos = m_deletePos + m_deleteSz;
@@ -37,9 +37,10 @@ void core::DeleteTilesCommand::redo() noexcept {
 	const auto dst2 = p.data() + (p.size() - m_deleteSz);
 	ox::memmove(dst1, src, p.size() - srcPos);
 	ox::memset(dst2, 0, m_deleteSz * sizeof(decltype(p[0])));
+	return {};
 }
 
-void DeleteTilesCommand::undo() noexcept {
+ox::Error DeleteTilesCommand::undo() noexcept {
 	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	const auto src = p.data() + m_deletePos;
@@ -48,6 +49,7 @@ void DeleteTilesCommand::undo() noexcept {
 	const auto sz = p.size() - m_deletePos - m_deleteSz;
 	ox::memmove(dst1, src, sz);
 	ox::memcpy(dst2, m_deletedPixels.data(), m_deletedPixels.size());
+	return {};
 }
 
 int DeleteTilesCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/deletetilescommand.hpp

@@ -23,9 +23,9 @@ class DeleteTilesCommand: public TileSheetCommand {
 				std::size_t tileIdx,
 				std::size_t tileCnt) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/drawcommand.cpp

@@ -56,18 +56,20 @@ bool DrawCommand::append(const ox::Vector<std::size_t> &idxList) noexcept {
 	return out;
 }
 
-void DrawCommand::redo() noexcept {
+ox::Error DrawCommand::redo() noexcept {
 	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
 		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(m_palIdx));
 	}
+	return {};
 }
 
-void DrawCommand::undo() noexcept {
+ox::Error DrawCommand::undo() noexcept {
 	auto &subsheet = getSubSheet(m_img, m_subSheetIdx);
 	for (const auto &c : m_changes) {
 		setPixel(subsheet, m_img.bpp, c.idx, static_cast<uint8_t>(c.oldPalIdx));
 	}
+	return {};
 }
 
 int DrawCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/drawcommand.hpp

@@ -40,9 +40,9 @@ class DrawCommand: public TileSheetCommand {
 
 		bool append(const ox::Vector<std::size_t> &idxList) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/inserttilescommand.cpp

@@ -28,7 +28,7 @@ core::InsertTilesCommand::InsertTilesCommand(
 	}
 }
 
-void InsertTilesCommand::redo() noexcept {
+ox::Error InsertTilesCommand::redo() noexcept {
 	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	auto dstPos = m_insertPos + m_insertCnt;
@@ -36,9 +36,10 @@ void InsertTilesCommand::redo() noexcept {
 	const auto src = p.data() + m_insertPos;
 	ox::memmove(dst, src, p.size() - dstPos);
 	ox::memset(src, 0, m_insertCnt * sizeof(decltype(p[0])));
+	return {};
 }
 
-void InsertTilesCommand::undo() noexcept {
+ox::Error InsertTilesCommand::undo() noexcept {
 	auto &s = getSubSheet(m_img, m_idx);
 	auto &p = s.pixels;
 	const auto srcIdx = m_insertPos + m_insertCnt;
@@ -48,6 +49,7 @@ void InsertTilesCommand::undo() noexcept {
 	const auto sz = p.size() - srcIdx;
 	ox::memmove(dst1, src, sz);
 	ox::memcpy(dst2, m_deletedPixels.data(), m_deletedPixels.size());
+	return {};
 }
 
 int InsertTilesCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/inserttilescommand.hpp

@@ -23,9 +23,9 @@ class InsertTilesCommand: public TileSheetCommand {
 				std::size_t tileIdx,
 				std::size_t tileCnt) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/palettechangecommand.cpp

@@ -16,12 +16,14 @@ core::PaletteChangeCommand::PaletteChangeCommand(
 		m_newPalette(ox::FileAddress(ox::sfmt<ox::IString<43>>("uuid://{}", newPalette))) {
 }
 
-void PaletteChangeCommand::redo() noexcept {
+ox::Error PaletteChangeCommand::redo() noexcept {
 	m_img.defaultPalette = m_newPalette;
+	return {};
 }
 
-void PaletteChangeCommand::undo() noexcept {
+ox::Error PaletteChangeCommand::undo() noexcept {
 	m_img.defaultPalette = m_oldPalette;
+	return {};
 }
 
 int PaletteChangeCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/palettechangecommand.hpp

@@ -21,9 +21,9 @@ class PaletteChangeCommand: public TileSheetCommand {
 				TileSheet &img,
 				ox::CRStringView newPalette) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/rmsubsheetcommand.cpp

@@ -11,19 +11,20 @@ core::RmSubSheetCommand::RmSubSheetCommand(TileSheet &img, TileSheet::SubSheetId
 		m_idx(std::move(idx)),
 		m_parentIdx(m_idx) {
 	m_parentIdx.pop_back();
-	auto &parent = getSubSheet(m_img, m_parentIdx);
-	m_sheet = parent.subsheets[*m_idx.back().value];
 }
 
-void RmSubSheetCommand::redo() noexcept {
+ox::Error RmSubSheetCommand::redo() noexcept {
 	auto &parent = getSubSheet(m_img, m_parentIdx);
-	oxLogError(parent.subsheets.erase(*m_idx.back().value).error);
+	m_sheet = std::move(parent.subsheets[*m_idx.back().value]);
+	oxReturnError(parent.subsheets.erase(*m_idx.back().value).error);
+	return {};
 }
 
-void RmSubSheetCommand::undo() noexcept {
+ox::Error RmSubSheetCommand::undo() noexcept {
 	auto &parent = getSubSheet(m_img, m_parentIdx);
-	auto i = *m_idx.back().value;
-	parent.subsheets.insert(i, m_sheet);
+	auto const i = *m_idx.back().value;
+	parent.subsheets.insert(i, std::move(m_sheet));
+	return {};
 }
 
 int RmSubSheetCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/rmsubsheetcommand.hpp

@@ -18,9 +18,9 @@ class RmSubSheetCommand: public TileSheetCommand {
 	public:
 		RmSubSheetCommand(TileSheet &img, TileSheet::SubSheetIdx idx) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/updatesubsheetcommand.cpp

@@ -20,17 +20,17 @@ core::UpdateSubSheetCommand::UpdateSubSheetCommand(
 		m_newRows(rows) {
 }
 
-void UpdateSubSheetCommand::redo() noexcept {
+ox::Error UpdateSubSheetCommand::redo() noexcept {
 	auto &sheet = getSubSheet(m_img, m_idx);
 	sheet.name = m_newName;
-	sheet.columns = m_newCols;
-	sheet.rows = m_newRows;
-	oxLogError(setPixelCount(sheet, m_img.bpp, static_cast<std::size_t>(PixelsPerTile * m_newCols * m_newRows)));
+	oxLogError(resizeSubsheet(sheet, m_img.bpp, {m_newCols, m_newRows}));
+	return {};
 }
 
-void UpdateSubSheetCommand::undo() noexcept {
+ox::Error UpdateSubSheetCommand::undo() noexcept {
 	auto &sheet = getSubSheet(m_img, m_idx);
 	sheet = m_sheet;
+	return {};
 }
 
 int UpdateSubSheetCommand::commandId() const noexcept {

src/nostalgia/modules/core/src/studio/tilesheeteditor/commands/updatesubsheetcommand.hpp

@@ -25,9 +25,9 @@ class UpdateSubSheetCommand: public TileSheetCommand {
 				int cols,
 				int rows) noexcept;
 
-		void redo() noexcept final;
+		ox::Error redo() noexcept final;
 
-		void undo() noexcept final;
+		ox::Error undo() noexcept final;
 
 		[[nodiscard]]
 		int commandId() const noexcept final;

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheeteditormodel.cpp

@@ -305,7 +305,7 @@ void TileSheetEditorModel::getFillPixels(bool *pixels, ox::Point const&pt, int o
 }
 
 void TileSheetEditorModel::pushCommand(studio::UndoCommand *cmd) noexcept {
-	m_undoStack.push(ox::UPtr<studio::UndoCommand>(cmd));
+	std::ignore = m_undoStack.push(ox::UPtr<studio::UndoCommand>(cmd));
 	m_ongoingDrawCommand = dynamic_cast<DrawCommand*>(cmd);
 	m_updated = true;
 }

src/nostalgia/modules/core/src/studio/tilesheeteditor/tilesheetpixels.cpp

@@ -139,10 +139,7 @@ void TileSheetPixels::setBufferObjects(ox::Vec2 const&paneSize) noexcept {
 			return;
 		}
 		if (m_model.pixelSelected(i)) {
-			auto const r = red16(color) / 2;
-			auto const g = (green16(color) + 20) / 2;
-			auto const b = (blue16(color) + 31) / 2;
-			color = color16(r, g, b);
+			color = applySelectionColor(color);
 		}
 		setPixelBufferObject(paneSize, static_cast<unsigned>(i * VertexVboRows), fx, fy, color, vbo, ebo);
 	});

src/nostalgia/modules/core/src/tilesheet.cpp

@@ -15,11 +15,11 @@ std::size_t idx(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept {
 }
 
 [[nodiscard]]
-static TileSheet::SubSheet const*getSubsheet(TileSheet::SubSheet const&ss, SubSheetId const id) noexcept {
+static TileSheet::SubSheet const *getSubsheet(TileSheet::SubSheet const&ss, SubSheetId const id) noexcept {
 	if (ss.id == id) {
 		return &ss;
 	}
-	for (auto const&child : ss.subsheets) {
+	for (auto const&child: ss.subsheets) {
 		if (auto out = getSubsheet(child, id)) {
 			return out;
 		}
@@ -34,7 +34,7 @@ static size_t getTileCnt(TileSheet::SubSheet const&ss, int const bpp) noexcept {
 		return ss.pixels.size() / bytesPerTile;
 	} else {
 		size_t out{};
-		for (auto const&child : ss.subsheets) {
+		for (auto const&child: ss.subsheets) {
 			out += getTileCnt(child, bpp);
 		}
 		return out;
@@ -45,7 +45,7 @@ size_t getTileCnt(TileSheet const&ts) noexcept {
 	return getTileCnt(ts.subsheet, ts.bpp);
 }
 
-TileSheet::SubSheet const*getSubsheet(TileSheet const&ts, SubSheetId const id) noexcept {
+TileSheet::SubSheet const *getSubsheet(TileSheet const&ts, SubSheetId const id) noexcept {
 	return getSubsheet(ts.subsheet, id);
 }
 
@@ -54,7 +54,7 @@ static ox::Optional<size_t> getPixelIdx(
 		SubSheetId const id,
 		size_t idx,
 		int8_t const bpp) noexcept {
-	for (auto const&child : ss.subsheets) {
+	for (auto const&child: ss.subsheets) {
 		if (child.id == id) {
 			return ox::Optional<size_t>(ox::in_place, idx);
 		}
@@ -106,8 +106,8 @@ uint8_t getPixel(TileSheet::SubSheet const&ss, int8_t pBpp, ox::Point const&pt)
 	return getPixel(ss, pBpp, idx);
 }
 
-void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept {
-	auto &pixel = ss.pixels[static_cast<std::size_t>(idx / 2)];
+static void setPixel(ox::Vector<uint8_t> &pixels, int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept {
+	auto &pixel = pixels[static_cast<std::size_t>(idx / 2)];
 	if (pBpp == 4) {
 		if (idx & 1) {
 			pixel = static_cast<uint8_t>((pixel & 0b0000'1111) | (palIdx << 4));
@@ -119,29 +119,59 @@ void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, uint64_t idx, uint8_t palIdx
 	}
 }
 
+void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, uint64_t idx, uint8_t palIdx) noexcept {
+	setPixel(ss.pixels, pBpp, idx, palIdx);
+}
+
+static void setPixel(ox::Vector<uint8_t> &pixels, int columns, int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept {
+	const auto idx = ptToIdx(pt, columns);
+	setPixel(pixels, pBpp, idx, palIdx);
+}
+
 void setPixel(TileSheet::SubSheet &ss, int8_t pBpp, ox::Point const&pt, uint8_t palIdx) noexcept {
 	const auto idx = ptToIdx(pt, ss.columns);
 	setPixel(ss, pBpp, idx, palIdx);
 }
 
-ox::Error setPixelCount(TileSheet::SubSheet &ss, int8_t pBpp, std::size_t cnt) noexcept {
+static ox::Error setPixelCount(ox::Vector<uint8_t> &pixels, int8_t pBpp, std::size_t cnt) noexcept {
 	switch (pBpp) {
 		case 4:
-			ss.pixels.resize(cnt / 2);
+			pixels.resize(cnt / 2);
 			return OxError(0);
 		case 8:
-			ss.pixels.resize(cnt);
+			pixels.resize(cnt);
 			return OxError(0);
 		default:
 			return OxError(1, "Invalid pBpp used for TileSheet::SubSheet::setPixelCount");
 	}
 }
 
+ox::Error setPixelCount(TileSheet::SubSheet &ss, int8_t pBpp, std::size_t cnt) noexcept {
+	return setPixelCount(ss.pixels, pBpp, cnt);
+}
+
 unsigned pixelCnt(TileSheet::SubSheet const&ss, int8_t pBpp) noexcept {
 	const auto pixelsSize = static_cast<unsigned>(ss.pixels.size());
 	return pBpp == 4 ? pixelsSize * 2 : pixelsSize;
 }
 
+ox::Error resizeSubsheet(TileSheet::SubSheet &ss, int8_t pBpp, ox::Size const&sz) noexcept {
+	ox::Vector<uint8_t> out;
+	oxReturnError(setPixelCount(out, pBpp, static_cast<size_t>(sz.width * sz.height) * PixelsPerTile));
+	auto const w = sz.width * TileWidth;
+	auto const h = sz.height * TileHeight;
+	for (auto x = 0; x < w; ++x) {
+		for (auto y = 0; y < h; ++y) {
+			auto const palIdx = getPixel(ss, pBpp, {x, y});
+			setPixel(out, sz.width, pBpp, {x, y}, palIdx);
+		}
+	}
+	ss.columns = sz.width;
+	ss.rows = sz.height;
+	ss.pixels = std::move(out);
+	return {};
+}
+
 ox::Result<ox::StringView> getNameFor(TileSheet::SubSheet const&ss, SubSheetId pId) noexcept {
 	if (ss.id == pId) {
 		return ox::StringView(ss.name);

src/nostalgia/studio/CMakeLists.txt

@@ -11,7 +11,7 @@ target_link_libraries(
 
 target_compile_definitions(
 	NostalgiaStudio PUBLIC
-		OLYMPIC_APP_VERSION="d2024.05.0"
+		OLYMPIC_APP_VERSION="dev build"
 )
 
 install(

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

@@ -4,6 +4,10 @@
 
 #pragma once
 
+#ifndef OX_BARE_METAL
+#include <functional>
+#endif
+
 #include <ox/event/signal.hpp>
 #include <ox/fs/fs.hpp>
 #include <ox/model/typenamecatcher.hpp>
@@ -178,9 +182,11 @@ constexpr AssetRef<T>::AssetRef(AssetRef &&h) noexcept: m_ctr(h.m_ctr) {
 	h.m_ctr = nullptr;
 }
 
+class Context;
+
 class AssetManager {
 	private:
-		class AssetTypeManagerBase {
+		class AssetTypeManagerBase: public ox::SignalHandler {
 			public:
 				virtual ~AssetTypeManagerBase() = default;
 
@@ -189,17 +195,24 @@ class AssetManager {
 
 		template<typename T>
 		class AssetTypeManager: public AssetTypeManagerBase {
+			public:
+				using Loader = std::function<ox::Result<T>(ox::StringView assetId)>;
 			private:
+				Loader m_loader{};
 				ox::HashMap<ox::String, ox::UPtr<AssetContainer<T>>> m_cache;
 
 			public:
-				ox::Result<AssetRef<T>> getAsset(ox::StringView const&assetId) const noexcept {
-					auto out = m_cache.at(assetId);
-					oxReturnError(out);
-					return AssetRef<T>(out.value->get());
+				AssetTypeManager(Loader loader) noexcept: m_loader(loader) {}
+
+				ox::Result<AssetRef<T>> getAsset(ox::StringView const assetId) const noexcept {
+					oxRequire(out, m_cache.at(assetId));
+					if (!out || !*out) {
+						return OxError(1, "asset is null");
+					}
+					return AssetRef<T>(out->get());
 				}
 
-				ox::Result<AssetRef<T>> setAsset(ox::StringView const&assetId, T const&obj) noexcept {
+				ox::Result<AssetRef<T>> setAsset(ox::StringView const assetId, T const&obj) noexcept {
 					auto &p = m_cache[assetId];
 					if (!p) {
 						p = ox::make_unique<AssetContainer<T>>(obj);
@@ -210,7 +223,7 @@ class AssetManager {
 					return AssetRef<T>(p.get());
 				}
 
-				ox::Result<AssetRef<T>> setAsset(ox::StringView const&assetId, T &&obj) noexcept {
+				ox::Result<AssetRef<T>> setAsset(ox::StringView const assetId, T &&obj) noexcept {
 					auto &p = m_cache[assetId];
 					if (!p) {
 						p = ox::make_unique<AssetContainer<T>>(obj);
@@ -221,6 +234,30 @@ class AssetManager {
 					return AssetRef<T>(p.get());
 				}
 
+				ox::Result<AssetRef<T>> loadAsset(ox::StringView const assetId) noexcept {
+					auto &p = m_cache[assetId];
+					oxRequireM(obj, m_loader(assetId));
+					if (!p) {
+						p = ox::make_unique<AssetContainer<T>>(std::move(obj));
+					} else {
+						p->set(std::move(obj));
+						p->updated.emit();
+					}
+					return AssetRef<T>(p.get());
+				}
+
+				ox::Error reloadAsset(ox::StringView const assetId) noexcept {
+					auto &p = m_cache[assetId];
+					oxRequireM(obj, m_loader(assetId));
+					if (!p) {
+						p = ox::make_unique<AssetContainer<T>>(std::move(obj));
+					} else {
+						p->set(std::move(obj));
+						p->updated.emit();
+					}
+					return {};
+				}
+
 				void gc() noexcept final {
 					for (auto const&ack : m_cache.keys()) {
 						auto &ac = m_cache[ack];
@@ -232,29 +269,58 @@ class AssetManager {
 		};
 
 		ox::HashMap<ox::String, ox::UPtr<AssetTypeManagerBase>> m_assetTypeManagers;
+		struct FileTracker {
+			ox::Signal<ox::Error(ox::StringView assetId)> updated;
+		};
+		ox::HashMap<ox::String, FileTracker> m_fileTrackers;
 
 		template<typename T>
-		AssetTypeManager<T> *getTypeManager() noexcept {
-			constexpr auto typeName = ox::requireModelTypeName<T>();
-			static_assert(ox::StringView(typeName) != "", "Types must have TypeName to use AssetManager");
-			auto &am = m_assetTypeManagers[typeName];
-			if (!am) {
-				am = ox::make_unique<AssetTypeManager<T>>();
+		ox::Result<AssetTypeManager<T>*> getTypeManager() noexcept {
+			constexpr auto &typeId = ox::ModelTypeId_v<T>;
+			static_assert(typeId != "", "Types must have TypeName to use AssetManager");
+			auto &am = m_assetTypeManagers[typeId];
+			auto const out = dynamic_cast<AssetTypeManager<T>*>(am.get());
+			if (!out) {
+				return OxError(1, "no AssetTypeManager for type");
 			}
-			return dynamic_cast<AssetTypeManager<T>*>(am.get());
+			return out;
 		}
 
 	public:
 		template<typename T>
-		ox::Result<AssetRef<T>> getAsset(ox::CRStringView assetId) noexcept {
-			auto m = getTypeManager<T>();
+		void initTypeManager(auto const&makeLoader, Context &ctx) noexcept {
+			constexpr auto &typeId = ox::ModelTypeId_v<T>;
+			static_assert(typeId != "", "Types must have TypeName to use AssetManager");
+			auto &am = m_assetTypeManagers[typeId];
+			if (!am) {
+				am = ox::make_unique<AssetTypeManager<T>>(makeLoader(ctx));
+			}
+		}
+
+		template<typename T>
+		ox::Result<AssetRef<T>> getAsset(ox::StringView assetId) noexcept {
+			oxRequire(m, getTypeManager<T>());
 			return m->getAsset(assetId);
 		}
 
 		template<typename T>
-		ox::Result<AssetRef<T>> setAsset(ox::CRStringView assetId, T const&obj) noexcept {
-			auto m = getTypeManager<T>();
-			return m->setAsset(assetId, obj);
+		ox::Result<AssetRef<T>> setAsset(ox::StringView assetId, T const&obj) noexcept {
+			oxRequire(m, getTypeManager<T>());
+			oxReturnError(m->setAsset(assetId, obj));
+			return {};
+		}
+
+		ox::Error reloadAsset(ox::StringView assetId) noexcept {
+			m_fileTrackers[assetId].updated.emit(assetId);
+			return {};
+		}
+
+		template<typename T>
+		ox::Result<AssetRef<T>> loadAsset(ox::StringView assetId) noexcept {
+			oxRequire(m, getTypeManager<T>());
+			oxRequire(out, m->loadAsset(assetId));
+			m_fileTrackers[assetId].updated.connect(m, &AssetTypeManager<T>::reloadAsset);
+			return out;
 		}
 
 		void gc() noexcept {

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

@@ -32,14 +32,43 @@ oxModelEnd()
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const&file) noexcept;
 ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::CRStringView file) noexcept;
 
+
+void createUuidMapping(Context &ctx, ox::StringView filePath, ox::UUID const&uuid) noexcept;
+
+ox::Error buildUuidMap(Context &ctx) noexcept;
+
+ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::CRStringView path) noexcept;
+
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
+
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept;
+
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept;
+
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexcept;
+
+constexpr ox::Result<ox::UUID> uuidUrlToUuid(ox::StringView uuidUrl) noexcept {
+	return ox::UUID::fromString(substr(uuidUrl, 7));
+}
+
+ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noexcept;
+
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::CRStringView uuid) noexcept;
+
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept;
+
+ox::Error performPackTransforms(Context &ctx, ox::Buffer &clawData) noexcept;
+
 #ifndef OX_BARE_METAL
 
+namespace detail {
 template<typename T>
-ox::Result<keel::AssetRef<T>> readObjFile(
-		keel::Context &ctx,
-		ox::StringView assetId,
-		bool forceLoad) noexcept {
-	constexpr auto readConvert = [](Context &ctx, const ox::Buffer &buff) -> ox::Result<T> {
+constexpr auto makeLoader(Context &ctx) {
+	return [&ctx](ox::StringView assetId) -> ox::Result<T> {
+		ox::StringView path;
+		oxRequire(p, ctx.uuidToPath.at(assetId));
+		path = *p;
+		oxRequire(buff, ctx.rom->read(path));
 		auto [obj, err] = readAsset<T>(buff);
 		if (err) {
 			if (err != ox::Error_ClawTypeVersionMismatch && err != ox::Error_ClawTypeMismatch) {
@@ -49,25 +78,34 @@ ox::Result<keel::AssetRef<T>> readObjFile(
 		}
 		return std::move(obj);
 	};
-	ox::StringView path;
+};
+}
+
+template<typename T>
+ox::Result<keel::AssetRef<T>> readObjFile(
+		keel::Context &ctx,
+		ox::StringView assetId,
+		bool forceLoad) noexcept {
+	ox::UUIDStr uuidStr;
 	if (beginsWith(assetId, "uuid://")) {
 		assetId = substr(assetId, 7);
-		oxRequire(p, ctx.uuidToPath.at(assetId));
-		path = *p;
+		oxRequire(p, keel::uuidToPath(ctx, assetId));
 	} else {
-		path = assetId;
+		auto const [uuid, uuidErr] =  getUuid(ctx, assetId);
+		if (!uuidErr) {
+			uuidStr = uuid.toString();
+			assetId = uuidStr;
+		}
 	}
 	if (forceLoad) {
-		oxRequire(buff, ctx.rom->read(path));
-		oxRequire(obj, readConvert(ctx, buff));
-		oxRequire(cached, ctx.assetManager.setAsset(assetId, obj));
+		ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
+		oxRequire(cached, ctx.assetManager.loadAsset<T>(assetId));
 		return cached;
 	} else {
 		auto [cached, err] = ctx.assetManager.getAsset<T>(assetId);
 		if (err) {
-			oxRequire(buff, ctx.rom->read(path));
-			oxRequire(obj, readConvert(ctx, buff));
-			oxReturnError(ctx.assetManager.setAsset(assetId, obj).moveTo(cached));
+			ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
+			oxReturnError(ctx.assetManager.loadAsset<T>(assetId).moveTo(cached));
 		}
 		return cached;
 	}
@@ -89,29 +127,24 @@ ox::Result<keel::AssetRef<T>> readObjNoCache(
 
 #endif
 
-void createUuidMapping(Context &ctx, ox::StringView filePath, ox::UUID const&uuid) noexcept;
-
-ox::Error buildUuidMap(Context &ctx) noexcept;
-
-ox::Result<ox::String> uuidToPath(Context &ctx, ox::CRStringView uuid) noexcept;
-
-ox::Result<ox::String> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept;
-
-ox::Error performPackTransforms(Context &ctx, ox::Buffer &clawData) noexcept;
+ox::Error reloadAsset(keel::Context &ctx, ox::StringView assetId) noexcept;
 
 template<typename T>
-ox::Result<AssetRef<T>> setAsset(keel::Context &ctx, ox::StringView assetId, T const&asset) noexcept {
+ox::Result<AssetRef<T>> setAsset(
+		keel::Context &ctx,
+		ox::StringView assetId,
+		T const&asset) noexcept {
 #ifndef OX_BARE_METAL
 	if (assetId.len() == 0) {
 		return OxError(1, "Invalid asset ID");
 	}
-	ox::UUIDStr idStr;
+	ox::UUIDStr uuidStr;
 	if (assetId[0] == '/') {
-		auto const [id, err] = ctx.pathToUuid.at(assetId);
-		oxReturnError(err);
-		idStr = id->toString();
-		assetId = idStr;
+		oxRequire(id, ctx.pathToUuid.at(assetId));
+		uuidStr = id->toString();
+		assetId = uuidStr;
 	}
+	ctx.assetManager.initTypeManager<T>(detail::makeLoader<T>, ctx);
 	return ctx.assetManager.setAsset(assetId, asset);
 #else
 	return OxError(1, "Not supported on this platform");

src/olympic/keel/src/media.cpp

@@ -83,19 +83,72 @@ ox::Result<ox::UUID> pathToUuid(Context &ctx, ox::CRStringView path) noexcept {
 #endif
 }
 
-ox::Result<ox::String> uuidToPath(Context &ctx, ox::CRStringView uuid) noexcept {
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
+	oxRequire(path, fileAddr.getPath());
+	return getUuid(ctx, path);
+}
+
+ox::Result<ox::UUID> getUuid(Context &ctx, ox::StringView path) noexcept {
+	if (beginsWith(path, "uuid://")) {
+		auto const uuid = substr(path, 7);
+		return ox::UUID::fromString(uuid);
+	} else {
+		return pathToUuid(ctx, path);
+	}
+}
+
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::FileAddress const&fileAddr) noexcept {
+	oxRequire(path, fileAddr.getPath());
+	if (beginsWith(path, "uuid://")) {
+		auto const uuid = substr(path, 7);
 #ifndef OX_BARE_METAL
-	oxRequire(out, ctx.uuidToPath.at(uuid));
-	return *out;
+		oxRequireM(out, ctx.uuidToPath.at(uuid));
+		return ox::CStringView{*out};
+#else
+		return OxError(1, "UUID to path conversion not supported on this platform");
+#endif
+	} else {
+		return ox::CStringView{path};
+	}
+}
+
+ox::Result<ox::CStringView> getPath(Context &ctx, ox::CStringView fileId) noexcept {
+	if (beginsWith(fileId, "uuid://")) {
+		auto const uuid = substr(fileId, 7);
+#ifndef OX_BARE_METAL
+		oxRequireM(out, ctx.uuidToPath.at(uuid));
+		return ox::CStringView{*out};
+#else
+		return OxError(1, "UUID to path conversion not supported on this platform");
+#endif
+	} else {
+		return ox::CStringView{fileId};
+	}
+}
+
+ox::Result<ox::CStringView> uuidUrlToPath(Context &ctx, ox::StringView uuid) noexcept {
+	uuid = substr(uuid, 7);
+#ifndef OX_BARE_METAL
+	oxRequireM(out, ctx.uuidToPath.at(uuid));
+	return ox::CStringView(*out);
 #else
 	return OxError(1, "UUID to path conversion not supported on this platform");
 #endif
 }
 
-ox::Result<ox::String> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::CRStringView uuid) noexcept {
 #ifndef OX_BARE_METAL
-	oxRequire(out, ctx.uuidToPath.at(uuid.toString()));
-	return *out;
+	oxRequireM(out, ctx.uuidToPath.at(uuid));
+	return ox::CStringView(*out);
+#else
+	return OxError(1, "UUID to path conversion not supported on this platform");
+#endif
+}
+
+ox::Result<ox::CStringView> uuidToPath(Context &ctx, ox::UUID const&uuid) noexcept {
+#ifndef OX_BARE_METAL
+	oxRequireM(out, ctx.uuidToPath.at(uuid.toString()));
+	return ox::CStringView(*out);
 #else
 	return OxError(1, "UUID to path conversion not supported on this platform");
 #endif
@@ -113,6 +166,21 @@ ox::Error performPackTransforms(Context &ctx, ox::Buffer &clawData) noexcept {
 	return {};
 }
 
+ox::Error reloadAsset(keel::Context &ctx, ox::StringView assetId) noexcept {
+	ox::UUIDStr uuidStr;
+	if (beginsWith(assetId, "uuid://")) {
+		assetId = substr(assetId, 7);
+		oxRequire(p, keel::uuidToPath(ctx, assetId));
+	} else {
+		auto const [uuid, uuidErr] =  getUuid(ctx, assetId);
+		if (!uuidErr) {
+			uuidStr = uuid.toString();
+			assetId = uuidStr;
+		}
+	}
+	return ctx.assetManager.reloadAsset(assetId);
+}
+
 }
 
 #else
@@ -166,6 +234,10 @@ ox::Result<std::size_t> getPreloadAddr(keel::Context &ctx, ox::FileAddress const
 	return static_cast<std::size_t>(p.preloadAddr) + ctx.preloadSectionOffset;
 }
 
+ox::Error reloadAsset(keel::Context&, ox::StringView) noexcept {
+	return OxError(1, "reloadAsset is unsupported on this platform");
+}
+
 }
 
 #endif

src/olympic/keel/src/pack.cpp

@@ -30,7 +30,7 @@ static ox::Error pathToInode(
 	}
 	if (beginsWith(path, "uuid://")) {
 		auto const uuid = ox::substr(path, 7);
-		oxReturnError(keel::uuidToPath(ctx, uuid).moveTo(path));
+		oxReturnError(keel::uuidToPath(ctx, uuid).to<ox::String>().moveTo(path));
 	}
 	oxRequire(s, dest.stat(path));
 	oxReturnError(o.at("type").unwrap()->set(static_cast<int8_t>(ox::FileAddressType::Inode)));

src/olympic/studio/applib/src/studioapp.cpp

@@ -2,6 +2,7 @@
  * Copyright 2016 - 2024 Gary Talent (gary@drinkingtea.net). All rights reserved.
  */
 
+#include <algorithm>
 #include <filesystem>
 
 #include <imgui.h>
@@ -196,10 +197,10 @@ void StudioUI::drawMenu() noexcept {
 		if (ImGui::BeginMenu("Edit")) {
 			auto undoStack = m_activeEditor ? m_activeEditor->undoStack() : nullptr;
 			if (ImGui::MenuItem("Undo", "Ctrl+Z", false, undoStack && undoStack->canUndo())) {
-				undoStack->undo();
+				oxLogError(undoStack->undo());
 			}
 			if (ImGui::MenuItem("Redo", "Ctrl+Y", false, undoStack && undoStack->canRedo())) {
-				undoStack->redo();
+				oxLogError(undoStack->redo());
 			}
 			ImGui::Separator();
 			if (ImGui::MenuItem("Copy", "Ctrl+C", false, m_activeEditor && m_activeEditor->copyEnabled())) {
@@ -314,14 +315,14 @@ void StudioUI::toggleProjectExplorer() noexcept {
 void StudioUI::redo() noexcept {
 	auto undoStack = m_activeEditor ? m_activeEditor->undoStack() : nullptr;
 	if (undoStack && undoStack->canRedo()) {
-		 m_activeEditor->undoStack()->redo();
+		 oxLogError(m_activeEditor->undoStack()->redo());
 	}
 }
 
 void StudioUI::undo() noexcept {
 	auto undoStack = m_activeEditor ? m_activeEditor->undoStack() : nullptr;
 	if (undoStack && undoStack->canUndo()) {
-		 m_activeEditor->undoStack()->undo();
+		 oxLogError(m_activeEditor->undoStack()->undo());
 	}
 }
 

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

@@ -131,14 +131,14 @@ class Editor: public studio::BaseEditor {
 		[[nodiscard]]
 		UndoStack *undoStack() noexcept final;
 
-		void pushCommand(ox::UPtr<UndoCommand> &&cmd) noexcept;
+		ox::Error pushCommand(ox::UPtr<UndoCommand> &&cmd) noexcept;
 
 		template<typename UC, typename ...Args>
-		void pushCommand(Args&&... args) noexcept {
+		ox::Error pushCommand(Args&&... args) noexcept {
 			try {
-				m_undoStack.push(ox::make_unique<UC>(ox::forward<Args>(args)...));
+				return m_undoStack.push(ox::make_unique<UC>(ox::forward<Args>(args)...));
 			} catch (ox::Exception const&ex) {
-				oxLogError(ex.toError());
+				return ex.toError();
 			}
 		}
 

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

@@ -34,7 +34,7 @@ ox::Result<T> getDragDropPayload(ox::CStringView name) noexcept {
 			static_cast<size_t>(payload->DataSize)});
 }
 
-ox::Error setDragDropPayload(ox::CStringView name, auto const &obj) noexcept {
+ox::Error setDragDropPayload(ox::CStringView name, auto const&obj) noexcept {
 	oxRequire(buff, ox::writeClaw(obj, ox::ClawFormat::Metal));
 	ImGui::SetDragDropPayload(name.c_str(), buff.data(), buff.size());
 	return {};
@@ -148,6 +148,19 @@ bool BeginPopup(turbine::Context &ctx, ox::CStringView popupName, bool &show, Im
  */
 bool ComboBox(ox::CStringView lbl, ox::SpanView<ox::String> list, size_t &selectedIdx) noexcept;
 
+/**
+ *
+ * @param lbl
+ * @param callback
+ * @param selectedIdx
+ * @return true if new value selected, false otherwise
+ */
+bool ComboBox(
+		ox::CStringView lbl,
+		std::function<ox::CStringView(size_t)> const&f,
+		size_t strCnt,
+		size_t &selectedIdx) noexcept;
+
 bool FileComboBox(
 		ox::CStringView lbl,
 		studio::StudioContext &sctx,

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

@@ -31,7 +31,7 @@ enum class ProjectEvent {
 constexpr ox::Result<ox::StringView> fileExt(ox::CRStringView path) noexcept {
 	auto const extStart = ox::find(path.crbegin(), path.crend(), '.').offset();
 	if (!extStart) {
-		return OxError(1, "Cannot open a file without valid extension.");
+		return OxError(1, "file path does not have valid extension");
 	}
 	return substr(path, extStart + 1);
 }
@@ -47,6 +47,7 @@ constexpr ox::StringView parentDir(ox::StringView path) noexcept {
 
 class Project {
 	private:
+		ox::SmallMap<ox::String, ox::Optional<ox::ClawFormat>> m_typeFmt;
 		keel::Context &m_ctx;
 		ox::String m_path;
 		ox::String m_projectDataDir;
@@ -75,7 +76,15 @@ class Project {
 		ox::Error writeObj(
 				ox::CRStringView path,
 				T const&obj,
-				ox::ClawFormat fmt = ox::ClawFormat::Metal) noexcept;
+				ox::ClawFormat fmt) noexcept;
+
+		/**
+		 * Writes a MetalClaw object to the project at the given path.
+		 */
+		template<typename T>
+		ox::Error writeObj(
+				ox::CRStringView path,
+				T const&obj) noexcept;
 
 		template<typename T>
 		ox::Result<T> loadObj(ox::CRStringView path) const noexcept;
@@ -115,7 +124,7 @@ class Project {
 		// file.
 		ox::Signal<ox::Error(ox::CRStringView)> fileRecognized;
 		ox::Signal<ox::Error(ox::CRStringView)> fileDeleted;
-		ox::Signal<ox::Error(ox::CRStringView)> fileUpdated;
+		ox::Signal<ox::Error(ox::StringView, ox::UUID)> fileUpdated;
 
 };
 
@@ -130,15 +139,24 @@ ox::Error Project::writeObj(ox::CRStringView path, T const&obj, ox::ClawFormat f
 		oxReturnError(ox::buildTypeDef(&m_typeStore, &obj));
 	}
 	oxRequire(desc, m_typeStore.get<T>());
-	auto const descExists = m_fs.stat(ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*desc))).error != 0;
+	auto const descPath = ox::sfmt("{}/{}", m_typeDescPath, buildTypeId(*desc));
+	auto const descExists = m_fs.exists(descPath);
 	if (!descExists) {
 		oxReturnError(writeTypeStore());
 	}
-	oxReturnError(keel::setAsset(m_ctx, path, obj));
-	fileUpdated.emit(path);
+	oxReturnError(keel::reloadAsset(m_ctx, path));
+	oxRequire(uuid, pathToUuid(m_ctx, path));
+	fileUpdated.emit(path, uuid);
 	return {};
 }
 
+template<typename T>
+ox::Error Project::writeObj(ox::CRStringView path, T const&obj) noexcept {
+	oxRequire(ext, fileExt(path));
+	auto const fmt = m_typeFmt[ext].or_value(ox::ClawFormat::Metal);
+	return writeObj(path, obj, fmt);
+}
+
 template<typename T>
 ox::Result<T> Project::loadObj(ox::CRStringView path) const noexcept {
 	oxRequire(buff, loadBuff(path));

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

@@ -0,0 +1,98 @@
+
+#pragma once
+
+#include <imgui.h>
+
+#include <ox/std/math.hpp>
+#include <ox/std/point.hpp>
+#include <ox/std/typetraits.hpp>
+
+namespace studio {
+
+struct Selection {
+	ox::Point a, b;
+	constexpr Selection() noexcept = default;
+	constexpr Selection(ox::Point const&pA, ox::Point const&pB) noexcept: a(pA), b(pB) {}
+};
+
+constexpr auto iterateSelection(studio::Selection const&sel, auto const&cb) {
+	constexpr auto retErr = ox::is_same_v<decltype(cb(0, 0)), ox::Error>;
+	for (auto x = sel.a.x; x <= sel.b.x; ++x) {
+		for (auto y = sel.a.y; y <= sel.b.y; ++y) {
+			if constexpr(retErr) {
+				oxReturnError(cb(x, y));
+			} else {
+				cb(x, y);
+			}
+		}
+	}
+	if constexpr(retErr) {
+		return ox::Error{};
+	}
+};
+
+class SelectionTracker {
+	private:
+		bool m_selectionOngoing{};
+		ox::Point m_pointA;
+		ox::Point m_pointB;
+	public:
+		[[nodiscard]]
+		constexpr bool selectionOngoing() const noexcept {
+			return m_selectionOngoing;
+		}
+
+		constexpr void startSelection(ox::Point cursor) noexcept {
+			m_pointA = cursor;
+			m_pointB = cursor;
+			m_selectionOngoing = true;
+		}
+
+		constexpr void updateCursorPoint(ox::Point cursor, bool allowStart = true) noexcept {
+			if (!m_selectionOngoing && allowStart) {
+				m_pointA = cursor;
+				m_selectionOngoing = true;
+			}
+			if (m_selectionOngoing) {
+				m_pointB = cursor;
+			}
+		}
+
+		constexpr void updateCursorPoint(ox::Vec2 cursor, bool allowStart = true) noexcept {
+			updateCursorPoint(
+					ox::Point{
+							static_cast<int32_t>(cursor.x),
+							static_cast<int32_t>(cursor.y),
+					},
+					allowStart);
+		}
+
+		constexpr void updateCursorPoint(ImVec2 cursor, bool allowStart = true) noexcept {
+			updateCursorPoint(
+					ox::Point{
+						static_cast<int32_t>(cursor.x),
+						static_cast<int32_t>(cursor.y),
+					},
+					allowStart);
+		}
+
+		constexpr void finishSelection() noexcept {
+			m_selectionOngoing = {};
+		}
+
+		[[nodiscard]]
+		constexpr Selection selection() const noexcept {
+			return {
+				{
+					ox::min(m_pointA.x, m_pointB.x),
+					ox::min(m_pointA.y, m_pointB.y),
+				},
+				{
+					ox::max(m_pointA.x, m_pointB.x),
+					ox::max(m_pointA.y, m_pointB.y),
+				},
+			};
+		}
+};
+
+}

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

@@ -12,6 +12,7 @@
 #include <studio/itemmaker.hpp>
 #include <studio/popup.hpp>
 #include <studio/project.hpp>
+#include <studio/selectiontracker.hpp>
 #include <studio/task.hpp>
 #include <studio/undocommand.hpp>
 #include <studio/undostack.hpp>

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

@@ -4,16 +4,26 @@
 
 #pragma once
 
+#include <source_location>
+
+#include <ox/std/error.hpp>
+
 namespace studio {
 
+class NoChangesException: public ox::Exception {
+	public:
+		inline NoChangesException(std::source_location sloc = std::source_location::current()):
+				ox::Exception(sloc.file_name(), sloc.line(), 1, "Command makes no changes.") {}
+};
+
 class UndoCommand {
 	public:
 		virtual ~UndoCommand() noexcept = default;
-		virtual void redo() noexcept = 0;
-		virtual void undo() noexcept = 0;
+		virtual ox::Error redo() noexcept = 0;
+		virtual ox::Error undo() noexcept = 0;
 		[[nodiscard]]
 		virtual int commandId() const noexcept = 0;
-		virtual bool mergeWith(UndoCommand const*cmd) noexcept;
+		virtual bool mergeWith(UndoCommand const&cmd) noexcept;
 };
 
 }

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

@@ -19,11 +19,11 @@ class UndoStack {
 		std::size_t m_stackIdx = 0;
 
 	public:
-		void push(ox::UPtr<UndoCommand> &&cmd) noexcept;
+		ox::Error push(ox::UPtr<UndoCommand> &&cmd) noexcept;
 
-		void redo() noexcept;
+		ox::Error redo() noexcept;
 
-		void undo() noexcept;
+		ox::Error undo() noexcept;
 
 		[[nodiscard]]
 		constexpr bool canRedo() const noexcept {

src/olympic/studio/modlib/src/editor.cpp

@@ -127,8 +127,8 @@ ox::CStringView Editor::itemDisplayName() const noexcept {
 	return m_itemName;
 }
 
-void Editor::pushCommand(ox::UPtr<UndoCommand> &&cmd) noexcept {
-	m_undoStack.push(std::move(cmd));
+ox::Error Editor::pushCommand(ox::UPtr<UndoCommand> &&cmd) noexcept {
+	return m_undoStack.push(std::move(cmd));
 }
 
 UndoStack *Editor::undoStack() noexcept {

src/olympic/studio/modlib/src/imguiutil.cpp

@@ -100,6 +100,26 @@ bool ComboBox(
 	return out;
 }
 
+bool ComboBox(
+		ox::CStringView lbl,
+		std::function<ox::CStringView(size_t)> const&f,
+		size_t strCnt,
+		size_t &selectedIdx) noexcept {
+	bool out{};
+	auto const first = selectedIdx < strCnt ? f(selectedIdx).c_str() : "";
+	if (ImGui::BeginCombo(lbl.c_str(), first, 0)) {
+		for (auto i = 0u; i < strCnt; ++i) {
+			const auto selected = (selectedIdx == i);
+			if (ImGui::Selectable(f(i).c_str(), selected) && selectedIdx != i) {
+				selectedIdx = i;
+				out = true;
+			}
+		}
+		ImGui::EndCombo();
+	}
+	return out;
+}
+
 bool FileComboBox(
 		ox::CStringView lbl,
 		studio::StudioContext &sctx,

src/olympic/studio/modlib/src/project.cpp

@@ -56,9 +56,13 @@ ox::FileSystem &Project::romFs() noexcept {
 }
 
 ox::Error Project::mkdir(ox::CRStringView path) const noexcept {
-	oxReturnError(m_fs.mkdir(path, true));
-	fileUpdated.emit(path);
-	return {};
+	auto const [stat, err] = m_fs.stat(path);
+	if (err) {
+		oxReturnError(m_fs.mkdir(path, true));
+		fileUpdated.emit(path, {});
+	}
+	return stat.fileType == ox::FileType::Directory ?
+		ox::Error{} : OxError(1, "path exists as normal file");
 }
 
 ox::Result<ox::FileStat> Project::stat(ox::CRStringView path) const noexcept {
@@ -115,9 +119,9 @@ ox::Error Project::writeBuff(ox::CRStringView path, ox::Buffer const&buff) noexc
 	ox::Buffer outBuff;
 	outBuff.reserve(buff.size() + HdrSz);
 	ox::BufferWriter writer(&outBuff);
-	auto const [uuid, err] = m_ctx.pathToUuid.at(path);
+	auto const [uuid, err] = pathToUuid(m_ctx, path);
 	if (!err) {
-		oxReturnError(keel::writeUuidHeader(writer, *uuid));
+		oxReturnError(keel::writeUuidHeader(writer, uuid));
 	}
 	oxReturnError(writer.write(buff.data(), buff.size()));
 	auto const newFile = m_fs.stat(path).error != 0;
@@ -126,7 +130,7 @@ ox::Error Project::writeBuff(ox::CRStringView path, ox::Buffer const&buff) noexc
 		fileAdded.emit(path);
 		indexFile(path);
 	} else {
-		fileUpdated.emit(path);
+		fileUpdated.emit(path, uuid);
 	}
 	return {};
 }

src/olympic/studio/modlib/src/undocommand.cpp

@@ -3,7 +3,7 @@
 
 namespace studio {
 
-bool UndoCommand::mergeWith(UndoCommand const*) noexcept {
+bool UndoCommand::mergeWith(UndoCommand const&) noexcept {
 	return false;
 }
 

src/olympic/studio/modlib/src/undostack.cpp

@@ -6,35 +6,39 @@
 
 namespace studio {
 
-void UndoStack::push(ox::UPtr<UndoCommand> &&cmd) noexcept {
+ox::Error UndoStack::push(ox::UPtr<UndoCommand> &&cmd) noexcept {
 	for (auto const i = m_stackIdx; i < m_stack.size();) {
 		std::ignore = m_stack.erase(i);
 	}
-	cmd->redo();
+	oxReturnError(cmd->redo());
 	redoTriggered.emit(cmd.get());
 	changeTriggered.emit(cmd.get());
-	if (m_stack.empty() || !(*m_stack.back().value)->mergeWith(cmd.get())) {
+	if (m_stack.empty() || !(*m_stack.back().value)->mergeWith(*cmd)) {
 		m_stack.emplace_back(std::move(cmd));
 		++m_stackIdx;
 	}
+	return {};
 }
 
-void UndoStack::redo() noexcept {
+ox::Error UndoStack::redo() noexcept {
 	if (m_stackIdx < m_stack.size()) {
-		auto &c = m_stack[m_stackIdx++];
-		c->redo();
+		auto &c = m_stack[m_stackIdx];
+		oxReturnError(c->redo());
+		++m_stackIdx;
 		redoTriggered.emit(c.get());
 		changeTriggered.emit(c.get());
 	}
+	return {};
 }
 
-void UndoStack::undo() noexcept {
+ox::Error UndoStack::undo() noexcept {
 	if (m_stackIdx) {
 		auto &c = m_stack[--m_stackIdx];
-		c->undo();
+		oxReturnError(c->undo());
 		undoTriggered.emit(c.get());
 		changeTriggered.emit(c.get());
 	}
+	return {};
 }
 
 }