diff --git a/deps/ox/src/ox/mc/read.cpp b/deps/ox/src/ox/mc/read.cpp
index fde36eb6..e4aade5a 100644
--- a/deps/ox/src/ox/mc/read.cpp
+++ b/deps/ox/src/ox/mc/read.cpp
@@ -27,45 +27,45 @@ MetalClawReader::~MetalClawReader() {
 	oxAssert(m_field == m_fields, "MetalClawReader: incorrect fields number given");
 }
 
-Error MetalClawReader::op(const char*, int8_t *val) {
+Error MetalClawReader::field(const char*, int8_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, int16_t *val) {
+Error MetalClawReader::field(const char*, int16_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, int32_t *val) {
+Error MetalClawReader::field(const char*, int32_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, int64_t *val) {
+Error MetalClawReader::field(const char*, int64_t *val) {
 	return readInteger(val);
 }
 
 
-Error MetalClawReader::op(const char*, uint8_t *val) {
+Error MetalClawReader::field(const char*, uint8_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, uint16_t *val) {
+Error MetalClawReader::field(const char*, uint16_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, uint32_t *val) {
+Error MetalClawReader::field(const char*, uint32_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, uint64_t *val) {
+Error MetalClawReader::field(const char*, uint64_t *val) {
 	return readInteger(val);
 }
 
-Error MetalClawReader::op(const char*, bool *val) {
+Error MetalClawReader::field(const char*, bool *val) {
 	*val = m_fieldPresence.get(m_field++);
 	return 0;
 }
 
-Error MetalClawReader::op(const char*, SerStr val) {
+Error MetalClawReader::field(const char*, SerStr val) {
 	if (m_fieldPresence.get(m_field++)) {
 		// read the length
 		if (m_buffIt >= m_buffLen) {
diff --git a/deps/ox/src/ox/mc/read.hpp b/deps/ox/src/ox/mc/read.hpp
index 19988a5e..e148edb7 100644
--- a/deps/ox/src/ox/mc/read.hpp
+++ b/deps/ox/src/ox/mc/read.hpp
@@ -37,32 +37,32 @@ class MetalClawReader {
 
 		~MetalClawReader();
 
-		Error op(const char*, int8_t *val);
-		Error op(const char*, int16_t *val);
-		Error op(const char*, int32_t *val);
-		Error op(const char*, int64_t *val);
+		Error field(const char*, int8_t *val);
+		Error field(const char*, int16_t *val);
+		Error field(const char*, int32_t *val);
+		Error field(const char*, int64_t *val);
 
-		Error op(const char*, uint8_t *val);
-		Error op(const char*, uint16_t *val);
-		Error op(const char*, uint32_t *val);
-		Error op(const char*, uint64_t *val);
+		Error field(const char*, uint8_t *val);
+		Error field(const char*, uint16_t *val);
+		Error field(const char*, uint32_t *val);
+		Error field(const char*, uint64_t *val);
 
-		Error op(const char*, bool *val);
+		Error field(const char*, bool *val);
 
 		// array handler
 		template<typename T>
-		Error op(const char*, T *val, std::size_t len);
+		Error field(const char*, T *val, std::size_t len);
 
 		template<typename T>
-		Error op(const char*, ox::Vector<T> *val);
+		Error field(const char*, ox::Vector<T> *val);
 
 		template<typename T>
-		Error op(const char*, T *val);
+		Error field(const char*, T *val);
 
 		template<std::size_t L>
-		Error op(const char*, ox::BString<L> *val);
+		Error field(const char*, ox::BString<L> *val);
 
-		Error op(const char*, SerStr val);
+		Error field(const char*, SerStr val);
 
 		/**
 		 * Reads an array length from the current location in the buffer.
@@ -105,18 +105,18 @@ class MetalClawReader {
 };
 
 template<typename T>
-Error MetalClawReader::op(const char*, T *val) {
+Error MetalClawReader::field(const char*, T *val) {
 	Error err = 0;
 	if (val && m_fieldPresence.get(m_field++)) {
 		auto reader = child();
-		err |= ioOp(&reader, val);
+		err |= model(&reader, val);
 	}
 	return err;
 };
 
 template<std::size_t L>
-Error MetalClawReader::op(const char *name, ox::BString<L> *val) {
-	return op(name, SerStr(val->data(), val->cap()));
+Error MetalClawReader::field(const char *name, ox::BString<L> *val) {
+	return field(name, SerStr(val->data(), val->cap()));
 }
 
 template<typename I>
@@ -138,7 +138,7 @@ Error MetalClawReader::readInteger(I *val) {
 
 // array handler
 template<typename T>
-Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
+Error MetalClawReader::field(const char*, T *val, std::size_t valLen) {
 	Error err = 0;
 	if (m_fieldPresence.get(m_field++)) {
 		// read the length
@@ -155,7 +155,7 @@ Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
 			auto reader = child();
 			reader.setTypeInfo("List", len);
 			for (std::size_t i = 0; i < len; i++) {
-				err |= reader.op("", &val[i]);
+				err |= reader.field("", &val[i]);
 			}
 		} else {
 			err = OxError(MC_OUTBUFFENDED);
@@ -165,14 +165,14 @@ Error MetalClawReader::op(const char*, T *val, std::size_t valLen) {
 };
 
 template<typename T>
-Error MetalClawReader::op(const char*, ox::Vector<T> *val) {
-	return op(nullptr, val->data(), val->size());
+Error MetalClawReader::field(const char*, ox::Vector<T> *val) {
+	return field(nullptr, val->data(), val->size());
 }
 
 template<typename T>
 Error readMC(uint8_t *buff, std::size_t buffLen, T *val) {
 	MetalClawReader reader(buff, buffLen);
-	return ioOp(&reader, val);
+	return model(&reader, val);
 }
 
 }
diff --git a/deps/ox/src/ox/mc/test/tests.cpp b/deps/ox/src/ox/mc/test/tests.cpp
index 23ee2f64..a3dafabf 100644
--- a/deps/ox/src/ox/mc/test/tests.cpp
+++ b/deps/ox/src/ox/mc/test/tests.cpp
@@ -40,33 +40,33 @@ struct TestStruct {
 };
 
 template<typename T>
-ox::Error ioOp(T *io, TestStructNest *obj) {
+ox::Error model(T *io, TestStructNest *obj) {
 	ox::Error err = 0;
 	io->setTypeInfo("TestStructNest", 3);
-	err |= io->op("Bool", &obj->Bool);
-	err |= io->op("Int", &obj->Int);
-	err |= io->op("String", &obj->String);
+	err |= io->field("Bool", &obj->Bool);
+	err |= io->field("Int", &obj->Int);
+	err |= io->field("String", &obj->String);
 	return err;
 }
 
 template<typename T>
-ox::Error ioOp(T *io, TestStruct *obj) {
+ox::Error model(T *io, TestStruct *obj) {
 	ox::Error err = 0;
 	io->setTypeInfo("TestStruct", 14);
-	err |= io->op("Bool", &obj->Bool);
-	err |= io->op("Int", &obj->Int);
-	err |= io->op("Int1", &obj->Int1);
-	err |= io->op("Int2", &obj->Int2);
-	err |= io->op("Int3", &obj->Int3);
-	err |= io->op("Int4", &obj->Int4);
-	err |= io->op("Int5", &obj->Int5);
-	err |= io->op("Int6", &obj->Int6);
-	err |= io->op("Int7", &obj->Int7);
-	err |= io->op("Int8", &obj->Int8);
-	err |= io->op("String", &obj->String);
-	err |= io->op("List", obj->List, 4);
-	err |= io->op("EmptyStruct", &obj->EmptyStruct);
-	err |= io->op("Struct", &obj->Struct);
+	err |= io->field("Bool", &obj->Bool);
+	err |= io->field("Int", &obj->Int);
+	err |= io->field("Int1", &obj->Int1);
+	err |= io->field("Int2", &obj->Int2);
+	err |= io->field("Int3", &obj->Int3);
+	err |= io->field("Int4", &obj->Int4);
+	err |= io->field("Int5", &obj->Int5);
+	err |= io->field("Int6", &obj->Int6);
+	err |= io->field("Int7", &obj->Int7);
+	err |= io->field("Int8", &obj->Int8);
+	err |= io->field("String", &obj->String);
+	err |= io->field("List", obj->List, 4);
+	err |= io->field("EmptyStruct", &obj->EmptyStruct);
+	err |= io->field("Struct", &obj->Struct);
 	return err;
 }
 
@@ -270,25 +270,25 @@ std::map<std::string, ox::Error(*)()> tests = {
 								switch (f.type->length) {
 									case 1: {
 										uint8_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 2: {
 										uint16_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 4: {
 										uint32_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 8: {
 										uint64_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
@@ -300,25 +300,25 @@ std::map<std::string, ox::Error(*)()> tests = {
 								switch (f.type->length) {
 									case 1: {
 										int8_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 2: {
 										int16_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 4: {
 										int32_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
 									case 8: {
 										int64_t i = {};
-										oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+										oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 										std::cout << i;
 										break;
 									}
@@ -327,14 +327,14 @@ std::map<std::string, ox::Error(*)()> tests = {
 								break;
 							case ox::PrimitiveType::Bool: {
 								bool i = {};
-								oxAssert(rdr->op(fieldName, &i), "Walking ioOp failed.");
+								oxAssert(rdr->field(fieldName, &i), "Walking model failed.");
 								std::cout << fieldName << ":\t" << "bool:\t" << (i ? "true" : "false") << '\n';
 								break;
 							}
 							case ox::PrimitiveType::String: {
 								ox::Vector<char> v(rdr->stringLength());
 								//std::cout << rdr->stringLength() << '\n';
-								oxAssert(rdr->op(fieldName, ox::SerStr(v.data(), v.size())), "Walking ioOp failed.");
+								oxAssert(rdr->field(fieldName, ox::SerStr(v.data(), v.size())), "Walking model failed.");
 								std::cout << fieldName << ":\t" << "string: " << v.data() << '\n';
 								break;
 							}
diff --git a/deps/ox/src/ox/mc/walk.hpp b/deps/ox/src/ox/mc/walk.hpp
index 0fc3d229..c39f4216 100644
--- a/deps/ox/src/ox/mc/walk.hpp
+++ b/deps/ox/src/ox/mc/walk.hpp
@@ -16,7 +16,7 @@ template<typename Reader, typename Handler>
 ox::Error walkMC(DescriptorType *type, uint8_t *data, std::size_t dataLen, Handler handler) {
 	DataWalker<Reader, Handler> walker(type, handler);
 	Reader rdr(data, dataLen);
-	return ioOp(&rdr, &walker);
+	return model(&rdr, &walker);
 }
 
 }
diff --git a/deps/ox/src/ox/mc/write.cpp b/deps/ox/src/ox/mc/write.cpp
index ff77386f..aa148146 100644
--- a/deps/ox/src/ox/mc/write.cpp
+++ b/deps/ox/src/ox/mc/write.cpp
@@ -23,44 +23,44 @@ MetalClawWriter::~MetalClawWriter() noexcept {
 	oxAssert(m_field == m_fields, "MetalClawWriter: incorrect fields number given");
 }
 
-Error MetalClawWriter::op(const char*, int8_t *val) {
+Error MetalClawWriter::field(const char*, int8_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, int16_t *val) {
+Error MetalClawWriter::field(const char*, int16_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, int32_t *val) {
+Error MetalClawWriter::field(const char*, int32_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, int64_t *val) {
+Error MetalClawWriter::field(const char*, int64_t *val) {
 	return appendInteger(*val);
 }
 
 
-Error MetalClawWriter::op(const char*, uint8_t *val) {
+Error MetalClawWriter::field(const char*, uint8_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, uint16_t *val) {
+Error MetalClawWriter::field(const char*, uint16_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, uint32_t *val) {
+Error MetalClawWriter::field(const char*, uint32_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, uint64_t *val) {
+Error MetalClawWriter::field(const char*, uint64_t *val) {
 	return appendInteger(*val);
 }
 
-Error MetalClawWriter::op(const char*, bool *val) {
+Error MetalClawWriter::field(const char*, bool *val) {
 	return m_fieldPresence.set(m_field++, *val);
 }
 
-Error MetalClawWriter::op(const char*, SerStr val) {
+Error MetalClawWriter::field(const char*, SerStr val) {
 	int err = 0;
 	bool fieldSet = false;
 	if (val.cap()) {
diff --git a/deps/ox/src/ox/mc/write.hpp b/deps/ox/src/ox/mc/write.hpp
index d1c6aa12..aadc929a 100644
--- a/deps/ox/src/ox/mc/write.hpp
+++ b/deps/ox/src/ox/mc/write.hpp
@@ -38,31 +38,31 @@ class MetalClawWriter {
 
 		~MetalClawWriter() noexcept;
 
-		Error op(const char*, int8_t *val);
-		Error op(const char*, int16_t *val);
-		Error op(const char*, int32_t *val);
-		Error op(const char*, int64_t *val);
+		Error field(const char*, int8_t *val);
+		Error field(const char*, int16_t *val);
+		Error field(const char*, int32_t *val);
+		Error field(const char*, int64_t *val);
 
-		Error op(const char*, uint8_t *val);
-		Error op(const char*, uint16_t *val);
-		Error op(const char*, uint32_t *val);
-		Error op(const char*, uint64_t *val);
+		Error field(const char*, uint8_t *val);
+		Error field(const char*, uint16_t *val);
+		Error field(const char*, uint32_t *val);
+		Error field(const char*, uint64_t *val);
 
-		Error op(const char*, bool *val);
+		Error field(const char*, bool *val);
 
 		template<typename T>
-		Error op(const char*, T *val, std::size_t len);
+		Error field(const char*, T *val, std::size_t len);
 
 		template<typename T>
-		Error op(const char*, ox::Vector<T> *val);
+		Error field(const char*, ox::Vector<T> *val);
 
 		template<std::size_t L>
-		Error op(const char*, ox::BString<L> *val);
+		Error field(const char*, ox::BString<L> *val);
 
-		Error op(const char*, SerStr val);
+		Error field(const char*, SerStr val);
 
 		template<typename T>
-		Error op(const char*, T *val);
+		Error field(const char*, T *val);
 
 		void setTypeInfo(const char *name, int fields);
 
@@ -78,17 +78,17 @@ class MetalClawWriter {
 };
 
 template<std::size_t L>
-Error MetalClawWriter::op(const char *name, ox::BString<L> *val) {
-	return op(name, SerStr(val->data(), val->cap()));
+Error MetalClawWriter::field(const char *name, ox::BString<L> *val) {
+	return field(name, SerStr(val->data(), val->cap()));
 }
 
 template<typename T>
-Error MetalClawWriter::op(const char*, T *val) {
+Error MetalClawWriter::field(const char*, T *val) {
 	int err = 0;
 	bool fieldSet = false;
 	MetalClawWriter writer(m_buff + m_buffIt, m_buffLen - m_buffIt);
 	if (val) {
-		err |= ioOp(&writer, val);
+		err |= model(&writer, val);
 		if (static_cast<std::size_t>(writer.m_fieldPresence.getMaxLen()) < writer.m_buffIt) {
 			m_buffIt += writer.m_buffIt;
 			fieldSet = true;
@@ -100,12 +100,12 @@ Error MetalClawWriter::op(const char*, T *val) {
 }
 
 template<typename T>
-Error MetalClawWriter::op(const char*, ox::Vector<T> *val) {
-	return op(nullptr, val->data(), val->size());
+Error MetalClawWriter::field(const char*, ox::Vector<T> *val) {
+	return field(nullptr, val->data(), val->size());
 }
 
 template<typename T>
-Error MetalClawWriter::op(const char*, T *val, std::size_t len) {
+Error MetalClawWriter::field(const char*, T *val, std::size_t len) {
 	Error err = 0;
 	bool fieldSet = false;
 
@@ -124,7 +124,7 @@ Error MetalClawWriter::op(const char*, T *val, std::size_t len) {
 
 		// write the array
 		for (std::size_t i = 0; i < len; i++) {
-			err |= writer.op("", &val[i]);
+			err |= writer.field("", &val[i]);
 		}
 
 		m_buffIt += writer.m_buffIt;
@@ -158,7 +158,7 @@ Error MetalClawWriter::appendInteger(I val) {
 template<typename T>
 Error writeMC(uint8_t *buff, std::size_t buffLen, T *val, std::size_t *sizeOut = nullptr) {
 	MetalClawWriter writer(buff, buffLen);
-	auto err = ioOp(&writer, val);
+	auto err = model(&writer, val);
 	if (sizeOut) {
 		*sizeOut = writer.size();
 	}
diff --git a/deps/ox/src/ox/model/descread.hpp b/deps/ox/src/ox/model/descread.hpp
index 2e57499a..cb3115e0 100644
--- a/deps/ox/src/ox/model/descread.hpp
+++ b/deps/ox/src/ox/model/descread.hpp
@@ -36,7 +36,7 @@ const TypeStore &TypeDescReader<ReaderBase>::typeStore() const {
 template<typename ReaderBase, typename T>
 int readMCDef(uint8_t *buff, std::size_t buffLen, T *val) {
 	TypeDescReader<ReaderBase> reader(buff, buffLen);
-	return ioOp(&reader, val);
+	return model(&reader, val);
 }
 
 }
diff --git a/deps/ox/src/ox/model/desctypes.hpp b/deps/ox/src/ox/model/desctypes.hpp
index 6aba5939..f7732af7 100644
--- a/deps/ox/src/ox/model/desctypes.hpp
+++ b/deps/ox/src/ox/model/desctypes.hpp
@@ -117,56 +117,56 @@ struct DescriptorType {
 
 
 template<typename T>
-Error ioOp(T *io, DescriptorType *type) {
+Error model(T *io, DescriptorType *type) {
 	Error err = 0;
 	io->setTypeInfo("ox::DescriptorType", 4);
-	err |= io->op("typeName", &type->typeName);
-	err |= io->op("primitiveType", &type->primitiveType);
-	err |= io->op("fieldList", &type->fieldList);
-	err |= io->op("length", &type->length);
+	err |= io->field("typeName", &type->typeName);
+	err |= io->field("primitiveType", &type->primitiveType);
+	err |= io->field("fieldList", &type->fieldList);
+	err |= io->field("length", &type->length);
 	return err;
 }
 
 template<typename T>
-Error ioOpWrite(T *io, DescriptorField *field) {
+Error modelWrite(T *io, DescriptorField *field) {
 	Error err = 0;
 	io->setTypeInfo("ox::DescriptorField", 4);
 	if (field->ownsType) {
-		err |= io->op("typeName", "");
-		err |= io->op("type", field->type);
+		err |= io->field("typeName", "");
+		err |= io->field("type", field->type);
 	} else {
-		err |= io->op("typeName", &field->type->typeName);
-		err |= io->op("type", static_cast<decltype(field->type)>(nullptr));
+		err |= io->field("typeName", &field->type->typeName);
+		err |= io->field("type", static_cast<decltype(field->type)>(nullptr));
 	}
-	err |= io->op("fieldName", &field->fieldName);
+	err |= io->field("fieldName", &field->fieldName);
 	// defaultValue is unused now, but leave placeholder for backwards compatibility
 	const int DefaultValue = 0;
-	err |= io->op("defaultValue", &DefaultValue);
+	err |= io->field("defaultValue", &DefaultValue);
 	return err;
 }
 
 template<typename T>
-Error ioOpRead(T *io, DescriptorField *field) {
+Error modelRead(T *io, DescriptorField *field) {
 	Error err = 0;
 	auto &typeStore = io->typeStore();
 	io->setTypeInfo("ox::DescriptorField", 4);
-	err |= io->op("typeName", &field->typeName);
+	err |= io->field("typeName", &field->typeName);
 	if (field->typeName == "") {
 		field->ownsType = true;
 		if (field->type == nullptr) {
 			field->type = new DescriptorType;
 		}
-		err |= io->op("type", field->type);
+		err |= io->field("type", field->type);
 		typeStore[field->type->typeName] = field->type;
 	} else {
 		// should be empty, so discard
 		DescriptorType t;
-		err |= io->op("type", &t);
+		err |= io->field("type", &t);
 		field->type = typeStore[field->typeName];
 	}
-	err |= io->op("fieldName", &field->fieldName);
+	err |= io->field("fieldName", &field->fieldName);
 	// defaultValue is unused now, but placeholder for backwards compatibility
-	err |= io->op("defaultValue", nullptr);
+	err |= io->field("defaultValue", nullptr);
 	return err;
 }
 
diff --git a/deps/ox/src/ox/model/descwrite.hpp b/deps/ox/src/ox/model/descwrite.hpp
index e91a5f81..75f1f8fa 100644
--- a/deps/ox/src/ox/model/descwrite.hpp
+++ b/deps/ox/src/ox/model/descwrite.hpp
@@ -43,12 +43,12 @@ class TypeDescWriter {
 			}
 
 			template<typename T>
-			constexpr ox::Error op(const char*, T*, std::size_t) noexcept {
+			constexpr ox::Error field(const char*, T*, std::size_t) noexcept {
 				return OxError(0);
 			}
 
 			template<typename T>
-			constexpr ox::Error op(const char*, T*) noexcept {
+			constexpr ox::Error field(const char*, T*) noexcept {
 				return OxError(0);
 			}
 
@@ -64,13 +64,13 @@ class TypeDescWriter {
 		~TypeDescWriter();
 
 		template<typename T>
-		ox::Error op(const char *name, T *val, std::size_t valLen);
+		ox::Error field(const char *name, T *val, std::size_t valLen);
 
 		template<typename T>
-		ox::Error op(const char *name, ox::Vector<T> *val);
+		ox::Error field(const char *name, ox::Vector<T> *val);
 
 		template<typename T>
-		ox::Error op(const char *name, T *val);
+		ox::Error field(const char *name, T *val);
 
 		void setTypeInfo(const char *name, int fields);
 
@@ -110,12 +110,12 @@ class TypeDescWriter {
 
 // array handler
 template<typename T>
-ox::Error TypeDescWriter::op(const char *name, T *val, std::size_t) {
+ox::Error TypeDescWriter::field(const char *name, T *val, std::size_t) {
 	if (m_type) {
 		constexpr typename ox::remove_pointer<decltype(val)>::type *p = nullptr;
 		bool alreadyExisted = false;
 		const auto t = type(p, &alreadyExisted);
-		oxAssert(t != nullptr, "op(const char *name, T *val, std::size_t): Type not found or generated");
+		oxAssert(t != nullptr, "field(const char *name, T *val, std::size_t): Type not found or generated");
 		if (t == nullptr) {
 			type(p, &alreadyExisted);
 		}
@@ -126,16 +126,16 @@ ox::Error TypeDescWriter::op(const char *name, T *val, std::size_t) {
 }
 
 template<typename T>
-ox::Error TypeDescWriter::op(const char *name, ox::Vector<T> *val) {
-	return op(name, val->data(), val->size());
+ox::Error TypeDescWriter::field(const char *name, ox::Vector<T> *val) {
+	return field(name, val->data(), val->size());
 }
 
 template<typename T>
-ox::Error TypeDescWriter::op(const char *name, T *val) {
+ox::Error TypeDescWriter::field(const char *name, T *val) {
 	if (m_type) {
 		bool alreadyExisted = false;
 		const auto t = type(val, &alreadyExisted);
-		oxAssert(t != nullptr, "op(const char *name, T *val): Type not found or generated");
+		oxAssert(t != nullptr, "field(const char *name, T *val): Type not found or generated");
 		m_type->fieldList.emplace_back(t, name, 0, alreadyExisted ? t->typeName : "", !alreadyExisted);
 		return OxError(0);
 	}
@@ -150,13 +150,13 @@ DescriptorType *TypeDescWriter::type(BString<sz> *val, bool *alreadyExisted) {
 template<typename T>
 DescriptorType *TypeDescWriter::type(T *val, bool *alreadyExisted) {
 	NameCatcher nc;
-	ioOp(&nc, val);
+	model(&nc, val);
 	if (m_typeStore->contains(nc.name)) {
 		*alreadyExisted = true;
 		return m_typeStore->at(nc.name);
 	} else {
 		TypeDescWriter dw(m_typeStore);
-		oxLogError(ioOp(&dw, val));
+		oxLogError(model(&dw, val));
 		*alreadyExisted = false;
 		return dw.m_type;
 	}
@@ -165,7 +165,7 @@ DescriptorType *TypeDescWriter::type(T *val, bool *alreadyExisted) {
 template<typename T>
 [[nodiscard]] ValErr<DescriptorType*> buildMCDef(T *val) {
 	TypeDescWriter writer;
-	Error err = ioOp(&writer, val);
+	Error err = model(&writer, val);
 	return {writer.definition(), err};
 }
 
diff --git a/deps/ox/src/ox/model/optype.hpp b/deps/ox/src/ox/model/optype.hpp
index 45b68119..95571234 100644
--- a/deps/ox/src/ox/model/optype.hpp
+++ b/deps/ox/src/ox/model/optype.hpp
@@ -18,31 +18,31 @@ enum class OpType {
 	WriteDefinition = 3,
 };
 
-// empty default implementations of ioOp functions
+// empty default implementations of model functions
 
 template<typename T, typename O>
-ox::Error ioOpRead(T*, O*) {
+ox::Error modelRead(T*, O*) {
 	return OxError(1);
 }
 
 template<typename T, typename O>
-ox::Error ioOpWrite(T*, O*) {
+ox::Error modelWrite(T*, O*) {
 	return OxError(1);
 }
 
 template<typename T, typename O>
-ox::Error ioOpWriteDefinition(T*, O*) {
+ox::Error modelWriteDefinition(T*, O*) {
 	return OxError(1);
 }
 
 template<typename T, typename O>
-ox::Error ioOp(T *io, O *obj) {
+ox::Error model(T *io, O *obj) {
 	if constexpr(T::opType() == ox::OpType::Read) {
-		return ioOpRead(io, obj);
+		return modelRead(io, obj);
 	} else if constexpr(T::opType() == ox::OpType::Write) {
-		return ioOpWrite(io, obj);
+		return modelWrite(io, obj);
 	} else if constexpr(T::opType() == ox::OpType::WriteDefinition) {
-		return ioOpWriteDefinition(io, obj);
+		return modelWriteDefinition(io, obj);
 	}
 	return OxError(1);
 }
diff --git a/deps/ox/src/ox/model/walk.hpp b/deps/ox/src/ox/model/walk.hpp
index ca4ca1e1..3aaf2ce4 100644
--- a/deps/ox/src/ox/model/walk.hpp
+++ b/deps/ox/src/ox/model/walk.hpp
@@ -113,13 +113,13 @@ static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalke
 				if (rdr->fieldPresent()) {
 					auto child = rdr->child();
 					walker->pushType(field.type);
-					oxReturnError(ioOp(&child, walker));
+					oxReturnError(model(&child, walker));
 					walker->popType();
 					rdr->nextField();
 				} else {
 					// skip and discard absent field
 					int discard;
-					oxReturnError(rdr->op("", &discard));
+					oxReturnError(rdr->field("", &discard));
 				}
 				break;
 		}
@@ -129,7 +129,7 @@ static ox::Error parseField(const DescriptorField &field, Reader *rdr, DataWalke
 }
 
 template<typename Reader, typename FH>
-ox::Error ioOp(Reader *rdr, DataWalker<Reader, FH> *walker) {
+ox::Error model(Reader *rdr, DataWalker<Reader, FH> *walker) {
 	auto type = walker->type();
 	if (!type) {
 		return OxError(1);
diff --git a/deps/ox/src/ox/std/trace.hpp b/deps/ox/src/ox/std/trace.hpp
index 0f927324..548a2620 100644
--- a/deps/ox/src/ox/std/trace.hpp
+++ b/deps/ox/src/ox/std/trace.hpp
@@ -21,13 +21,13 @@ struct TraceMsg {
 };
 
 template<typename T>
-int ioOp(T *io, ox::trace::TraceMsg *obj) {
+int model(T *io, ox::trace::TraceMsg *obj) {
 	int32_t err = 0;
 	io->setTypeInfo("ox::trace::TraceMsg", 5);
-	err |= io->op("file", &obj->file);
-	err |= io->op("line", &obj->line);
-	err |= io->op("time", &obj->time);
-	err |= io->op("msg", &obj->msg);
+	err |= io->field("file", &obj->file);
+	err |= io->field("line", &obj->line);
+	err |= io->field("time", &obj->time);
+	err |= io->field("msg", &obj->msg);
 	return err;
 }