[nostalgia/studio] Set version to d2025.07.0

deps/ox/src/ox/clargs/clargs.cpp

@@ -17,14 +17,14 @@ ClArgs::ClArgs(ox::SpanView<const char*> args) noexcept {
 	for (auto i = 0u; i < args.size(); ++i) {
 		auto arg = StringView{args[i]};
 		if (arg[0] == '-') {
-			while (arg[0] == '-' && arg.len()) {
+			while (arg[0] == '-' && arg.size()) {
 				arg = substr(arg, 1);
 			}
 			m_bools[arg] = true;
 			// parse additional arguments
 			if (i < args.size() && args[i + 1]) {
 				auto const val = StringView{args[i + 1]};
-				if (val.len() && val[0] != '-') {
+				if (val.size() && val[0] != '-') {
 					if (val == "false") {
 						m_bools[arg] = false;
 					}

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

@@ -109,7 +109,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			"ClawHeaderReader",
 			[] {
 				constexpr auto hdr = ox::StringLiteral("O1;com.drinkingtea.ox.claw.test.Header;2;");
-				auto [ch, err] = ox::readClawHeader({hdr.c_str(), hdr.len() + 1});
+				auto [ch, err] = ox::readClawHeader({hdr.c_str(), hdr.size() + 1});
 				oxAssert(err, "Error parsing header");
 				oxAssert(ch.fmt == ox::ClawFormat::Organic, "Format wrong");
 				oxAssert(ch.typeName == "com.drinkingtea.ox.claw.test.Header", "Type name wrong");
@@ -121,7 +121,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			"ClawHeaderReader2",
 			[] {
 				constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;");
-				auto [ch, err] = ox::readClawHeader({hdr.c_str(), hdr.len() + 1});
+				auto [ch, err] = ox::readClawHeader({hdr.c_str(), hdr.size() + 1});
 				oxAssert(err, "Error parsing header");
 				oxAssert(ch.fmt == ox::ClawFormat::Metal, "Format wrong");
 				oxAssert(ch.typeName == "com.drinkingtea.ox.claw.test.Header2", "Type name wrong");
@@ -134,7 +134,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			[] {
 				constexpr auto hdr = ox::StringLiteral("M2;com.drinkingtea.ox.claw.test.Header2;3;awefawf");
 				constexpr auto expected = ox::StringLiteral("com.drinkingtea.ox.claw.test.Header2;3");
-				OX_REQUIRE(actual, ox::readClawTypeId({hdr.data(), hdr.len() + 1}));
+				OX_REQUIRE(actual, ox::readClawTypeId({hdr.data(), hdr.size() + 1}));
 				oxExpect(actual, expected);
 				return ox::Error{};
 			}

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

@@ -52,7 +52,7 @@ struct OX_PACKED DirectoryEntry {
 			if (d.valid()) {
 				d->inode = inode;
 				auto const maxStrSz = bufferSize - 1 - sizeof(*this);
-				ox::strncpy(d->name, name.data(), ox::min(maxStrSz, name.len()));
+				ox::strncpy(d->name, name.data(), ox::min(maxStrSz, name.size()));
 				return {};
 			}
 			return ox::Error(1);
@@ -219,7 +219,7 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, uint64_t inode64
 			oxTrace("ox.fs.Directory.write.fail", "Could not read existing version of Directory");
 			return ox::Error(1, "Could not read existing version of Directory");
 		}
-		const auto pathSize = name.len() + 1;
+		const auto pathSize = name.size() + 1;
 		const auto entryDataSize = DirectoryEntry<InodeId_t>::DirectoryEntryData::spaceNeeded(pathSize);
 		const auto newSize = oldStat.size + Buffer::spaceNeeded(entryDataSize);
 		auto cpy = ox_malloca(newSize, Buffer, *old, oldStat.size);

deps/ox/src/ox/fs/filesystem/passthroughfs.cpp

@@ -206,7 +206,7 @@ Error PassThroughFS::writeFileInode(uint64_t, const void*, uint64_t, FileType) n
 }
 
 std::string_view PassThroughFS::stripSlash(StringView path) noexcept {
-	for (auto i = 0u; i < path.len() && path[0] == '/'; i++) {
+	for (auto i = 0u; i < path.size() && path[0] == '/'; i++) {
 		path = substr(path, 1);
 	}
 	return {path.data(), path.bytes()};

deps/ox/src/ox/fs/filesystem/pathiterator.cpp

@@ -74,7 +74,7 @@ Error PathIterator::get(StringView &fileName) {
 	if (size && fileName[size - 1] == '/') {
 		fileName = ox::substr(m_path, start, start + size - 1);
 	}
-	oxAssert(fileName[fileName.len()-1] != '/', "name ends in /");
+	oxAssert(fileName[fileName.size()-1] != '/', "name ends in /");
 	return {};
 }
 
@@ -104,11 +104,11 @@ Error PathIterator::next(StringView &fileName) {
 		}
 		fileName = ox::substr(m_path, start, start + size);
 		// truncate trailing /
-		while (fileName.len() && fileName[fileName.len() - 1] == '/') {
+		while (fileName.size() && fileName[fileName.size() - 1] == '/') {
 			fileName = ox::substr(m_path, start, start + size);
 		}
 		m_iterator += size;
-		oxAssert(fileName.len() == 0 || fileName[fileName.len()-1] != '/', "name ends in /");
+		oxAssert(fileName.size() == 0 || fileName[fileName.size()-1] != '/', "name ends in /");
 	}
 	return retval;
 }

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

@@ -59,7 +59,7 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
 			"PathIterator::next1",
 			[](ox::StringView) {
 				auto constexpr path = ox::StringLiteral("/usr/share/charset.gbag");
-				ox::PathIterator it(path.c_str(), path.len());
+				ox::PathIterator it(path.c_str(), path.size());
 				ox::StringView buff;
 				oxAssert(it.next(buff) == 0 && buff == "usr", "PathIterator shows wrong next");
 				oxAssert(it.next(buff) == 0 && buff == "share", "PathIterator shows wrong next");
@@ -84,7 +84,7 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
 			"PathIterator::next3",
 			[](ox::StringView) {
 				auto const path = ox::String("/");
-				ox::PathIterator it(path.c_str(), path.len());
+				ox::PathIterator it(path.c_str(), path.size());
 				ox::StringView buff;
 				oxAssert(it.next(buff) == 0 && buff == "\0", "PathIterator shows wrong next");
 				return ox::Error(0);
@@ -106,7 +106,7 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
 			"PathIterator::next5",
 			[](ox::StringView) {
 				auto const path = ox::String("usr/share/");
-				ox::PathIterator it(path.c_str(), path.len());
+				ox::PathIterator it(path.c_str(), path.size());
 				ox::StringView buff;
 				oxAssert(it.next(buff) == 0 && buff == "usr", "PathIterator shows wrong next");
 				oxAssert(it.next(buff) == 0 && buff == "share", "PathIterator shows wrong next");
@@ -117,10 +117,10 @@ const std::map<ox::StringView, std::function<ox::Error(ox::StringView)>> tests =
 			"PathIterator::dirPath",
 			[] (ox::StringView) {
 				auto constexpr path = ox::StringLiteral("/usr/share/charset.gbag");
-				ox::PathIterator it(path.c_str(), path.len());
-				auto buff = static_cast<char*>(ox_alloca(path.len() + 1));
+				ox::PathIterator it(path.c_str(), path.size());
+				auto buff = static_cast<char*>(ox_alloca(path.size() + 1));
 				OX_ALLOW_UNSAFE_BUFFERS_BEGIN
-				oxAssert(it.dirPath(buff, path.len()) == 0 && ox::strcmp(buff, "/usr/share/") == 0, "PathIterator shows incorrect dir path");
+				oxAssert(it.dirPath(buff, path.size()) == 0 && ox::strcmp(buff, "/usr/share/") == 0, "PathIterator shows incorrect dir path");
 				OX_ALLOW_UNSAFE_BUFFERS_END
 				return ox::Error(0);
 			}

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

@@ -157,7 +157,7 @@ std::map<ox::StringView, ox::Error(*)()> tests = {
 				oxAssert(testIn.Int8                == testOut.Int8,                "Int8 value mismatch");
 				oxAssert(testIn.Union.Int           == testOut.Union.Int,           "Union.Int value mismatch");
 				oxAssert(testIn.String              == testOut.String,              "String value mismatch");
-				oxDebugf("{}", testOut.IString.len());
+				oxDebugf("{}", testOut.IString.size());
 				oxExpect(testIn.IString,               testOut.IString);
 				oxAssert(testIn.List[0]             == testOut.List[0],             "List[0] value mismatch");
 				oxAssert(testIn.List[1]             == testOut.List[1],             "List[1] value mismatch");

deps/ox/src/ox/mc/write.hpp

@@ -191,12 +191,12 @@ template<Writer_c Writer>
 template<std::size_t SmallStringSize>
 constexpr Error MetalClawWriter<Writer>::field(const char*, const BasicString<SmallStringSize> *val) noexcept {
 	bool fieldSet = false;
-	if (val->len() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
+	if (val->size() && (!m_unionIdx.has_value() || *m_unionIdx == m_field)) {
 		// write the length
-		const auto strLen = mc::encodeInteger(val->len());
+		const auto strLen = mc::encodeInteger(val->size());
 		OX_RETURN_ERROR(m_writer.write(reinterpret_cast<const char*>(strLen.data.data()), strLen.length));
 		// write the string
-		OX_RETURN_ERROR(m_writer.write(val->c_str(), static_cast<std::size_t>(val->len())));
+		OX_RETURN_ERROR(m_writer.write(val->c_str(), static_cast<std::size_t>(val->size())));
 		fieldSet = true;
 	}
 	OX_RETURN_ERROR(m_fieldPresence.set(static_cast<std::size_t>(m_field), fieldSet));
@@ -207,7 +207,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const BasicString<Sm
 template<Writer_c Writer>
 template<std::size_t L>
 constexpr Error MetalClawWriter<Writer>::field(const char *name, const IString<L> *val) noexcept {
-	return fieldCString(name, val->data(), val->len());
+	return fieldCString(name, val->data(), val->size());
 }
 
 template<Writer_c Writer>
@@ -339,7 +339,7 @@ constexpr Error MetalClawWriter<Writer>::field(const char*, const HashMap<String
 		OX_RETURN_ERROR(handler.setTypeInfo("Map", 0, {}, len * 2));
 		// this loop body needs to be in a lambda because of the potential alloca call
 		constexpr auto loopBody = [](auto &handler, auto const&key, auto const&val) -> ox::Error {
-			const auto keyLen = key.len();
+			const auto keyLen = key.size();
 			auto wkey = ox_malloca(keyLen + 1, char, 0);
 			memcpy(wkey.get(), key.c_str(), keyLen + 1);
 			OX_RETURN_ERROR(handler.fieldCString("", wkey.get(), keyLen));

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

@@ -43,7 +43,7 @@ static constexpr auto buildTypeId(
 		for (const auto &p : typeParams) {
 			tp += p + ",";
 		}
-		tp.resize(tp.len() - 1);
+		tp.resize(tp.size() - 1);
 		tp += "#";
 	}
 	return ox::sfmt("{}{};{}", name, tp, version);

deps/ox/src/ox/model/typenamecatcher.hpp

@@ -144,7 +144,7 @@ template<typename T, typename Str = const char*>
 [[nodiscard]]
 consteval auto requireModelTypeName() noexcept {
 	constexpr auto name = getModelTypeName<T, Str>();
-	static_assert(ox::StringView{name}.len(), "Type lacks required TypeName");
+	static_assert(ox::StringView{name}.size(), "Type lacks required TypeName");
 	return name;
 }
 
@@ -159,7 +159,7 @@ constexpr auto ModelTypeId_v = [] {
 	constexpr auto name = ModelTypeName_v<T, ox::StringView>;
 	constexpr auto version = ModelTypeVersion_v<T>;
 	constexpr auto versionStr = ox::sfmt<ox::IString<19>>("{}", version);
-	return ox::sfmt<ox::IString<name.len() + versionStr.len() + 1>>("{};{}", name, versionStr);
+	return ox::sfmt<ox::IString<name.size() + versionStr.size() + 1>>("{};{}", name, versionStr);
 }();
 
 }

deps/ox/src/ox/oc/read.hpp

@@ -307,7 +307,7 @@ Result<T> readOC(BufferView buff) noexcept {
 
 template<typename T>
 Result<T> readOC(ox::StringView json) noexcept {
-	return readOC<T>(ox::BufferView{json.data(), json.len()});
+	return readOC<T>(ox::BufferView{json.data(), json.size()});
 }
 
 }

deps/ox/src/ox/oc/write.cpp

@@ -32,7 +32,7 @@ Error OrganicClawWriter::fieldCString(const char *key, const char *const*val) no
 
 Error OrganicClawWriter::field(const char *key, const UUID *uuid) noexcept {
 	const auto uuidStr = uuid->toString();
-	if (targetValid() && uuidStr.len()) {
+	if (targetValid() && uuidStr.size()) {
 		value(key) = uuidStr.c_str();
 	}
 	++m_fieldIt;

deps/ox/src/ox/oc/write.hpp

@@ -138,7 +138,7 @@ class OrganicClawWriter {
 
 		template<std::size_t L>
 		Error field(char const*key, IString<L> const*val) noexcept {
-			if (targetValid() && val->len()) {
+			if (targetValid() && val->size()) {
 				value(key) = val->c_str();
 			}
 			++m_fieldIt;
@@ -147,7 +147,7 @@ class OrganicClawWriter {
 
 		template<std::size_t L>
 		Error field(char const*key, BasicString<L> const*val) noexcept {
-			if (targetValid() && val->len()) {
+			if (targetValid() && val->size()) {
 				value(key) = val->c_str();
 			}
 			++m_fieldIt;

deps/ox/src/ox/std/assert.cpp

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

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

@@ -185,7 +185,7 @@ class BaseStringView {
 		}
 
 		[[nodiscard]]
-		constexpr auto len() const noexcept {
+		constexpr auto size() const noexcept {
 			return m_len;
 		}
 

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

@@ -21,13 +21,13 @@ class CStringView: public detail::BaseStringView {
 
 		constexpr CStringView(CStringView const&sv) noexcept = default;
 
-		constexpr CStringView(StringLiteral const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+		constexpr CStringView(StringLiteral const&str) noexcept: BaseStringView(str.data(), str.size()) {}
 
 		template<std::size_t SmallStrSz>
-		constexpr CStringView(BasicString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+		constexpr CStringView(BasicString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.size()) {}
 
 		template<std::size_t SmallStrSz>
-		constexpr CStringView(IString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.len()) {}
+		constexpr CStringView(IString<SmallStrSz> const&str) noexcept: BaseStringView(str.data(), str.size()) {}
 
 		constexpr CStringView(std::nullptr_t) noexcept {}
 
@@ -37,7 +37,7 @@ class CStringView: public detail::BaseStringView {
 
 		constexpr auto &operator=(CStringView const&other) noexcept {
 			if (&other != this) {
-				set(other.data(), other.len());
+				set(other.data(), other.size());
 			}
 			return *this;
 		}

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

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

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

@@ -72,7 +72,7 @@ class IString {
 		 * Returns the number of characters in this string.
 		 */
 		[[nodiscard]]
-		constexpr std::size_t len() const noexcept;
+		constexpr std::size_t size() const noexcept;
 
 		/**
 		 * Returns the number of bytes used for this string.
@@ -121,7 +121,7 @@ constexpr IString<size> &IString<size>::operator=(Integer_c auto i) noexcept {
 
 template<std::size_t size>
 constexpr IString<size> &IString<size>::operator=(ox::StringViewCR str) noexcept {
-	std::size_t strLen = str.len();
+	std::size_t strLen = str.size();
 	if (cap() < strLen) {
 		strLen = cap();
 	}
@@ -171,7 +171,7 @@ constexpr char &IString<StrCap>::operator[](std::size_t i) noexcept {
 template<std::size_t StrCap>
 constexpr Error IString<StrCap>::append(const char *str, std::size_t strLen) noexcept {
 	Error err{};
-	auto const currentLen = len();
+	auto const currentLen = size();
 	if (cap() < currentLen + strLen) {
 		strLen = cap() - currentLen;
 		err = ox::Error(1, "Insufficient space for full string");
@@ -187,7 +187,7 @@ OX_CLANG_NOWARN_END
 
 template<std::size_t StrCap>
 constexpr Error IString<StrCap>::append(ox::StringView str) noexcept {
-	return append(str.data(), str.len());
+	return append(str.data(), str.size());
 }
 
 template<std::size_t StrCap>
@@ -207,7 +207,7 @@ constexpr const char *IString<StrCap>::c_str() const noexcept {
 
 
 template<std::size_t StrCap>
-constexpr std::size_t IString<StrCap>::len() const noexcept {
+constexpr std::size_t IString<StrCap>::size() const noexcept {
 	return m_size;
 }
 

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

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

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

@@ -30,13 +30,15 @@ constexpr std::ios_base::seekdir sdMap(ox::ios_base::seekdir in) noexcept {
 
 ox::Result<char> StreamReader::peek() const noexcept {
 	try {
+		if (m_strm.eof()) {
+			return Error{1, "EOF"};
+		}
 		char c{};
 		m_strm.get(c);
-		auto const ok = c != EOF;
-		if (ok && m_strm.unget()) [[unlikely]] {
-			return ox::Error(1, "Unable to unget character");
+		if (m_strm.unget()) [[unlikely]] {
+			return ox::Error{1, "Unable to unget character"};
 		}
-		return {static_cast<char>(c), ox::Error(!ok, "File peek failed")};
+		return static_cast<char>(c);
 	} catch (std::exception const&) {
 		return ox::Error(1, "peek failed");
 	}

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

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

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

@@ -139,7 +139,7 @@ class BasicString {
 
 		constexpr BasicString &operator+=(Integer_c auto i) noexcept;
 
-		constexpr BasicString &operator+=(StringView src) noexcept;
+		constexpr BasicString &operator+=(StringViewCR src) noexcept;
 
 		constexpr BasicString &operator+=(BasicString const&src) noexcept;
 
@@ -176,7 +176,7 @@ class BasicString {
 		constexpr char &operator[](std::size_t i) noexcept;
 
 		constexpr Error append(const char *str, std::size_t strLen) noexcept {
-			auto currentLen = len();
+			auto currentLen = size();
 			m_buff.resize(m_buff.size() + strLen);
 			ox::listcpy(&m_buff[currentLen], str, strLen);
 			// make sure last element is a null terminator
@@ -185,8 +185,8 @@ class BasicString {
 			return {};
 		}
 
-		constexpr Error append(ox::StringView sv) noexcept {
-			return append(sv.data(), sv.len());
+		constexpr Error append(StringViewCR sv) noexcept {
+			return append(sv.data(), sv.size());
 		}
 
 		[[nodiscard]]
@@ -237,7 +237,7 @@ class BasicString {
 		 * Returns the number of characters in this string.
 		 */
 		[[nodiscard]]
-		constexpr std::size_t len() const noexcept;
+		constexpr std::size_t size() const noexcept;
 
 		/**
 		 * Returns the number of bytes used for this string.
@@ -277,7 +277,7 @@ constexpr BasicString<SmallStringSize_v>::BasicString(const char *str, std::size
 
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v>::BasicString(StringLiteral const&str) noexcept:
-	BasicString(StringView{str.data(), str.len()}) {
+	BasicString(StringView{str.data(), str.size()}) {
 }
 
 template<std::size_t SmallStringSize_v>
@@ -376,7 +376,7 @@ constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operat
 }
 
 template<std::size_t SmallStringSize_v>
-constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operator+=(StringView s) noexcept {
+constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operator+=(StringViewCR s) noexcept {
 	std::size_t strLen = s.bytes();
 	std::ignore = append(s.data(), strLen);
 	return *this;
@@ -384,14 +384,14 @@ constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operat
 
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v> &BasicString<SmallStringSize_v>::operator+=(BasicString const&src) noexcept {
-	std::ignore = append(src.c_str(), src.len());
+	std::ignore = append(src.c_str(), src.size());
 	return *this;
 }
 
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operator+(const char *str) const noexcept {
 	const std::size_t strLen = ox::strlen(str);
-	const auto currentLen = len();
+	const auto currentLen = size();
 	BasicString<SmallStringSize_v> cpy;
 	cpy.m_buff.resize(m_buff.size() + strLen);
 	ox::listcpy(&cpy.m_buff[0], m_buff.data(), currentLen);
@@ -420,8 +420,8 @@ constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operato
 
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operator+(StringViewCR src) const noexcept {
-	const std::size_t strLen = src.len();
-	const auto currentLen = len();
+	const std::size_t strLen = src.size();
+	const auto currentLen = size();
 	BasicString<SmallStringSize_v> cpy(currentLen + strLen);
 	cpy.m_buff.resize(m_buff.size() + strLen);
 	ox::listcpy(&cpy.m_buff[0], m_buff.data(), currentLen);
@@ -432,8 +432,8 @@ constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operato
 
 template<std::size_t SmallStringSize_v>
 constexpr BasicString<SmallStringSize_v> BasicString<SmallStringSize_v>::operator+(BasicString const&src) const noexcept {
-	const std::size_t strLen = src.len();
-	const auto currentLen = len();
+	const std::size_t strLen = src.size();
+	const auto currentLen = size();
 	BasicString<SmallStringSize_v> cpy(currentLen + strLen);
 	cpy.m_buff.resize(m_buff.size() + strLen);
 	ox::listcpy(&cpy.m_buff[0], m_buff.data(), currentLen);
@@ -456,7 +456,7 @@ constexpr bool BasicString<SmallStringSize_v>::operator==(const char *other) con
 
 template<std::size_t SmallStringSize_v>
 constexpr bool BasicString<SmallStringSize_v>::operator==(OxString_c auto const&other) const noexcept {
-	return ox::StringView(*this) == ox::StringView(other);
+	return StringView(*this) == StringView(other);
 }
 
 template<std::size_t SmallStringSize_v>
@@ -521,7 +521,7 @@ constexpr std::size_t BasicString<SmallStringSize_v>::bytes() const noexcept {
 }
 
 template<std::size_t SmallStringSize_v>
-constexpr std::size_t BasicString<SmallStringSize_v>::len() const noexcept {
+constexpr std::size_t BasicString<SmallStringSize_v>::size() const noexcept {
 	return m_buff.size() - 1;
 }
 
@@ -548,28 +548,28 @@ using StringCR = String const&;
 
 
 [[nodiscard]]
-constexpr ox::String toString(ox::StringViewCR sv) noexcept {
+constexpr String toString(StringViewCR sv) noexcept {
 	return ox::String(sv);
 }
 
 
 template<typename PlatSpec, std::size_t SmallStringSize_v>
 [[nodiscard]]
-constexpr auto sizeOf(const ox::BasicString<SmallStringSize_v>*) noexcept {
+constexpr auto sizeOf(BasicString<SmallStringSize_v> const*) noexcept {
 	VectorMemMap<PlatSpec> v{.smallVecSize = SmallStringSize_v};
 	return sizeOf<PlatSpec>(&v);
 }
 
 template<typename PlatSpec, std::size_t SmallStringSize_v>
 [[nodiscard]]
-constexpr auto alignOf(const ox::BasicString<SmallStringSize_v>&) noexcept {
+constexpr auto alignOf(BasicString<SmallStringSize_v> const&) noexcept {
 	VectorMemMap<PlatSpec> v{.smallVecSize = SmallStringSize_v};
 	return alignOf<PlatSpec>(&v);
 }
 
 template<size_t sz>
-struct MaybeView<ox::BasicString<sz>> {
-	using type = ox::StringView;
+struct MaybeView<BasicString<sz>> {
+	using type = StringView;
 };
 
 }

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

@@ -19,7 +19,7 @@ namespace ox {
  */
 class StringLiteral: public detail::BaseStringView {
 	public:
-		consteval StringLiteral() noexcept = default;
+		constexpr StringLiteral() noexcept = default;
 
 		constexpr StringLiteral(StringLiteral const &sv) noexcept = default;
 
@@ -32,7 +32,7 @@ class StringLiteral: public detail::BaseStringView {
 		OX_ALLOW_UNSAFE_BUFFERS_END
 
 		constexpr StringLiteral &operator=(StringLiteral const &other) noexcept {
-			set(other.data(), other.len());
+			set(other.data(), other.size());
 			return *this;
 		}
 

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

@@ -40,10 +40,10 @@ class StringView: public detail::BaseStringView {
 		constexpr StringView(BaseStringView const&str) noexcept: BaseStringView(str.data(), str.bytes()) {}
 
 		template<std::size_t SmallStrSz>
-		constexpr StringView(const BasicString<SmallStrSz> &str) noexcept: BaseStringView(str.data(), str.len()) {}
+		constexpr StringView(const BasicString<SmallStrSz> &str) noexcept: BaseStringView(str.data(), str.size()) {}
 
 		template<std::size_t SmallStrSz>
-		constexpr StringView(const IString<SmallStrSz> &str) noexcept: BaseStringView(str.data(), str.len()) {}
+		constexpr StringView(const IString<SmallStrSz> &str) noexcept: BaseStringView(str.data(), str.size()) {}
 
 		constexpr StringView(std::nullptr_t) noexcept {}
 
@@ -53,7 +53,7 @@ class StringView: public detail::BaseStringView {
 
 		constexpr auto &operator=(StringView const&other) noexcept {
 			if (&other != this) {
-				set(other.data(), other.len());
+				set(other.data(), other.size());
 			}
 			return *this;
 		}
@@ -63,14 +63,14 @@ class StringView: public detail::BaseStringView {
 using StringViewCR = StringView const&;
 
 constexpr auto operator==(StringViewCR s1, StringViewCR s2) noexcept {
-	if (s2.len() != s1.len()) {
+	if (s2.size() != s1.size()) {
 		return false;
 	}
-	return ox::strncmp(s1.data(), s2.data(), s1.len()) == 0;
+	return ox::strncmp(s1.data(), s2.data(), s1.size()) == 0;
 }
 
 constexpr auto operator<=>(StringViewCR s1, StringViewCR s2) noexcept {
-	const auto maxLen = ox::min(s1.len(), s2.len());
+	const auto maxLen = ox::min(s1.size(), s2.size());
 	const auto a = &s1.front();
 	const auto b = &s2.front();
 	for (std::size_t i = 0; i < maxLen && (a[i] || b[i]); ++i) {
@@ -80,9 +80,9 @@ constexpr auto operator<=>(StringViewCR s1, StringViewCR s2) noexcept {
 			return 1;
 		}
 	}
-	if (s1.len() > s2.len()) {
+	if (s1.size() > s2.size()) {
 		return 1;
-	} else if (s1.len() < s2.len()) {
+	} else if (s1.size() < s2.size()) {
 		return -1;
 	} else {
 		return 0;
@@ -104,10 +104,10 @@ constexpr ox::Result<int> strToInt(StringViewCR str) noexcept {
 	OX_ALLOW_UNSAFE_BUFFERS_BEGIN
 	int total = 0;
 	int multiplier = 1;
-	if (str.len() == 0) [[unlikely]] {
+	if (str.size() == 0) [[unlikely]] {
 		return Error{1, "Empty string passed to strToInt"};
 	}
-	for (auto i = static_cast<int64_t>(str.len()) - 1; i != -1; --i) {
+	for (auto i = static_cast<int64_t>(str.size()) - 1; i != -1; --i) {
 		auto s = static_cast<std::size_t>(i);
 		if (str[s] >= '0' && str[s] <= '9') {
 			total += (str[s] - '0') * multiplier;

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

@@ -21,37 +21,47 @@ OX_CLANG_NOWARN_BEGIN(-Wunsafe-buffer-usage)
 namespace ox {
 
 [[nodiscard]]
-constexpr ox::StringView substr(ox::StringView const&str, std::size_t pos) noexcept {
-	if (str.len() >= pos) {
-		return {&str[pos], str.len() - pos};
+constexpr StringView substr(StringViewCR str, std::size_t const pos) noexcept {
+	if (str.size() >= pos) {
+		return {&str[pos], str.size() - pos};
 	}
 	return {};
 }
 
 [[nodiscard]]
-constexpr ox::StringView substr(ox::StringView const&str, std::size_t start, std::size_t end) noexcept {
-	if (str.len() >= start && end >= start) {
+constexpr StringView substr(StringViewCR str, std::size_t const start, std::size_t const end) noexcept {
+	if (str.size() >= start && end >= start) {
 		return {&str[start], end - start};
 	}
 	return {};
 }
 
+[[nodiscard]]
+constexpr bool beginsWith(StringViewCR base, char const beginning) noexcept {
+	return base.size() && base[0] == beginning;
+}
+
+[[nodiscard]]
+constexpr bool endsWith(StringViewCR base, char const ending) noexcept {
+	return base.size() && base[base.size() - 1] == ending;
+}
+
 [[nodiscard]]
 constexpr bool beginsWith(StringViewCR base, StringViewCR beginning) noexcept {
-	const auto beginningLen = ox::min(beginning.len(), base.len());
-	return base.len() >= beginning.len() && ox::strncmp(base.data(), beginning, beginningLen) == 0;
+	const auto beginningLen = ox::min(beginning.size(), base.size());
+	return base.size() >= beginning.size() && ox::strncmp(base.data(), beginning, beginningLen) == 0;
 }
 
 [[nodiscard]]
 constexpr bool endsWith(StringViewCR base, StringViewCR ending) noexcept {
-	const auto endingLen = ending.len();
-	return base.len() >= endingLen && ox::strcmp(base.data() + (base.len() - endingLen), ending) == 0;
+	const auto endingLen = ending.size();
+	return base.size() >= endingLen && ox::strcmp(base.data() + (base.size() - endingLen), ending) == 0;
 }
 
 [[nodiscard]]
-constexpr std::size_t find(StringViewCR str, char search) noexcept {
+constexpr std::size_t find(StringViewCR str, char const search) noexcept {
 	std::size_t i = 0;
-	for (; i < str.len(); ++i) {
+	for (; i < str.size(); ++i) {
 		if (str[i] == search) {
 			break;
 		}
@@ -62,7 +72,7 @@ constexpr std::size_t find(StringViewCR str, char search) noexcept {
 [[nodiscard]]
 constexpr std::size_t find(StringViewCR str, StringViewCR search) noexcept {
 	std::size_t i = 0;
-	for (; i < str.len(); ++i) {
+	for (; i < str.size(); ++i) {
 		if (beginsWith(substr(str, i), search)) {
 			break;
 		}
@@ -72,14 +82,14 @@ constexpr std::size_t find(StringViewCR str, StringViewCR search) noexcept {
 
 template<std::size_t smallSz = 0>
 [[nodiscard]]
-constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, char del) noexcept {
+constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, char const del) noexcept {
 	ox::Vector<ox::StringView, smallSz> out;
 	constexpr auto nextSeg = [](StringViewCR current, char del) {
 		return substr(current, find(current, del) + 1);
 	};
-	for (auto current = str; current.len(); current = nextSeg(current, del)) {
+	for (auto current = str; current.size(); current = nextSeg(current, del)) {
 		const auto next = find(current, del);
-		if (const auto s = substr(current, 0, next); s.len()) {
+		if (const auto s = substr(current, 0, next); s.size()) {
 			out.emplace_back(s);
 		}
 		current = substr(current, next);
@@ -92,11 +102,11 @@ template<std::size_t smallSz = 0>
 constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, StringViewCR del) noexcept {
 	ox::Vector<ox::StringView, smallSz> out;
 	constexpr auto nextSeg = [](StringViewCR current, StringViewCR del) {
-		return substr(current, find(current, del) + del.len());
+		return substr(current, find(current, del) + del.size());
 	};
-	for (auto current = str; current.len(); current = nextSeg(current, del)) {
+	for (auto current = str; current.size(); current = nextSeg(current, del)) {
 		const auto next = find(current, del);
-		if (const auto s = substr(current, 0, next); s.len()) {
+		if (const auto s = substr(current, 0, next); s.size()) {
 			out.emplace_back(s);
 		}
 		current = substr(current, next);
@@ -105,7 +115,7 @@ constexpr ox::Vector<ox::StringView, smallSz> split(StringViewCR str, StringView
 }
 
 [[nodiscard]]
-constexpr ox::Result<std::size_t> lastIndexOf(ox::StringViewCR str, int character) noexcept {
+constexpr ox::Result<std::size_t> lastIndexOf(ox::StringViewCR str, int const character) noexcept {
 	ox::Result<std::size_t> retval = ox::Error(1, "Character not found");
 	for (auto i = static_cast<int>(str.bytes() - 1); i >= 0; --i) {
 		if (str[static_cast<std::size_t>(i)] == character) {

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

@@ -183,7 +183,7 @@ OX_CLANG_NOWARN_END
 			s = "asdf";
 			oxAssert(s == "asdf", "String assign broken");
 			oxAssert(s != "aoeu", "String assign broken");
-			oxAssert(s.len() == 4, "String assign broken");
+			oxAssert(s.size() == 4, "String assign broken");
 			return ox::Error(0);
 		}
 	},

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

@@ -166,7 +166,7 @@ class OutStream {
 		constexpr OutStream &operator<<(Integer_c auto v) noexcept;
 
 		constexpr OutStream &operator<<(char v) noexcept {
-			if (m_msg.msg.len()) {
+			if (m_msg.msg.size()) {
 				m_msg.msg += m_delimiter;
 			}
 			m_msg.msg += v;
@@ -174,7 +174,7 @@ class OutStream {
 		}
 
 		constexpr OutStream &operator<<(StringViewCR v) noexcept {
-			if (m_msg.msg.len()) {
+			if (m_msg.msg.size()) {
 				m_msg.msg += m_delimiter;
 			}
 			m_msg.msg += v;
@@ -209,7 +209,7 @@ class OutStream {
 
 	private:
 		constexpr OutStream &appendSignedInt(int64_t v) noexcept {
-			if (m_msg.msg.len()) {
+			if (m_msg.msg.size()) {
 				m_msg.msg += m_delimiter;
 			}
 			m_msg.msg += static_cast<int64_t>(v);
@@ -217,7 +217,7 @@ class OutStream {
 		}
 
 		constexpr OutStream &appendUnsignedInt(uint64_t v) noexcept {
-			if (m_msg.msg.len()) {
+			if (m_msg.msg.size()) {
 				m_msg.msg += m_delimiter;
 			}
 			m_msg.msg += static_cast<int64_t>(v);
@@ -227,7 +227,7 @@ class OutStream {
 };
 
 constexpr OutStream &OutStream::operator<<(Integer_c auto v) noexcept {
-	if (m_msg.msg.len()) {
+	if (m_msg.msg.size()) {
 		m_msg.msg += m_delimiter;
 	}
 	m_msg.msg += v;

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

@@ -58,7 +58,7 @@ constexpr ox::Result<uint8_t> fromHex(ox::StringViewCR v) noexcept {
 	if (!detail::isHexChar(v[0]) || !detail::isHexChar(v[1])) {
 		return ox::Error(1, "Invalid UUID");
 	}
-	if (v.len() != 2) {
+	if (v.size() != 2) {
 		return ox::Error(2);
 	}
 	uint8_t out = 0;
@@ -133,18 +133,18 @@ class UUID {
 		}
 
 		static constexpr ox::Result<ox::UUID> fromString(ox::StringViewCR s) noexcept {
-			if (s.len() < 36) {
+			if (s.size() < 36) {
 				return ox::Error(1, "Insufficient data to contain a complete UUID");
 			}
 			UUID out;
 			auto valueI = 0u;
-			for (size_t i = 0; i < s.len();) {
+			for (size_t i = 0; i < s.size();) {
 				if (s[i] == '-') {
 					++i;
 					continue;
 				}
 				const auto seg = substr(s, i, i + 2);
-				if (seg.len() != 2) {
+				if (seg.size() != 2) {
 					return ox::Error(1, "Invalid UUID");
 				}
 				OX_REQUIRE(val, detail::fromHex(seg));
@@ -174,7 +174,7 @@ class UUID {
 				for (auto i = 0u; i < cnt; ++i) {
 					const auto v = value[valueI];
 					const auto h = detail::toHex(v);
-					std::ignore = writer.write(h.c_str(), h.len());
+					std::ignore = writer.write(h.c_str(), h.size());
 					++valueI;
 				}
 			};

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

@@ -87,7 +87,9 @@ struct VectorAllocator {
 		constexpr void deallocate(T *items, std::size_t cap) noexcept {
 			// small vector optimization cannot be done it constexpr, but it doesn't really matter in constexpr
 			if (std::is_constant_evaluated()) {
-				Allocator{}.deallocate(items, cap);
+				if (items) {
+					Allocator{}.deallocate(items, cap);
+				}
 			} else {
 				if (items && static_cast<void*>(items) != static_cast<void*>(m_data.data())) {
 					Allocator{}.deallocate(items, cap);

deps/teagba/include/teagba/addresses.hpp

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

deps/teagba/include/teagba/gfx.hpp

@@ -41,4 +41,8 @@ void addSpriteUpdate(GbaSpriteAttrUpdate const &upd) noexcept;
 
 void applySpriteUpdates() noexcept;
 
+void setBgOffset(uint16_t bg, int16_t x, int16_t y) noexcept;
+
+void scrollBgOffset(uint16_t bg, int16_t x, int16_t y) noexcept;
+
 }

deps/teagba/src/gfx.cpp

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

release-notes.md

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

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

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

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

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

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

@@ -168,9 +168,9 @@ OX_MODEL_BEGIN(PaletteV3)
 OX_MODEL_END()
 
 [[nodiscard]]
-constexpr bool valid(PaletteV3 const&p) noexcept {
+constexpr bool valid(PaletteV3 const &p) noexcept {
 	auto const colors = p.colorInfo.size();
-	return ox::all_of(p.pages.begin(), p.pages.end(), [colors](auto const&page) {
+	return ox::all_of(p.pages.begin(), p.pages.end(), [colors](auto const &page) {
 		return page.size() == colors;
 	});
 }
@@ -198,9 +198,9 @@ OX_MODEL_BEGIN(PaletteV4)
 OX_MODEL_END()
 
 [[nodiscard]]
-constexpr bool valid(PaletteV4 const&p) noexcept {
+constexpr bool valid(PaletteV4 const &p) noexcept {
 	auto const colors = p.colorNames.size();
-	return ox::all_of(p.pages.begin(), p.pages.end(), [colors](PalettePageV1 const&page) {
+	return ox::all_of(p.pages.begin(), p.pages.end(), [colors](PalettePageV1 const &page) {
 		return page.colors.size() == colors;
 	});
 }

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

@@ -11,7 +11,7 @@
 namespace nostalgia::gfx {
 
 [[nodiscard]]
-constexpr std::size_t ptToIdx(int x, int y, int c, int scale = 1) noexcept {
+constexpr std::size_t ptToIdx(int const x, int const y, int const c, int const scale = 1) noexcept {
 	auto const tileWidth = TileWidth * scale;
 	auto const tileHeight = TileHeight * scale;
 	auto const pixelsPerTile = tileWidth * tileHeight;
@@ -25,12 +25,12 @@ constexpr std::size_t ptToIdx(int x, int y, int c, int scale = 1) noexcept {
 }
 
 [[nodiscard]]
-constexpr std::size_t ptToIdx(const ox::Point &pt, int c, int scale = 1) noexcept {
+constexpr std::size_t ptToIdx(ox::Point const &pt, int const c, int const scale = 1) noexcept {
 	return ptToIdx(pt.x, pt.y, c * TileWidth, scale);
 }
 
 [[nodiscard]]
-constexpr ox::Point idxToPt(int i, int c, int scale = 1) noexcept {
+constexpr ox::Point idxToPt(int const i, int c, int const scale = 1) noexcept {
 	auto const tileWidth = TileWidth * scale;
 	auto const tileHeight = TileHeight * scale;
 	auto const pixelsPerTile = tileWidth * tileHeight;

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

@@ -30,7 +30,7 @@ struct TileSheetV1 {
 };
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV1 const&ts) noexcept {
+constexpr bool valid(TileSheetV1 const &ts) noexcept {
 	auto const bytes = static_cast<size_t>(ts.columns * ts.rows * PixelsPerTile) / (ts.bpp == 4 ? 2 : 1);
 	return (ts.bpp == 4 || ts.bpp == 8) && ts.pixels.size() == bytes;
 }
@@ -71,16 +71,16 @@ struct TileSheetV2 {
 };
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV2::SubSheet const&ss, int bpp) noexcept {
+constexpr bool valid(TileSheetV2::SubSheet const &ss, int bpp) noexcept {
 	auto const bytes = static_cast<size_t>(ss.columns * ss.rows * PixelsPerTile) / (bpp == 4 ? 2 : 1);
 	return ox::all_of(ss.subsheets.begin(), ss.subsheets.end(),
-			[bpp, bytes](TileSheetV2::SubSheet const&s) {
+			[bpp, bytes](TileSheetV2::SubSheet const &s) {
 		return bytes == s.pixels.size() && valid(s, bpp);
 	});
 }
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV2 const&ts) noexcept {
+constexpr bool valid(TileSheetV2 const &ts) noexcept {
 	return (ts.bpp == 4 || ts.bpp == 8) && valid(ts.subsheet, ts.bpp);
 }
 
@@ -141,16 +141,16 @@ struct TileSheetV3 {
 };
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV3::SubSheet const&ss, int bpp) noexcept {
+constexpr bool valid(TileSheetV3::SubSheet const &ss, int bpp) noexcept {
 	auto const bytes = static_cast<size_t>(ss.columns * ss.rows * PixelsPerTile) / (bpp == 4 ? 2 : 1);
 	return ox::all_of(ss.subsheets.begin(), ss.subsheets.end(),
-			[bpp, bytes](TileSheetV3::SubSheet const&s) {
+			[bpp, bytes](TileSheetV3::SubSheet const &s) {
 		return bytes == s.pixels.size() && valid(s, bpp);
 	});
 }
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV3 const&ts) noexcept {
+constexpr bool valid(TileSheetV3 const &ts) noexcept {
 	return (ts.bpp == 4 || ts.bpp == 8) && valid(ts.subsheet, ts.bpp);
 }
 
@@ -233,18 +233,18 @@ struct TileSheetV4 {
 };
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV4::SubSheet const&ss, int bpp) noexcept {
+constexpr bool valid(TileSheetV4::SubSheet const &ss, int bpp) noexcept {
 	auto const bytes = static_cast<size_t>(ss.columns * ss.rows * PixelsPerTile) / (bpp == 4 ? 2 : 1);
 	return
 		(ss.pixels.empty() || ss.subsheets.empty()) &&
 		ox::all_of(ss.subsheets.begin(), ss.subsheets.end(),
-				[bpp, bytes](TileSheetV4::SubSheet const&s) {
+				[bpp, bytes](TileSheetV4::SubSheet const &s) {
 			return bytes == s.pixels.size() && valid(s, bpp);
 		});
 }
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV4 const&ts) noexcept {
+constexpr bool valid(TileSheetV4 const &ts) noexcept {
 	return (ts.bpp == 4 || ts.bpp == 8) && valid(ts.subsheet, ts.bpp);
 }
 
@@ -334,19 +334,19 @@ struct TileSheetV5 {
 };
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV5::SubSheet const&ss) noexcept {
+constexpr bool valid(TileSheetV5::SubSheet const &ss) noexcept {
 	if (ss.subsheets.empty()) {
 		return std::cmp_equal(ss.columns * ss.rows * PixelsPerTile, ss.pixels.size());
 	} else {
 		return ss.pixels.empty() && ox::all_of(ss.subsheets.begin(), ss.subsheets.end(),
-				[](TileSheetV5::SubSheet const&s) {
+				[](TileSheetV5::SubSheet const &s) {
 			return valid(s);
 		});
 	}
 }
 
 [[nodiscard]]
-constexpr bool valid(TileSheetV5 const&ts) noexcept {
+constexpr bool valid(TileSheetV5 const &ts) noexcept {
 	return (ts.bpp == 4 || ts.bpp == 8) && valid(ts.subsheet);
 }
 
@@ -376,24 +376,24 @@ constexpr ox::Error repair(TileSheetV5 &ts) noexcept {
 using TileSheet = TileSheetV5;
 
 [[nodiscard]]
-std::size_t idx(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept;
+std::size_t idx(TileSheet::SubSheet const &ss, ox::Point const &pt) noexcept;
 
 [[nodiscard]]
-size_t getTileCnt(TileSheet const&ts) noexcept;
+size_t getTileCnt(TileSheet const &ts) noexcept;
 
 [[nodiscard]]
-TileSheet::SubSheet const*getSubsheet(TileSheet const&ts, SubSheetId id) noexcept;
+TileSheet::SubSheet const*getSubsheet(TileSheet const &ts, SubSheetId id) noexcept;
 
 [[nodiscard]]
-ox::Optional<size_t> getTileIdx(TileSheet const&ts, SubSheetId id) noexcept;
+ox::Optional<size_t> getTileIdx(TileSheet const &ts, SubSheetId id) noexcept;
 
 [[nodiscard]]
-uint8_t getPixel(TileSheet::SubSheet const&ss, std::size_t idx) noexcept;
+uint8_t getPixel(TileSheet::SubSheet const &ss, std::size_t idx) noexcept;
 
 [[nodiscard]]
-uint8_t getPixel(TileSheet::SubSheet const&ss, ox::Point const&pt) noexcept;
+uint8_t getPixel(TileSheet::SubSheet const &ss, ox::Point const &pt) noexcept;
 
-void setPixel(TileSheet::SubSheet &ss, ox::Point const&pt, uint8_t palIdx) noexcept;
+void setPixel(TileSheet::SubSheet &ss, ox::Point const &pt, uint8_t palIdx) noexcept;
 
 ox::Error setPixelCount(TileSheet::SubSheet &ss, std::size_t cnt) noexcept;
 
@@ -406,14 +406,14 @@ void flipY(TileSheet::SubSheet &ss, ox::Point const &a, ox::Point const &b) noex
  * @return a count of the pixels in this sheet
  */
 [[nodiscard]]
-unsigned pixelCnt(TileSheet::SubSheet const&ss) noexcept;
+unsigned pixelCnt(TileSheet::SubSheet const &ss) noexcept;
 
 /**
  *
  * @param ss
  * @param sz size of Subsheet in tiles (not pixels)
  */
-ox::Error resizeSubsheet(TileSheet::SubSheet &ss, ox::Size const&sz) noexcept;
+ox::Error resizeSubsheet(TileSheet::SubSheet &ss, ox::Size const &sz) noexcept;
 
 /**
  * validateSubSheetIdx takes a SubSheetIdx and moves the index to the
@@ -424,7 +424,7 @@ ox::Error resizeSubsheet(TileSheet::SubSheet &ss, ox::Size const&sz) noexcept;
  * @return a valid version of idx
  */
 [[nodiscard]]
-TileSheet::SubSheetIdx validateSubSheetIdx(TileSheet const&ts, TileSheet::SubSheetIdx idx) noexcept;
+TileSheet::SubSheetIdx validateSubSheetIdx(TileSheet const &ts, TileSheet::SubSheetIdx idx) noexcept;
 
 ox::Result<TileSheet::SubSheetIdx> getSubSheetIdx(TileSheet const &ts, SubSheetId pId) noexcept;
 
@@ -438,7 +438,7 @@ ox::Result<TileSheet::SubSheet const*> getSubSheet(
 
 [[nodiscard]]
 TileSheet::SubSheet &getSubSheet(
-		ox::SpanView<uint32_t> const&idx,
+		ox::SpanView<uint32_t> const &idx,
 		std::size_t idxIt,
 		TileSheet::SubSheet &pSubsheet) noexcept;
 
@@ -447,7 +447,7 @@ TileSheet::SubSheet &getSubSheet(
 #pragma GCC diagnostic ignored "-Wdangling-reference"
 #endif
 [[nodiscard]]
-TileSheet::SubSheet const&getSubSheet(TileSheet const&ts, ox::SpanView<uint32_t> const &idx) noexcept;
+TileSheet::SubSheet const &getSubSheet(TileSheet const &ts, ox::SpanView<uint32_t> const &idx) noexcept;
 
 [[nodiscard]]
 TileSheet::SubSheet &getSubSheet(TileSheet &ts, ox::SpanView<uint32_t> const &idx) noexcept;
@@ -461,27 +461,29 @@ ox::Error insertSubSheet(TileSheet &ts, ox::SpanView<uint32_t> const &idx, TileS
 
 ox::Error rmSubSheet(
 		TileSheet &ts,
-		TileSheet::SubSheetIdx const&idx,
+		TileSheet::SubSheetIdx const &idx,
 		std::size_t idxIt,
 		TileSheet::SubSheet &pSubsheet) noexcept;
 
-ox::Error rmSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const&idx) noexcept;
+ox::Error rmSubSheet(TileSheet &ts, TileSheet::SubSheetIdx const &idx) noexcept;
 
 [[nodiscard]]
 uint8_t getPixel(
-		TileSheet const&ts,
-		ox::Point const&pt,
-		TileSheet::SubSheetIdx const&subsheetIdx) noexcept;
+		TileSheet const &ts,
+		ox::Point const &pt,
+		TileSheet::SubSheetIdx const &subsheetIdx) noexcept;
 
-ox::Result<SubSheetId> getIdFor(TileSheet const&ts, ox::StringViewCR path) noexcept;
+ox::Result<SubSheetId> getIdFor(TileSheet const &ts, ox::StringViewCR path) noexcept;
 
-ox::Result<unsigned> getTileOffset(TileSheet const&ts, ox::StringViewCR pNamePath) noexcept;
+ox::Result<unsigned> getTileOffset(TileSheet const &ts, ox::StringViewCR pNamePath) noexcept;
 
-ox::Result<uint32_t> getTileOffset(TileSheet const&ts, SubSheetId pId) noexcept;
+ox::Result<uint32_t> getTileOffset(TileSheet const &ts, SubSheetId pId) noexcept;
 
-ox::Result<ox::StringView> getNameFor(TileSheet::SubSheet const&ss, SubSheetId pId) noexcept;
+ox::Result<ox::StringView> getNameFor(TileSheet::SubSheet const &ss, SubSheetId pId) noexcept;
 
-ox::Result<ox::StringView> getNameFor(TileSheet const&ts, SubSheetId pId) noexcept;
+ox::Result<ox::StringView> getNameFor(TileSheet &ts, SubSheetId pId) noexcept;
+
+ox::Result<ox::StringView> getNameFor(TileSheet const &ts, SubSheetId pId) noexcept;
 
 [[nodiscard]]
 ox::Vector<uint8_t> pixels(TileSheet &ts) noexcept;
@@ -497,7 +499,7 @@ struct CompactTileSheetV1 {
 };
 
 [[nodiscard]]
-constexpr bool valid(CompactTileSheetV1 const&ts) noexcept {
+constexpr bool valid(CompactTileSheetV1 const &ts) noexcept {
 	return ts.bpp == 4 || ts.bpp == 8;
 }
 
@@ -506,22 +508,22 @@ using CompactTileSheet = CompactTileSheetV1;
 
 [[nodiscard]]
 uint8_t getPixel4Bpp(
-		CompactTileSheet const&ts,
+		CompactTileSheet const &ts,
 		size_t idx) noexcept;
 
 [[nodiscard]]
 uint8_t getPixel8Bpp(
-		CompactTileSheet const&ts,
+		CompactTileSheet const &ts,
 		size_t idx) noexcept;
 
 [[nodiscard]]
 ox::Pair<uint8_t> get2Pixels4Bpp(
-		CompactTileSheet const&ts,
+		CompactTileSheet const &ts,
 		size_t idx) noexcept;
 
 [[nodiscard]]
 ox::Pair<uint8_t> get2Pixels8Bpp(
-		CompactTileSheet const&ts,
+		CompactTileSheet const &ts,
 		size_t idx) noexcept;
 
 OX_MODEL_BEGIN(TileSheetV1)
@@ -601,8 +603,8 @@ OX_MODEL_BEGIN(CompactTileSheetV1)
 OX_MODEL_END()
 
 ox::Vector<uint32_t> resizeTileSheetData(
-		ox::Vector<uint32_t> const&srcPixels,
-		ox::Size const&srcSize,
+		ox::Vector<uint32_t> const &srcPixels,
+		ox::Size const &srcSize,
 		int scale = 2) noexcept;
 
 }

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

@@ -169,8 +169,8 @@ ox::Error loadBgTileSheet(
 		unsigned const cbb,
 		CompactTileSheet const &ts,
 		ox::Optional<unsigned> const &paletteBank) noexcept {
-	auto const cnt = (ts.pixels.size() * PixelsPerTile) / (1 + (ts.bpp == 4));
-	for (size_t i = 0; i < cnt; ++i) {
+	auto const cnt = ts.pixels.size() >> (ts.bpp == 4);
+	for (size_t i{}; i < cnt; ++i) {
 		auto const srcIdx = i * 2;
 		auto const p1 = static_cast<uint16_t>(ts.pixels[srcIdx]);
 		auto const p2 = static_cast<uint16_t>(ts.pixels[srcIdx + 1]);
@@ -218,10 +218,11 @@ ox::Error loadSpriteTileSheet(
 		Context &ctx,
 		CompactTileSheet const &ts,
 		bool const loadDefaultPalette) noexcept {
-	for (size_t i = 0; i < ts.pixels.size(); i += 2) {
-		uint16_t v = ts.pixels[i];
-		v |= static_cast<uint16_t>(ts.pixels[i + 1] << 8);
-		MEM_SPRITE_TILES[i] = v;
+	for (size_t i{}; i < ts.pixels.size(); i += 2) {
+		MEM_SPRITE_TILES[i >> 1] =
+			static_cast<uint16_t>(
+				ts.pixels[i] |
+				(static_cast<uint16_t>(ts.pixels[i + 1]) << 8));
 	}
 	if (loadDefaultPalette && ts.defaultPalette) {
 		OX_RETURN_ERROR(loadSpritePalette(ctx, ts.defaultPalette));
@@ -294,6 +295,14 @@ void setBgPriority(Context&, uint_t const bgIdx, uint_t const priority) noexcept
 	bgCtl = (bgCtl & 0b1111'1111'1111'1100u) | (priority & 0b11);
 }
 
+void setBgOffset(Context&, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+	teagba::setBgOffset(bg, x, y);
+}
+
+void scrollBgOffset(Context&, uint16_t const bg, int16_t const x, int16_t const y) noexcept {
+	teagba::scrollBgOffset(bg, x, y);
+}
+
 void hideSprite(Context&, unsigned const idx) noexcept {
 	//oxAssert(g_spriteUpdates < config::GbaSpriteBufferLen, "Sprite update buffer overflow");
 	teagba::addSpriteUpdate({

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

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

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

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

src/nostalgia/modules/gfx/src/studio/subcommands/CMakeLists.txt

@@ -2,4 +2,9 @@
 target_sources(
 	NostalgiaGfx-Studio PRIVATE
         export-tilesheet/export-tilesheet.cpp
+)
+
+target_link_libraries(
+	NostalgiaGfx-Studio PUBLIC
+		OxClArgs
 )

src/nostalgia/modules/gfx/src/studio/subcommands/export-tilesheet/export-tilesheet.cpp

@@ -14,6 +14,7 @@
 
 #include "export-tilesheet.hpp"
 
+#include "nostalgia/gfx/tilesheet.hpp"
 #include "studio/context.hpp"
 
 
@@ -71,6 +72,32 @@ static ox::Error toPngFile(
 					8)));
 }
 
+ox::Error exportSubsheetToPng(
+	TileSheet::SubSheet const &s,
+	Palette const &pal,
+	size_t const palPage,
+	ox::CStringViewCR dstPath,
+	int const scale) noexcept {
+	// subsheet to png
+	auto const width = s.columns * TileWidth;
+	auto const height = s.rows * TileHeight;
+	auto const err = toPngFile(
+			dstPath,
+			normalizePixelArrangement(
+				normalizePixelSizes(s.pixels),
+				s.columns,
+				scale),
+			pal,
+			palPage,
+			static_cast<unsigned>(width * scale),
+			static_cast<unsigned>(height * scale));
+	if (err) {
+		oxErrorf("TileSheet export failed: {}", toStr(err));
+		return ox::Error{7, "TileSheet export failed"};
+	}
+	return {};
+}
+
 ox::Error exportSubsheetToPng(
 	TileSheet const &src,
 	Palette const &pal,
@@ -84,23 +111,12 @@ ox::Error exportSubsheetToPng(
 	if (ssErr) {
 		return ox::Error{6, "failed to find SubSheet"};
 	}
-	auto const width = s->columns * TileWidth;
-	auto const height = s->rows * TileHeight;
-	auto const err = toPngFile(
-			dstPath,
-			normalizePixelArrangement(
-				normalizePixelSizes(s->pixels),
-				s->columns,
-				scale),
-			pal,
-			palPage,
-			static_cast<unsigned>(width * scale),
-			static_cast<unsigned>(height * scale));
-	if (err) {
-		oxErrorf("TileSheet export failed: {}", toStr(err));
-		return ox::Error{7, "TileSheet export failed"};
-	}
-	return {};
+	return exportSubsheetToPng(
+		*s,
+		pal,
+		palPage,
+		dstPath,
+		scale);
 }
 
 ox::Error cmdExportTilesheet(studio::Project &project, ox::SpanView<ox::CString> const args) noexcept {
@@ -117,17 +133,20 @@ ox::Error cmdExportTilesheet(studio::Project &project, ox::SpanView<ox::CString>
 				"[-scale <int>]\n");
 		}
 	};
+	if (args.empty()) {
+		return {};
+	}
 	OX_REQUIRE(srcPath, clargs.getString("src-path").transformError(1, "no src path specified"));
 	OX_REQUIRE(dstPath, clargs.getString("dst-path").transformError(2, "no dst path specified"));
 	auto const palPath = clargs.getString("pal-path", "");
-	auto const subsheetPath = clargs.getString("subsheet-path").or_value({});
+	auto const subsheetPath = clargs.getString("subsheet-path").or_value(ox::String{"Root"});
 	auto const palPage = static_cast<size_t>(clargs.getInt("pal-page", 0));
 	auto const scale = clargs.getInt("scale", 1);
 	showUsage = false;
 	// load objects
 	auto &kctx = project.kctx();
 	OX_REQUIRE(ts, keel::readObj<TileSheet>(kctx, srcPath).transformError(4, "could not load TileSheet"));
-	OX_REQUIRE(pal, keel::readObj<Palette>(kctx, palPath.len() ? palPath : ts->defaultPalette)
+	OX_REQUIRE(pal, keel::readObj<Palette>(kctx, palPath.size() ? palPath : ts->defaultPalette)
 		.transformError(5, "could not load Palette"));
 	// export to the destination file
 	return exportSubsheetToPng(

src/nostalgia/modules/gfx/src/studio/subcommands/export-tilesheet/export-tilesheet.hpp

@@ -8,6 +8,13 @@
 
 namespace nostalgia::gfx {
 
+ox::Error exportSubsheetToPng(
+	TileSheet::SubSheet const &s,
+	Palette const &pal,
+	size_t palPage,
+	ox::CStringViewCR dstPath,
+	int scale) noexcept;
+
 ox::Error exportSubsheetToPng(
 	TileSheet const &src,
 	Palette const &pal,

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

@@ -11,6 +11,7 @@
 
 #include <nostalgia/gfx/studio.hpp>
 
+#include "../subcommands/export-tilesheet/export-tilesheet.hpp"
 #include "tilesheeteditor-imgui.hpp"
 
 namespace nostalgia::gfx {
@@ -37,58 +38,6 @@ OX_MODEL_BEGIN(TileSheetEditorConfig)
 	OX_MODEL_FIELD_RENAME(activeSubsheet, active_subsheet)
 OX_MODEL_END()
 
-static ox::Vector<uint32_t> normalizePixelSizes(
-		ox::Vector<uint8_t> const &inPixels) noexcept {
-	ox::Vector<uint32_t> outPixels;
-	outPixels.reserve(inPixels.size());
-	outPixels.resize(inPixels.size());
-	for (std::size_t i = 0; i < inPixels.size(); ++i) {
-		outPixels[i] = inPixels[i];
-	}
-	return outPixels;
-}
-
-static ox::Vector<uint32_t> normalizePixelArrangement(
-		ox::Vector<uint32_t> const &inPixels,
-		int const cols,
-		int const scale) {
-	auto const scalePt = ox::Point{scale, scale};
-	auto const width = cols * TileWidth;
-	auto const height = static_cast<int>(inPixels.size()) / width;
-	auto const dstWidth = width * scale;
-	ox::Vector<uint32_t> outPixels(static_cast<size_t>((width * scale) * (height * scale)));
-	for (std::size_t dstIdx = 0; dstIdx < outPixels.size(); ++dstIdx) {
-		auto const dstPt = ox::Point{
-			static_cast<int>(dstIdx) % dstWidth,
-			static_cast<int>(dstIdx) / dstWidth};
-		auto const srcPt = dstPt / scalePt;
-		auto const srcIdx = ptToIdx(srcPt, cols);
-		outPixels[dstIdx] = inPixels[srcIdx];
-	}
-	return outPixels;
-}
-
-static ox::Error toPngFile(
-		ox::CStringViewCR path,
-		ox::Vector<uint32_t> &&pixels,
-		Palette const &pal,
-		size_t const page,
-		unsigned const width,
-		unsigned const height) noexcept {
-	for (auto &c : pixels) {
-		c = color32(color(pal, page, c)) | static_cast<Color32>(0XFF << 24);
-	}
-	constexpr auto fmt = LCT_RGBA;
-	return ox::Error(static_cast<ox::ErrorCode>(
-			lodepng_encode_file(
-					path.c_str(),
-					reinterpret_cast<uint8_t const*>(pixels.data()),
-					width,
-					height,
-					fmt,
-					8)));
-}
-
 TileSheetEditorImGui::TileSheetEditorImGui(studio::Context &sctx, ox::StringParam path):
 		Editor{sctx, std::move(path)},
 		m_sctx{sctx},
@@ -421,21 +370,7 @@ ox::Error TileSheetEditorImGui::exportSubsheetToPng(int const scale) const noexc
 	// subsheet to png
 	auto const &s = m_model.activeSubSheet();
 	auto const &pal = m_model.pal();
-	auto const width = s.columns * TileWidth;
-	auto const height = s.rows * TileHeight;
-	auto pixels = normalizePixelSizes(s.pixels);
-	pixels = normalizePixelArrangement(pixels, s.columns, scale);
-	auto const err = toPngFile(
-			path,
-			std::move(pixels),
-			pal,
-			m_model.palettePage(),
-			static_cast<unsigned>(width * scale),
-			static_cast<unsigned>(height * scale));
-	if (err) {
-		oxErrorf("TileSheet export failed: {}", toStr(err));
-	}
-	return err;
+	return gfx::exportSubsheetToPng(s, pal, m_model.palettePage(), path, scale);
 }
 
 void TileSheetEditorImGui::drawTileSheet(ox::Vec2 const &fbSize) noexcept {

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

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

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

@@ -236,13 +236,19 @@ static ox::Result<SubSheet*> getSubSheet(
 ox::Result<TileSheet::SubSheet const*> getSubSheet(
 		ox::SpanView<ox::StringView> const &idx,
 		TileSheet const &ts) noexcept {
-	return getSubSheet<TileSheet::SubSheet const>(idx, 1, ts.subsheet);
+	if (!idx.empty() && idx[0] == ts.subsheet.name) {
+		return getSubSheet<TileSheet::SubSheet const>(idx, 1, ts.subsheet);
+	}
+	return ox::Error{1, "SubSheet not found"};
 }
 
 ox::Result<TileSheet::SubSheet*> getSubSheet(
 		ox::SpanView<ox::StringView> const &idx,
 		TileSheet &ts) noexcept {
-	return getSubSheet<TileSheet::SubSheet>(idx, 1, ts.subsheet);
+	if (!idx.empty() && idx[0] == ts.subsheet.name) {
+		return getSubSheet<TileSheet::SubSheet>(idx, 1, ts.subsheet);
+	}
+	return ox::Error{1, "SubSheet not found"};
 }
 
 

src/nostalgia/modules/sound/src/studio/studiomodule.cpp

@@ -10,6 +10,10 @@ namespace nostalgia::sound {
 
 static struct: studio::Module {
 
+	ox::String id() const noexcept final {
+		return ox::String{"net.drinkingtea.nostalgia.sound"};
+	}
+
 	ox::Vector<studio::EditorMaker> editors(studio::Context&) const noexcept final {
 		return {
 		};
@@ -22,7 +26,7 @@ static struct: studio::Module {
 
 } const mod;
 
-const studio::Module *studioModule() noexcept {
+studio::Module const *studioModule() noexcept {
 	return &mod;
 }
 

src/nostalgia/player/app.cpp

@@ -38,7 +38,7 @@ static int testUpdateHandler(turbine::Context &tctx) noexcept {
 	spriteX += xmod;
 	spriteY += ymod;
 	constexpr ox::StringView sprites = "nostalgia";
-	for (unsigned i = 0; i < sprites.len(); ++i) {
+	for (unsigned i = 0; i < sprites.size(); ++i) {
 		auto const c = static_cast<unsigned>(sprites[i] - ('a' - 1));
 		gfx::setSprite(cctx, i, {
 			.enabled = true,

src/nostalgia/studio/CMakeLists.txt

@@ -15,7 +15,7 @@ target_link_libraries(
 
 target_compile_definitions(
 	NostalgiaStudio PUBLIC
-		OLYMPIC_APP_VERSION="dev build"
+		OLYMPIC_APP_VERSION="d2025.07.0"
 )
 
 install(

src/nostalgia/studio/Info.plist

@@ -18,7 +18,7 @@
 	<string>APPL</string>
 
 	<key>CFBundleVersion</key>
-	<string>dev build</string>
+	<string>d2025.07.0</string>
 
 	<key>LSMinimumSystemVersion</key>
 	<string>12.0.0</string>

src/olympic/CMakeLists.txt

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

src/olympic/applib/CMakeLists.txt

@@ -3,6 +3,11 @@ add_library(
     OlympicApplib INTERFACE
 )
 
+target_link_libraries(
+    OlympicApplib INTERFACE
+        OxLogConn
+)
+
 target_sources(
     OlympicApplib INTERFACE
         applib.cpp

src/olympic/hull/CMakeLists.txt

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

src/olympic/hull/hull.cpp

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

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

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

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

@@ -64,11 +64,13 @@ class AssetContainer {
 
 	protected:
 		constexpr void incRefs() const noexcept {
+			oxAssert(m_references < ox::MaxValue<decltype(m_references)>, "reference count exceeds maximum");
 			++m_references;
 		}
 
 		constexpr void decRefs() const noexcept {
 			--m_references;
+			oxAssert(m_references >= 0, "negative references");
 		}
 
 		[[nodiscard]]
@@ -162,6 +164,7 @@ template<typename T>
 constexpr AssetRef<T>::AssetRef(AssetContainer<T> const*c) noexcept: m_ctr(c) {
 	if (m_ctr) {
 		m_ctr->updated.connect(this, &AssetRef::emitUpdated);
+		m_ctr->incRefs();
 	}
 }
 

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

@@ -140,7 +140,7 @@ class ConverterFunc final: public BaseConverter {
 	private:
 		template<typename SrcType, typename DstType>
 		struct ParamPack {
-			using Src = SrcType;
+			using Src = ox::remove_const_t<SrcType>;
 			using Dst = DstType;
 		};
 

src/olympic/keel/src/media.cpp

@@ -59,7 +59,7 @@ static ox::Error buildUuidMap(Context &ctx, ox::StringViewCR path, DuplicateSet
 			auto const [uuid, err] = readUuidHeader(buff);
 			if (!err) {
 				// check for duplication
-				if (duplicates && ctx.uuidToPath[uuid.toString()].len()) {
+				if (duplicates && ctx.uuidToPath[uuid.toString()].size()) {
 					auto &dl = (*duplicates)[uuid];
 					if (dl.empty()) {
 						dl.emplace_back(ctx.uuidToPath[uuid.toString()]);
@@ -261,6 +261,9 @@ namespace keel {
 ox::Error setRomFs(Context &ctx, ox::UPtr<ox::FileSystem> &&fs, DuplicateSet &duplicateSet) noexcept {
 	ctx.rom = std::move(fs);
 	clearUuidMap(ctx);
+#ifndef OX_BARE_METAL
+	ctx.assetManager.gc();
+#endif
 	return buildUuidMap(ctx, &duplicateSet);
 }
 

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

@@ -88,7 +88,7 @@ static ox::Error pack(
 	oxOutf("Final ROM buff size: {} bytes\n", romBuff.size());
 	OX_RETURN_ERROR(writeFileBuff(argRomBin, romBuff));
 	OX_REQUIRE(manifestJson, ox::writeOCString(manifest));
-	OX_RETURN_ERROR(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.len()}));
+	OX_RETURN_ERROR(writeFileBuff(argManifest, {manifestJson.data(), manifestJson.size()}));
 	return {};
 }
 

src/olympic/keel/test/tests.cpp

@@ -16,7 +16,7 @@ static std::map<ox::StringView, ox::Error(*)()> tests = {
 			constexpr ox::StringView uuidStr = "8d814442-f46e-4cc3-8edc-ca3c01cc86db";
 			constexpr ox::StringView hdr = "K1;8d814442-f46e-4cc3-8edc-ca3c01cc86db;";
 			OX_REQUIRE(uuid, ox::UUID::fromString(uuidStr));
-			ox::Array<char, hdr.len()> buff;
+			ox::Array<char, hdr.size()> buff;
 			ox::CharBuffWriter bw(buff);
 			OX_RETURN_ERROR(keel::writeUuidHeader(bw, uuid));
 			oxExpect(ox::StringView(buff.data(), buff.size()), hdr);

src/olympic/studio/applib/src/app.cpp

@@ -90,7 +90,10 @@ static ox::Error run(
 							return ox::Error{2, "failed to load project directory"};
 						}
 						Project project{*kctx.value, projectDir, projectDataDir};
-						return c.func(project, args + numCmdArgs);
+						return c.func(
+							project,
+							args.size() > numCmdArgs ?
+								 args + numCmdArgs : ox::SpanView<ox::CString>{});
 					}
 				}
 				return ox::Error{1, "command not found"};

src/olympic/studio/applib/src/popups/newmenu.cpp

@@ -192,7 +192,7 @@ void NewMenu::drawLastPageButtons(Context &sctx) noexcept {
 }
 
 void NewMenu::finish(Context &sctx) noexcept {
-	if (m_itemName.len() == 0) {
+	if (m_itemName.size() == 0) {
 		oxLogError(ox::Error{1, "New file error: no file name"});
 		return;
 	}

src/olympic/studio/applib/src/projectexplorer.cpp

@@ -57,7 +57,7 @@ void ProjectExplorer::dirContextMenu(ox::StringViewCR path) const noexcept {
 		if (ImGui::MenuItem("Add Directory")) {
 			addDir.emit(path);
 		}
-		if (path.len() && ImGui::MenuItem("Delete")) {
+		if (path.size() && ImGui::MenuItem("Delete")) {
 			deleteItem.emit(path);
 		}
 		ImGui::EndPopup();

src/olympic/studio/applib/src/studioui.cpp

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

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

@@ -40,8 +40,8 @@ constexpr ox::Result<ox::StringView> fileExt(ox::StringViewCR path) noexcept {
 
 [[nodiscard]]
 constexpr ox::StringView parentDir(ox::StringView path) noexcept {
-	if (path.len() && path[path.len() - 1] == '/') {
-		path = substr(path, 0, path.len() - 1);
+	if (path.size() && path[path.size() - 1] == '/') {
+		path = substr(path, 0, path.size() - 1);
 	}
 	auto const extStart = ox::find(path.crbegin(), path.crend(), '/').offset();
 	return substr(path, 0, extStart);
@@ -189,6 +189,10 @@ ox::Result<T> Project::loadObj(ox::StringViewCR path) const noexcept {
 	if constexpr(ox::is_same_v<T, ox::ModelObject>) {
 		return keel::readAsset(m_typeStore, buff);
 	} else {
+		OX_REQUIRE(typeId, keel::readAssetTypeId(buff));
+		if (typeId != ox::ModelTypeId_v<T>) {
+			return keel::convert<T>(m_kctx, buff);
+		}
 		return keel::readAsset<T>(buff);
 	}
 }

src/olympic/studio/modlib/src/filedialog_nfd.cpp

@@ -13,10 +13,10 @@ namespace studio {
 
 FDFilterItem::FDFilterItem(ox::StringViewCR pName, ox::StringViewCR pSpec) noexcept {
 	OX_ALLOW_UNSAFE_BUFFERS_BEGIN
-	name.resize(pName.len() + 1);
-	ox::strncpy(name.data(), pName.data(), pName.len());
-	spec.resize(pSpec.len() + 1);
-	ox::strncpy(spec.data(), pSpec.data(), pSpec.len());
+	name.resize(pName.size() + 1);
+	ox::strncpy(name.data(), pName.data(), pName.size());
+	spec.resize(pSpec.size() + 1);
+	ox::strncpy(spec.data(), pSpec.data(), pSpec.size());
 	OX_ALLOW_UNSAFE_BUFFERS_END
 }