diff --git a/deps/ox/src/ox/fs/filestore/filestoretemplate.hpp b/deps/ox/src/ox/fs/filestore/filestoretemplate.hpp
index 120dcd9f..bd1874c0 100644
--- a/deps/ox/src/ox/fs/filestore/filestoretemplate.hpp
+++ b/deps/ox/src/ox/fs/filestore/filestoretemplate.hpp
@@ -39,6 +39,7 @@ struct OX_PACKED FileStoreItem: public ptrarith::Item<size_t> {
 	/**
 	 * @return the size of the data + the size of the Item type
 	 */
+	[[nodiscard]]
 	size_t fullSize() const {
 		return sizeof(*this) + this->size();
 	}
@@ -85,11 +86,11 @@ class FileStoreTemplate {
 
 		Error decLinks(InodeId_t id);
 
-		Error write(InodeId_t id, const void *data, FsSize_t dataLen, uint8_t fileType = 0);
+		Error write(InodeId_t id, const void *data, FsSize_t dataSize, uint8_t fileType = 0);
 
 		Error remove(InodeId_t id);
 
-		Error read(InodeId_t id, void *data, FsSize_t dataSize, FsSize_t *size = nullptr) const;
+		Error read(InodeId_t id, void *out, FsSize_t outSize, FsSize_t *size = nullptr) const;
 
 		Error read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size = nullptr) const;
 
@@ -116,13 +117,17 @@ class FileStoreTemplate {
 
 		Error resize(std::size_t size, void *newBuff = nullptr);
 
-		[[nodiscard]] InodeId_t spaceNeeded(FsSize_t size);
+		[[nodiscard]]
+		InodeId_t spaceNeeded(FsSize_t size);
 
-		[[nodiscard]] InodeId_t size() const;
+		[[nodiscard]]
+		InodeId_t size() const;
 
-		[[nodiscard]] InodeId_t available();
+		[[nodiscard]]
+		InodeId_t available();
 
-		[[nodiscard]] char *buff();
+		[[nodiscard]]
+		char *buff();
 
 		Error walk(Error(*cb)(uint8_t, uint64_t, uint64_t));
 
@@ -164,7 +169,7 @@ class FileStoreTemplate {
 		/**
 		 * Finds the parent an inode by its ID.
 		 */
-		ItemPtr findParent(ItemPtr ptr, size_t id, size_t oldAddr) const;
+		ItemPtr findParent(ItemPtr item, size_t id, size_t oldAddr) const;
 
 		/**
 		 * Finds an inode by its ID.
@@ -204,11 +209,10 @@ Error FileStoreTemplate<size_t>::format(void *buffer, size_t bufferSize) {
 		if (data.valid()) {
 			new (data) FileStoreData;
 			return OxError(0);
-		} else {
-			oxTrace("ox::fs::FileStoreTemplate::format::fail") << "Could not read data section of FileStoreData";
 		}
 	}
-	return OxError(1);
+	oxTrace("ox::fs::FileStoreTemplate::format::fail", "Could not read data section of FileStoreData");
+	return OxError(1, "Could not read data section of FileStoreData");
 }
 
 template<typename size_t>
@@ -221,30 +225,24 @@ Error FileStoreTemplate<size_t>::setSize(InodeId_t size) {
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::incLinks(InodeId_t id) {
-	auto item = find(id);
-	if (item.valid()) {
-		item->links++;
-		return OxError(0);
-	}
-	return OxError(1);
+	oxRequireM(item, find(id).validate());
+	item->links++;
+	return OxError(0);
 }
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::decLinks(InodeId_t id) {
-	auto item = find(id);
-	if (item.valid()) {
-		item->links--;
-		if (item->links == 0) {
-			oxReturnError(remove(item));
-		}
-		return OxError(0);
+	oxRequireM(item, find(id).validate());
+	item->links--;
+	if (item->links == 0) {
+		oxReturnError(remove(item));
 	}
-	return OxError(1);
+	return OxError(0);
 }
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t dataSize, uint8_t fileType) {
-	oxTrace("ox::fs::FileStoreTemplate::write") << "Attempting to write to inode" << id;
+	oxTracef("ox::fs::FileStoreTemplate::write", "Attempting to write to inode {}", id);
 	auto existing = find(id);
 	if (!canWrite(existing, dataSize)) {
 		oxReturnError(compact());
@@ -254,25 +252,24 @@ Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t
 	if (canWrite(existing, dataSize)) {
 		// delete the old node if it exists
 		if (existing.valid()) {
-			oxTrace("ox::fs::FileStoreTemplate::write") << "Freeing old version of inode found at offset:" << existing.offset();
+			oxTracef("ox::fs::FileStoreTemplate::write", "Freeing old version of inode found at offset: {}", existing.offset());
 			auto err = m_buffer->free(existing);
 			if (err) {
-				oxTrace("ox::fs::FileStoreTemplate::write::fail") << "Free of old version of inode failed";
+				oxTrace("ox::fs::FileStoreTemplate::write::fail", "Free of old version of inode failed");
 				return err;
 			}
 			existing = nullptr;
 		}
-
 		// write the given data
 		auto dest = m_buffer->malloc(dataSize);
 		// if first malloc failed, compact and try again
 		if (!dest.valid()) {
-			oxTrace("ox::fs::FileStoreTemplate::write") << "Allocation failed, compacting";
+			oxTrace("ox::fs::FileStoreTemplate::write", "Allocation failed, compacting");
 			oxReturnError(compact());
 			dest = m_buffer->malloc(dataSize);
 		}
 		if (dest.valid()) {
-			oxTrace("ox::fs::FileStoreTemplate::write") << "Memory allocated";
+			oxTrace("ox::fs::FileStoreTemplate::write", "Memory allocated");
 			dest->id = id;
 			dest->fileType = fileType;
 			auto destData = m_buffer->template dataOf<uint8_t>(dest);
@@ -281,24 +278,26 @@ Error FileStoreTemplate<size_t>::write(InodeId_t id, const void *data, FsSize_t
 				// write data if any was provided
 				if (data != nullptr) {
 					ox_memcpy(destData, data, dest->size());
-					oxTrace("ox::fs::FileStoreTemplate::write") << "Data written";
+					oxTrace("ox::fs::FileStoreTemplate::write", "Data written");
 				}
 				auto fsData = fileStoreData();
 				if (fsData) {
-					oxTrace("ox::fs::FileStoreTemplate::write") << "Searching for root node at" << fsData->rootNode;
+					oxTracef("ox::fs::FileStoreTemplate::write", "Searching for root node at {}", fsData->rootNode.get());
 					auto root = m_buffer->ptr(fsData->rootNode);
 					if (root.valid()) {
-						oxTrace("ox::fs::FileStoreTemplate::write") << "Placing" << dest->id << "on" << root->id << "at" << destData.offset();
+						oxTracef("ox::fs::FileStoreTemplate::write",
+						         "Placing {} on {} at {}", dest->id.get(), root->id.get(), destData.offset());
 						return placeItem(dest);
 					} else {
-						oxTrace("ox::fs::FileStoreTemplate::write") << "Initializing root inode:" << dest->id << "( offset:" << dest.offset()
-						                                            << ", data size:" << destData.size() << ")";
+						oxTracef("ox::fs::FileStoreTemplate::write",
+						        "Initializing root inode: {} (offset: {}, data size: {})",
+						        dest->id.get(), dest.offset(), destData.size());
 						fsData->rootNode = dest.offset();
-						oxTrace("ox::fs::FileStoreTemplate::write") << "Root inode:" << dest->id;
+						oxTracef("ox::fs::FileStoreTemplate::write", "Root inode: {}", dest->id.get());
 						return OxError(0);
 					}
 				} else {
-					oxTrace("ox::fs::FileStoreTemplate::write::fail") << "Could not place item due to absence of FileStore header.";
+					oxTrace("ox::fs::FileStoreTemplate::write::fail", "Could not place item due to absence of FileStore header.");
 				}
 			}
 		}
@@ -314,28 +313,24 @@ Error FileStoreTemplate<size_t>::remove(InodeId_t id) {
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::read(InodeId_t id, void *out, FsSize_t outSize, FsSize_t *size) const {
-	oxTrace("ox::fs::FileStoreTemplate::read") << "Attempting to read from inode" << id;
-
+	oxTracef("ox::fs::FileStoreTemplate::read", "Attempting to read from inode {}", id);
 	auto src = find(id);
-
 	// error check
 	if (!src.valid()) {
-		oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not find requested item:" << id;
+		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not find requested item: {}", id);
 		return OxError(1);
 	}
 
 	auto srcData = m_buffer->template dataOf<uint8_t>(src);
-	oxTrace("ox::fs::FileStoreTemplate::read::found") << id << "found at"<< src.offset()
-		<< "with data section at" << srcData.offset();
-	oxTrace("ox::fs::FileStoreTemplate::read::outSize") << srcData.offset() << srcData.size() << outSize;
+	oxTracef("ox::fs::FileStoreTemplate::read::found", "{} found at {} with data section at {}",
+	        id, src.offset(), srcData.offset());
+	oxTracef("ox::fs::FileStoreTemplate::read::outSize", "{} {} {}", srcData.offset(), srcData.size(), outSize);
 
 	// error check
 	if (!(srcData.valid() && srcData.size() <= outSize)) {
-		oxTrace("ox::fs::FileStoreTemplate::read::fail")
-			<< "Could not read data section of item:" << id;
-		oxTrace("ox::fs::FileStoreTemplate::read::fail").del("")
-			<< "Item data section size: " << srcData.size()
-			<< ", Expected size: " << outSize;
+		oxTracef("ox::fs::FileStoreTemplate::read::fail", "Could not read data section of item: {}", id);
+		oxTracef("ox::fs::FileStoreTemplate::read::fail",
+		         "Item data section size: {}, Expected size: {}", srcData.size(), outSize);
 		return OxError(1);
 	}
 
@@ -349,54 +344,37 @@ Error FileStoreTemplate<size_t>::read(InodeId_t id, void *out, FsSize_t outSize,
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart, FsSize_t readSize, void *data, FsSize_t *size) const {
-	auto src = find(id);
-	if (src.valid()) {
-		auto srcData = src->data();
-		if (srcData.valid()) {
-			auto sub = srcData.template subPtr<uint8_t>(readStart, readSize);
-			if (sub.valid()) {
-				ox_memcpy(data, sub, sub.size());
-				if (size) {
-					*size = sub.size();
-				}
-				return OxError(0);
-			} else {
-				oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not read requested data sub-section of item:" << id;
-			}
-		} else {
-			oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not read data section of item:" << id;
-		}
-	} else {
-		oxTrace("ox::fs::FileStoreTemplate::read::fail") << "Could not find requested item:" << id;
+	oxRequireM(src, find(id).validate());
+	oxRequireM(srcData, src->data().validate());
+	oxRequire(sub, srcData.template subPtr<uint8_t>(readStart, readSize).validate());
+	memcpy(data, sub, sub.size());
+	if (size) {
+		*size = sub.size();
 	}
-	return OxError(1);
+	return OxError(0);
 }
 
 template<typename size_t>
 template<typename T>
 Error FileStoreTemplate<size_t>::read(InodeId_t id, FsSize_t readStart,
                                       FsSize_t readSize, T *data, FsSize_t *size) const {
-	auto src = find(id);
-	if (src.valid()) {
-		auto srcData = src->data();
-		if (srcData.valid()) {
-			auto sub = srcData.template subPtr<uint8_t>(readStart, readSize);
-			if (sub.valid() && sub.size() % sizeof(T)) {
-				for (FsSize_t i = 0; i < sub.size() / sizeof(T); i++) {
-					// do byte-by-byte copy to ensure alignment is right when
-					// copying to final destination
-					T tmp;
-					for (size_t ii = 0; ii < sizeof(T); ii++) {
-						reinterpret_cast<uint8_t*>(&tmp)[ii] = *(sub.get() + ii);
-					}
-					*(data + i) = tmp;
-				}
-				if (size) {
-					*size = sub.size();
-				}
-				return OxError(0);
+	oxRequireM(src, find(id).validate());
+	oxRequireM(srcData, src->data().validate());
+	auto sub = srcData.template subPtr<uint8_t>(readStart, readSize);
+	if (sub.valid() && sub.size() % sizeof(T)) {
+		for (FsSize_t i = 0; i < sub.size() / sizeof(T); i++) {
+			// do byte-by-byte copy to ensure alignment is right when
+			// copying to final destination
+			T tmp;
+			for (size_t ii = 0; ii < sizeof(T); ii++) {
+				reinterpret_cast<uint8_t*>(&tmp)[ii] = *(sub.get() + ii);
 			}
+			*(data + i) = tmp;
 		}
+		if (size) {
+			*size = sub.size();
+		}
+		return OxError(0);
 	}
 	return OxError(1);
 }
@@ -415,9 +393,9 @@ template<typename size_t>
 Error FileStoreTemplate<size_t>::resize() {
 	oxReturnError(compact());
 	const auto newSize = size() - available();
-	oxTrace("ox::fs::FileStoreTemplate::resize") << "resize to:" << newSize;
+	oxTracef("ox::fs::FileStoreTemplate::resize", "resize to: {}", newSize);
 	oxReturnError(m_buffer->setSize(newSize));
-	oxTrace("ox::fs::FileStoreTemplate::resize") << "resized to:" << m_buffer->size();
+	oxTracef("ox::fs::FileStoreTemplate::resize", "resized to: {}", m_buffer->size());
 	return OxError(0);
 }
 
@@ -436,16 +414,13 @@ Error FileStoreTemplate<size_t>::resize(std::size_t size, void *newBuff) {
 
 template<typename size_t>
 Result<StatInfo> FileStoreTemplate<size_t>::stat(InodeId_t id) {
-	auto inode = find(id);
-	if (inode.valid()) {
-		return Result<StatInfo>({
-			id,
-			inode->links,
-			inode->size(),
-			inode->fileType,
-		});
-	}
-	return {};
+	oxRequireM(inode, find(id).validate());
+	return StatInfo {
+		id,
+		inode->links,
+		inode->size(),
+		inode->fileType,
+	};
 }
 
 template<typename size_t>
@@ -479,16 +454,16 @@ Error FileStoreTemplate<size_t>::walk(Error(*cb)(uint8_t, uint64_t, uint64_t)) {
 template<typename size_t>
 Result<typename FileStoreTemplate<size_t>::InodeId_t> FileStoreTemplate<size_t>::generateInodeId() {
 	auto fsData = fileStoreData();
-	if (fsData) {
-		for (auto i = 0; i < 100; i++) {
-			auto inode = fsData->random.gen() % MaxValue<InodeId_t>;
-			if (inode > ReservedInodeEnd && !find(inode).valid()) {
-				return inode;
-			}
-		}
-		return OxError(2);
+	if (!fsData) {
+		return OxError(1);
 	}
-	return OxError(1);
+	for (auto i = 0; i < 100; i++) {
+		auto inode = fsData->random.gen() % MaxValue<InodeId_t>;
+		if (inode > ReservedInodeEnd && !find(inode).valid()) {
+			return inode;
+		}
+	}
+	return OxError(2);
 }
 
 template<typename size_t>
@@ -502,10 +477,7 @@ Error FileStoreTemplate<size_t>::compact() {
 		if (!item.valid()) {
 			return OxError(1);
 		}
-		oxTrace("ox::FileStoreTemplate::compact::moveItem")
-			<< "Moving Item:" << item->id
-			<< "from" << oldAddr
-			<< "to" << item.offset();
+		oxTracef("ox::FileStoreTemplate::compact::moveItem", "Moving Item: {} from {} to {}", item->id.get(), oldAddr, item.offset());
 		// update rootInode if this is it
 		auto fsData = fileStoreData();
 		if (fsData && oldAddr == fsData->rootNode) {
@@ -540,109 +512,104 @@ typename FileStoreTemplate<size_t>::FileStoreData *FileStoreTemplate<size_t>::fi
 template<typename size_t>
 Error FileStoreTemplate<size_t>::placeItem(ItemPtr item) {
 	auto fsData = fileStoreData();
-	if (fsData) {
-		auto root = m_buffer->ptr(fsData->rootNode);
-		if (root.valid()) {
-			if (root->id == item->id) {
-				fsData->rootNode = item;
-				item->left = root->left;
-				item->right = root->right;
-				oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Overwrote Root Item:" << item->id;
-				return OxError(0);
-			} else {
-				return placeItem(root, item);
-			}
-		}
+	if (!fsData) {
+		return OxError(1);
+	}
+	oxRequireM(root, m_buffer->ptr(fsData->rootNode).validate());
+	if (root->id == item->id) {
+		fsData->rootNode = item;
+		item->left = root->left;
+		item->right = root->right;
+		oxTracef("ox::fs::FileStoreTemplate::placeItem", "Overwrote Root Item: {}", item->id.get());
+		return OxError(0);
+	} else {
+		return placeItem(root, item);
 	}
-	return OxError(1);
 }
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::placeItem(ItemPtr root, ItemPtr item, int depth) {
-	if (depth < 5000) {
-		if (item->id > root->id) {
-			auto right = m_buffer->ptr(root->right);
-			if (!right.valid() || right->id == item->id) {
-				root->right = item.offset();
-				if (right.valid()) {
-					item->left = right->left;
-					item->right = right->right;
-				}
-				oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Placed Item:" << item->id;
-				return OxError(0);
-			} else {
-				return placeItem(right, item, depth + 1);
-			}
-		} else if (item->id < root->id) {
-			auto left = m_buffer->ptr(root->left);
-			if (!left.valid() || left->id == item->id) {
-				root->left = item.offset();
-				if (left.valid()) {
-					item->left = left->left;
-					item->right = left->right;
-				}
-				oxTrace("ox::fs::FileStoreTemplate::placeItem") << "Placed Item:" << item->id;
-				return OxError(0);
-			} else {
-				return placeItem(left, item, depth + 1);
+	if (depth > 5000) {
+		oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Excessive recursion depth, stopping before stack overflow.");
+		return OxError(2);
+	}
+	if (item->id > root->id) {
+		auto right = m_buffer->ptr(root->right);
+		if (!right.valid() || right->id == item->id) {
+			root->right = item.offset();
+			if (right.valid()) {
+				item->left = right->left;
+				item->right = right->right;
 			}
+			oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
+			return OxError(0);
 		} else {
-			oxTrace("ox::fs::FileStoreTemplate::placeItem::fail") << "Cannot insert an item on itself.";
-			return OxError(1);
+			return placeItem(right, item, depth + 1);
+		}
+	} else if (item->id < root->id) {
+		auto left = m_buffer->ptr(root->left);
+		if (!left.valid() || left->id == item->id) {
+			root->left = item.offset();
+			if (left.valid()) {
+				item->left = left->left;
+				item->right = left->right;
+			}
+			oxTracef("ox::fs::FileStoreTemplate::placeItem", "Placed Item: {}", item->id.get());
+			return OxError(0);
+		} else {
+			return placeItem(left, item, depth + 1);
 		}
 	} else {
-		oxTrace("ox::fs::FileStoreTemplate::placeItem::fail") << "Excessive recursion depth, stopping before stack overflow.";
-		return OxError(2);
+		oxTrace("ox::fs::FileStoreTemplate::placeItem::fail", "Cannot insert an item on itself.");
+		return OxError(1, "Cannot insert an item on itself.");
 	}
 }
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr item) {
 	auto fsData = fileStoreData();
-	if (fsData) {
-		auto root = m_buffer->ptr(fsData->rootNode);
-		if (root.valid()) {
-			if (root->id == item->id) {
-				item->left = root->left;
-				item->right = root->right;
-				auto left = m_buffer->ptr(item->left);
-				auto right = m_buffer->ptr(item->right);
-				if (right.valid()) {
-					auto oldRoot = fsData->rootNode;
-					fsData->rootNode = item->right;
-					if (left.valid()) {
-						auto err = placeItem(left);
-						// undo if unable to place the left side of the tree
-						if (err) {
-							fsData->rootNode = oldRoot;
-							return err;
-						}
-					}
-				} else if (left.valid()) {
-					fsData->rootNode = item->left;
-				} else {
-					fsData->rootNode = 0;
-				}
-				return OxError(0);
-			} else {
-				return unplaceItem(root, item);
-			}
-		}
+	if (!fsData) {
+		return OxError(1);
+	}
+	oxRequireM(root, m_buffer->ptr(fsData->rootNode).validate());
+	if (root->id == item->id) {
+		item->left = root->left;
+		item->right = root->right;
+		auto left = m_buffer->ptr(item->left);
+		auto right = m_buffer->ptr(item->right);
+		if (right.valid()) {
+			auto oldRoot = fsData->rootNode;
+			fsData->rootNode = item->right;
+			if (left.valid()) {
+				auto err = placeItem(left);
+				// undo if unable to place the left side of the tree
+				if (err) {
+					fsData->rootNode = oldRoot;
+					return err;
+				}
+			}
+		} else if (left.valid()) {
+			fsData->rootNode = item->left;
+		} else {
+			fsData->rootNode = 0;
+		}
+		return OxError(0);
+	} else {
+		return unplaceItem(root, item);
 	}
-	return OxError(1);
 }
 
 template<typename size_t>
 Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int depth) {
 	if (depth >= 5000) {
-		oxTrace("ox::fs::FileStoreTemplate::unplaceItem::fail") << "Excessive recursion depth, stopping before stack overflow.";
-		return OxError(1);
+		oxTrace("ox::fs::FileStoreTemplate::unplaceItem::fail", "Excessive recursion depth, stopping before stack overflow.");
+		return OxError(1, "Excessive recursion depth, stopping before stack overflow.");
 	}
 	if (item->id > root->id) {
 		auto right = m_buffer->ptr(root->right);
 		if (right->id == item->id) {
 			root->right = 0;
-			oxTrace("ox::fs::FileStoreTemplate::unplaceItem") << "Unplaced Item:" << item->id;
+			oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
 		} else {
 			return unplaceItem(right, item, depth + 1);
 		}
@@ -650,7 +617,7 @@ Error FileStoreTemplate<size_t>::unplaceItem(ItemPtr root, ItemPtr item, int dep
 		auto left = m_buffer->ptr(root->left);
 		if (left->id == item->id) {
 			root->left = 0;
-			oxTrace("ox::fs::FileStoreTemplate::unplaceItem") << "Unplaced Item:" << item->id;
+			oxTracef("ox::fs::FileStoreTemplate::unplaceItem", "Unplaced Item: {}", item->id.get());
 		} else {
 			return unplaceItem(left, item, depth + 1);
 		}
@@ -705,31 +672,30 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::findParen
 template<typename size_t>
 typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(ItemPtr item, InodeId_t id, int depth) const {
 	if (depth > 5000) {
-		oxTrace("ox::fs::FileStoreTemplate::find::fail") << "Excessive recursion depth, stopping before stack overflow. Search for:" << id;
+		oxTracef("ox::fs::FileStoreTemplate::find::fail", "Excessive recursion depth, stopping before stack overflow. Search for: {}", id);
 		return nullptr;
 	}
 	if (!item.valid()) {
-		oxTrace("ox::fs::FileStoreTemplate::find::fail") << "item invalid";
+		oxTrace("ox::fs::FileStoreTemplate::find::fail", "item invalid");
 		return nullptr;
 	}
-
+	// do search
 	if (id > item->id) {
-		oxTrace("ox::fs::FileStoreTemplate::find") << "Not a match, searching on" << item->right;
+		oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->right.get());
 		return find(m_buffer->ptr(item->right), id, depth + 1);
 	} else if (id < item->id) {
-		oxTrace("ox::fs::FileStoreTemplate::find") << "Not a match, searching on" << item->left;
+		oxTracef("ox::fs::FileStoreTemplate::find", "Not a match, searching on {}", item->left.get());
 		return find(m_buffer->ptr(item->left), id, depth + 1);
 	} else if (id == item->id) {
-		oxTrace("ox::fs::FileStoreTemplate::find") << "Found" << id << "at" << item;
+		oxTracef("ox::fs::FileStoreTemplate::find", "Found {} at {}", id, item.offset());
 		return item;
 	}
-
 	return nullptr;
 }
 
 template<typename size_t>
 typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(InodeId_t id) const {
-	oxTrace("ox::fs::FileStoreTemplate::find") << "Searching for inode:" << id;
+	oxTracef("ox::fs::FileStoreTemplate::find", "Searching for inode: {}", id);
 	auto fsData = fileStoreData();
 	if (fsData) {
 		auto root = m_buffer->ptr(fsData->rootNode);
@@ -737,10 +703,10 @@ typename FileStoreTemplate<size_t>::ItemPtr FileStoreTemplate<size_t>::find(Inod
 			auto item = find(root, id);
 			return item;
 		} else {
-			oxTrace("ox::fs::FileStoreTemplate::find::fail") << "No root node";
+			oxTrace("ox::fs::FileStoreTemplate::find::fail", "No root node");
 		}
 	} else {
-		oxTrace("ox::fs::FileStoreTemplate::find::fail") << "No FileStore Data";
+		oxTrace("ox::fs::FileStoreTemplate::find::fail", "No FileStore Data");
 	}
 	return nullptr;
 }
diff --git a/deps/ox/src/ox/fs/filesystem/directory.hpp b/deps/ox/src/ox/fs/filesystem/directory.hpp
index eb283239..7dacfe61 100644
--- a/deps/ox/src/ox/fs/filesystem/directory.hpp
+++ b/deps/ox/src/ox/fs/filesystem/directory.hpp
@@ -55,7 +55,7 @@ struct OX_PACKED DirectoryEntry {
 		}
 
 		ptrarith::Ptr<DirectoryEntryData, InodeId_t> data() {
-			oxTrace("ox::fs::DirectoryEntry::data") << this->fullSize() << sizeof(*this) << this->size();
+			oxTracef("ox::fs::DirectoryEntry::data", "{} {} {}", this->fullSize(), sizeof(*this), this->size());
 			return ptrarith::Ptr<DirectoryEntryData, InodeId_t>(this, this->fullSize(), sizeof(*this), this->size(), this->size());
 		}
 
@@ -132,7 +132,7 @@ Directory<FileStore, InodeId_t>::Directory(FileStore fs, InodeId_t inodeId) {
 template<typename FileStore, typename InodeId_t>
 Error Directory<FileStore, InodeId_t>::init() noexcept {
 	constexpr auto Size = sizeof(Buffer);
-	oxTrace("ox::fs::Directory::init") << "Initializing Directory with Inode ID:" << m_inodeId;
+	oxTracef("ox::fs::Directory::init", "Initializing Directory with Inode ID: {}", m_inodeId);
 	oxReturnError(m_fs.write(m_inodeId, nullptr, Size, static_cast<uint8_t>(FileType::Directory)));
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
@@ -147,7 +147,7 @@ Error Directory<FileStore, InodeId_t>::init() noexcept {
 template<typename FileStore, typename InodeId_t>
 Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, FileName *nameBuff) {
 	if (path.valid()) {
-		oxTrace("ox::fs::Directory::mkdir") << path.fullPath();
+		oxTrace("ox::fs::Directory::mkdir", path.fullPath());
 		// reuse nameBuff if it has already been allocated, as it is a rather large variable
 		if (nameBuff == nullptr) {
 			nameBuff = new (ox_alloca(sizeof(FileName))) FileName;
@@ -164,7 +164,7 @@ Error Directory<FileStore, InodeId_t>::mkdir(PathIterator path, bool parents, Fi
 				return OxError(1);
 			}
 			childInode = m_fs.generateInodeId();
-			oxTrace("ox::fs::Directory::mkdir") << "Generated Inode ID:" << childInode.value;
+			oxTracef("ox::fs::Directory::mkdir", "Generated Inode ID: {}", childInode.value);
 			oxLogError(childInode.error);
 			oxReturnError(childInode.error);
 
@@ -199,38 +199,34 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
 
 	if (path.next().hasNext()) { // not yet at target directory, recurse to next one
 		oxReturnError(path.get(name));
-
-		oxTrace("ox::fs::Directory::write") << "Attempting to write to next sub-Directory: "
-			<< name->c_str() << " of " << path.fullPath();
-
+		oxTracef("ox::fs::Directory::write", "Attempting to write to next sub-Directory: {} of {}",
+		        name->c_str(), path.fullPath());
 		oxRequire(nextChild, findEntry(*name));
-		oxTrace("ox::fs::Directory::write") << name->c_str() << ": " << nextChild;
-
+		oxTracef("ox::fs::Directory::write", "{}: {}", name->c_str(), nextChild);
 		if (nextChild) {
 			// reuse name because it is a rather large variable and will not be used again
 			// be attentive that this remains true
 			name = nullptr;
 			return Directory(m_fs, nextChild).write(path.next(), inode, nameBuff);
 		} else {
-			oxTrace("ox::fs::Directory::write") << name->c_str()
-				<< "not found and not allowed to create it.";
-			return OxError(1);
+			oxTracef("ox::fs::Directory::write", "{} not found and not allowed to create it.", name->c_str());
+			return OxError(1, "File not found and not allowed to create it.");
 		}
 	} else {
-		oxTrace("ox::fs::Directory::write") << path.fullPath();
+		oxTrace("ox::fs::Directory::write", path.fullPath());
 		// insert the new entry on this directory
 
 		// get the name
 		oxReturnError(path.next(name));
 
 		// find existing version of directory
-		oxTrace("ox::fs::Directory::write") << "Searching for directory inode" << m_inodeId;
+		oxTracef("ox::fs::Directory::write", "Searching for directory inode {}", m_inodeId);
 		oxRequire(oldStat, m_fs.stat(m_inodeId));
-		oxTrace("ox::fs::Directory::write") << "Found existing directory of size" << oldStat.size;
+		oxTracef("ox::fs::Directory::write", "Found existing directory of size {}", oldStat.size);
 		auto old = m_fs.read(m_inodeId).template to<Buffer>();
 		if (!old.valid()) {
-			oxTrace("ox::fs::Directory::write::fail") << "Could not read existing version of Directory";
-			return OxError(1);
+			oxTrace("ox::fs::Directory::write::fail", "Could not read existing version of Directory");
+			return OxError(1, "Could not read existing version of Directory");
 		}
 
 		const auto pathSize = name->len() + 1;
@@ -238,20 +234,19 @@ Error Directory<FileStore, InodeId_t>::write(PathIterator path, InodeId_t inode,
 		const auto newSize = oldStat.size + Buffer::spaceNeeded(entryDataSize);
 		auto cpy = ox_malloca(newSize, Buffer, *old, oldStat.size);
 		if (cpy == nullptr) {
-			oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for copy of Directory";
-			return OxError(1);
+			oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for copy of Directory");
+			return OxError(1, "Could not allocate memory for copy of Directory");
 		}
 
 		// TODO: look for old version of this entry and delete it
 		oxReturnError(cpy->setSize(newSize));
 		auto val = cpy->malloc(entryDataSize);
 		if (!val.valid()) {
-			oxTrace("ox::fs::Directory::write::fail") << "Could not allocate memory for new directory entry";
-			return OxError(1);
+			oxTrace("ox::fs::Directory::write::fail", "Could not allocate memory for new directory entry");
+			return OxError(1, "Could not allocate memory for new directory entry");
 		}
 
-		oxTrace("ox::fs::Directory::write") << "Attempting to write Directory entry:" << name->data();
-		oxTrace("ox::fs::Directory::write") << "Attempting to write Directory to FileStore";
+		oxTracef("ox::fs::Directory::write", "Attempting to write Directory entry: {}", name->data());
 		oxReturnError(val->init(inode, name->data(), val.size()));
 		return m_fs.write(m_inodeId, cpy, cpy->size(), static_cast<uint8_t>(FileType::Directory));
 	}
@@ -266,10 +261,10 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
 	auto &name = *nameBuff;
 	oxReturnError(path.get(&name));
 
-	oxTrace("ox::fs::Directory::remove") << name.c_str();
+	oxTrace("ox::fs::Directory::remove", name.c_str());
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (buff.valid()) {
-		oxTrace("ox::fs::Directory::remove") << "Found directory buffer.";
+		oxTrace("ox::fs::Directory::remove", "Found directory buffer.");
 		for (auto i = buff->iterator(); i.valid(); i.next()) {
 			auto data = i->data();
 			if (data.valid()) {
@@ -277,12 +272,12 @@ Error Directory<FileStore, InodeId_t>::remove(PathIterator path, FileName *nameB
 					oxReturnError(buff->free(i));
 				}
 			} else {
-				oxTrace("ox::fs::Directory::remove") << "INVALID DIRECTORY ENTRY";
+				oxTrace("ox::fs::Directory::remove", "INVALID DIRECTORY ENTRY");
 			}
 		}
 	} else {
-		oxTrace("ox::fs::Directory::remove::fail") << "Could not find directory buffer";
-		return OxError(1);
+		oxTrace("ox::fs::Directory::remove::fail", "Could not find directory buffer");
+		return OxError(1, "Could not find directory buffer");
 	}
 	return OxError(0);
 }
@@ -293,17 +288,17 @@ Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
 	oxTrace("ox::fs::Directory::ls");
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
-		oxTrace("ox::fs::Directory::ls::fail") << "Could not directory buffer";
-		return OxError(1);
+		oxTrace("ox::fs::Directory::ls::fail", "Could not directory buffer");
+		return OxError(1, "Could not directory buffer");
 	}
 
-	oxTrace("ox::fs::Directory::ls") << "Found directory buffer.";
+	oxTrace("ox::fs::Directory::ls", "Found directory buffer.");
 	for (auto i = buff->iterator(); i.valid(); i.next()) {
 		auto data = i->data();
 		if (data.valid()) {
 			oxReturnError(cb(data->name, data->inode));
 		} else {
-			oxTrace("ox::fs::Directory::ls") << "INVALID DIRECTORY ENTRY";
+			oxTrace("ox::fs::Directory::ls", "INVALID DIRECTORY ENTRY");
 		}
 	}
 
@@ -312,27 +307,27 @@ Error Directory<FileStore, InodeId_t>::ls(F cb) noexcept {
 
 template<typename FileStore, typename InodeId_t>
 Result<typename FileStore::InodeId_t> Directory<FileStore, InodeId_t>::findEntry(const FileName &name) const noexcept {
-	oxTrace("ox::fs::Directory::findEntry") << name.c_str();
+	oxTrace("ox::fs::Directory::findEntry", name.c_str());
 	auto buff = m_fs.read(m_inodeId).template to<Buffer>();
 	if (!buff.valid()) {
-		oxTrace("ox::fs::Directory::findEntry::fail") << "Could not findEntry directory buffer";
-		return OxError(2);
+		oxTrace("ox::fs::Directory::findEntry::fail", "Could not findEntry directory buffer");
+		return OxError(2, "Could not findEntry directory buffer");
 	}
-	oxTrace("ox::fs::Directory::findEntry") << "Found directory buffer, size:" << buff.size();
+	oxTracef("ox::fs::Directory::findEntry", "Found directory buffer, size: {}", buff.size());
 	for (auto i = buff->iterator(); i.valid(); i.next()) {
 		auto data = i->data();
 		if (data.valid()) {
-			oxTrace("ox::fs::Directory::findEntry").del("") << "Comparing \"" << name.c_str() << "\" to \"" << data->name << "\"";
+			oxTracef("ox::fs::Directory::findEntry", "Comparing \"{}\" to \"{}\"", name.c_str(), data->name);
 			if (ox_strncmp(data->name, name.c_str(), MaxFileNameLength) == 0) {
-				oxTrace("ox::fs::Directory::findEntry").del("") << "\"" << name.c_str() << "\" match found.";
+				oxTracef("ox::fs::Directory::findEntry", "\"{}\" match found.", name.c_str());
 				return static_cast<InodeId_t>(data->inode);
 			}
 		} else {
 			oxTrace("ox::fs::Directory::findEntry") << "INVALID DIRECTORY ENTRY";
 		}
 	}
-	oxTrace("ox::fs::Directory::findEntry::fail") << "Entry not present";
-	return OxError(1);
+	oxTrace("ox::fs::Directory::findEntry::fail", "Entry not present");
+	return OxError(1, "Entry not present");
 }
 
 template<typename FileStore, typename InodeId_t>
diff --git a/deps/ox/src/ox/fs/filesystem/filelocation.cpp b/deps/ox/src/ox/fs/filesystem/filelocation.cpp
index 2d7556d8..62d7a925 100644
--- a/deps/ox/src/ox/fs/filesystem/filelocation.cpp
+++ b/deps/ox/src/ox/fs/filesystem/filelocation.cpp
@@ -49,7 +49,7 @@ FileAddress::~FileAddress() noexcept {
 	cleanup();
 }
 
-const FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
+FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
 	cleanup();
 	m_type = other.m_type;
 	switch (m_type) {
@@ -70,7 +70,7 @@ const FileAddress &FileAddress::operator=(const FileAddress &other) noexcept {
 	return *this;
 }
 
-const FileAddress &FileAddress::operator=(FileAddress &&other) noexcept {
+FileAddress &FileAddress::operator=(FileAddress &&other) noexcept {
 	cleanup();
 	m_type = other.m_type;
 	memcpy(this, &other, sizeof(*this));
diff --git a/deps/ox/src/ox/fs/filesystem/filelocation.hpp b/deps/ox/src/ox/fs/filesystem/filelocation.hpp
index 3d546e20..b2b1a509 100644
--- a/deps/ox/src/ox/fs/filesystem/filelocation.hpp
+++ b/deps/ox/src/ox/fs/filesystem/filelocation.hpp
@@ -58,9 +58,9 @@ class FileAddress {
 
 		~FileAddress() noexcept;
 
-		const FileAddress &operator=(const FileAddress &other) noexcept;
+		FileAddress &operator=(const FileAddress &other) noexcept;
 
-		const FileAddress &operator=(FileAddress &&other) noexcept;
+		FileAddress &operator=(FileAddress &&other) noexcept;
 
 		[[nodiscard]]
 		constexpr FileAddressType type() const noexcept {
diff --git a/deps/ox/src/ox/fs/filesystem/filesystem.hpp b/deps/ox/src/ox/fs/filesystem/filesystem.hpp
index a0f947fc..d96a347c 100644
--- a/deps/ox/src/ox/fs/filesystem/filesystem.hpp
+++ b/deps/ox/src/ox/fs/filesystem/filesystem.hpp
@@ -209,11 +209,11 @@ Error FileSystemTemplate<FileStore, Directory>::format(void *buff, uint64_t buff
 
 	FileSystemData fd;
 	fd.rootDirInode = rootDirInode;
-	oxTrace("ox::fs::FileSystemTemplate::format") << "rootDirInode:" << fd.rootDirInode;
+	oxTracef("ox::fs::FileSystemTemplate::format", "rootDirInode: {}", fd.rootDirInode.get());
 	oxReturnError(fs.write(InodeFsData, &fd, sizeof(fd)));
 
 	if (!fs.read(fd.rootDirInode).valid()) {
-		oxTrace("ox::fs::FileSystemTemplate::format::error") << "FileSystemTemplate::format did not correctly create root directory";
+		oxTrace("ox::fs::FileSystemTemplate::format::error", "FileSystemTemplate::format did not correctly create root directory");
 		return OxError(1);
 	}
 
@@ -285,7 +285,7 @@ Result<Vector<String>> FileSystemTemplate<FileStore, Directory>::ls(const char *
 template<typename FileStore, typename Directory>
 template<typename F>
 Error FileSystemTemplate<FileStore, Directory>::ls(const char *path, F cb) {
-	oxTrace("ox::fs::FileSystemTemplate::ls") << "path:" << path;
+	oxTracef("ox::fs::FileSystemTemplate::ls", "path: {}", path);
 	oxRequire(s, stat(path));
 	Directory dir(m_fs, s.inode);
 	return dir.ls(cb);
@@ -304,7 +304,7 @@ Error FileSystemTemplate<FileStore, Directory>::remove(const char *path, bool re
 			return err;
 		}
 	} else {
-		oxTrace("FileSystemTemplate::remove::fail") << "Tried to remove directory without recursive setting.";
+		oxTrace("FileSystemTemplate::remove::fail", "Tried to remove directory without recursive setting.");
 		return OxError(1);
 	}
 	return OxError(0);
diff --git a/deps/ox/src/ox/fs/filesystem/passthroughfs.cpp b/deps/ox/src/ox/fs/filesystem/passthroughfs.cpp
index 305bf3cd..2591a245 100644
--- a/deps/ox/src/ox/fs/filesystem/passthroughfs.cpp
+++ b/deps/ox/src/ox/fs/filesystem/passthroughfs.cpp
@@ -31,7 +31,7 @@ Error PassThroughFS::mkdir(const char *path, bool recursive) noexcept {
 	bool success = false;
 	const auto p = m_path / stripSlash(path);
 	const auto u8p = p.u8string();
-	oxTrace("ox::fs::PassThroughFS::mkdir") << u8p.c_str();
+	oxTrace("ox::fs::PassThroughFS::mkdir", u8p.c_str());
 	if (recursive) {
 		std::error_code ec;
 		const auto isDir = std::filesystem::is_directory(p, ec);
@@ -65,7 +65,7 @@ Error PassThroughFS::read(const char *path, void *buffer, std::size_t buffSize)
 		const std::size_t size = file.tellg();
 		file.seekg(0, std::ios::beg);
 		if (size > buffSize) {
-			oxTrace("ox::fs::PassThroughFS::read::error") << "Read failed: Buffer too small:" << path;
+			oxTracef("ox::fs::PassThroughFS::read::error", "Read failed: Buffer too small: {}", path);
 			return OxError(1);
 		}
 		file.read(static_cast<char*>(buffer), buffSize);
@@ -146,10 +146,10 @@ Result<FileStat> PassThroughFS::stat(const char *path) noexcept {
 	const auto p = m_path / stripSlash(path);
 	const FileType type = std::filesystem::is_directory(p, ec) ?
 		FileType::Directory : FileType::NormalFile;
-	oxTrace("ox::fs::PassThroughFS::stat") << ec.message().c_str() << path;
+	oxTracef("ox::fs::PassThroughFS::stat", "{} {}", ec.message().c_str(), path);
 	const uint64_t size = type == FileType::Directory ? 0 : std::filesystem::file_size(p, ec);
-	oxTrace("ox::fs::PassThroughFS::stat") << ec.message().c_str() << path;
-	oxTrace("ox::fs::PassThroughFS::stat::size") << path << size;
+	oxTracef("ox::fs::PassThroughFS::stat", "{} {}", ec.message().c_str(), path);
+	oxTracef("ox::fs::PassThroughFS::stat::size", "{} {}", path, size);
 	oxReturnError(OxError(ec.value()));
 	return FileStat{0, 0, size, type};
 }
diff --git a/deps/ox/src/ox/fs/filesystem/pathiterator.cpp b/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
index 2eecbaaa..f7a36575 100644
--- a/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
+++ b/deps/ox/src/ox/fs/filesystem/pathiterator.cpp
@@ -61,11 +61,11 @@ Error PathIterator::fileName(char *out, std::size_t outSize) {
 Error PathIterator::get(char *pathOut, std::size_t pathOutSize) {
 	std::size_t size = 0;
 	if (m_iterator >= m_maxSize) {
-		oxTrace("ox::fs::PathIterator::get") << "m_iterator >= m_maxSize";
+		oxTracef("ox::fs::PathIterator::get", "m_iterator ({}) >= m_maxSize ({})", m_iterator, m_maxSize);
 		return OxError(1);
 	}
 	if (!ox_strlen(&m_path[m_iterator])) {
-		oxTrace("ox::fs::PathIterator::get") << "!ox_strlen(&m_path[m_iterator])";
+		oxTrace("ox::fs::PathIterator::get", "!ox_strlen(&m_path[m_iterator])");
 		return OxError(1);
 	}
 	auto start = m_iterator;
diff --git a/deps/ox/src/ox/fs/filesystem/pathiterator.hpp b/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
index 4a760e45..d05f063e 100644
--- a/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
+++ b/deps/ox/src/ox/fs/filesystem/pathiterator.hpp
@@ -61,12 +61,16 @@ class PathIterator {
 		 */
 		Result<std::size_t> nextSize() const;
 
+		[[nodiscard]]
 		bool hasNext() const;
 
+		[[nodiscard]]
 		bool valid() const;
 
-		[[nodiscard]] PathIterator next() const;
+		[[nodiscard]]
+		PathIterator next() const;
 
+		[[nodiscard]]
 		const char *fullPath() const;
 
 };
diff --git a/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp b/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp
index 53e9e76c..60110296 100644
--- a/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp
+++ b/deps/ox/src/ox/fs/ptrarith/nodebuffer.hpp
@@ -180,7 +180,7 @@ NodeBuffer<size_t, Item>::NodeBuffer(size_t size) noexcept {
 
 template<typename size_t, typename Item>
 NodeBuffer<size_t, Item>::NodeBuffer(const NodeBuffer &other, size_t size) noexcept {
-	oxTrace("ox::ptrarith::NodeBuffer::copy") << "other.m_header.firstItem:" << other.m_header.firstItem;
+	oxTracef("ox::ptrarith::NodeBuffer::copy", "other.m_header.firstItem: {}", other.m_header.firstItem.get());
 	auto data = reinterpret_cast<uint8_t*>(this) + sizeof(*this);
 	ox_memset(data, 0, size - sizeof(*this));
 	ox_memcpy(this, &other, size);
@@ -268,7 +268,7 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::ptr(size_t
 
 template<typename size_t, typename Item>
 typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size_t size) noexcept {
-	oxTrace("ox::ptrarith::NodeBuffer::malloc") << "Size:" << size;
+	oxTracef("ox::ptrarith::NodeBuffer::malloc", "Size: {}", size);
 	size_t fullSize = size + sizeof(Item);
 	if (m_header.size - m_header.bytesUsed >= fullSize) {
 		auto last = lastItem();
@@ -278,18 +278,18 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
 		} else {
 			// there is no first item, so this must be the first item
 			if (!m_header.firstItem) {
-				oxTrace("ox::ptrarith::NodeBuffer::malloc") << "No first item, initializing.";
+				oxTrace("ox::ptrarith::NodeBuffer::malloc", "No first item, initializing.");
 				m_header.firstItem = sizeof(m_header);
 				addr = m_header.firstItem;
 			} else {
-				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer is in invalid state.";
+				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer is in invalid state.");
 				return nullptr;
 			}
 		}
 		oxTracef("ox::ptrarith::NodeBuffer::malloc", "buffer size: {}; addr: {}; fullSize: {}", m_header.size.get(), addr, fullSize);
 		auto out = ItemPtr(this, m_header.size, addr, fullSize);
 		if (!out.valid()) {
-			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "Unknown";
+			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "Unknown");
 			return nullptr;
 		}
 		ox_memset(out, 0, fullSize);
@@ -302,7 +302,7 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
 		if (first.valid()) {
 			first->prev = out.offset();
 		} else {
-			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer malloc failed due to invalid first element pointer.";
+			oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid first element pointer.");
 			return nullptr;
 		}
 
@@ -312,22 +312,22 @@ typename NodeBuffer<size_t, Item>::ItemPtr NodeBuffer<size_t, Item>::malloc(size
 		} else { // check to see if this is the first allocation
 			if (out.offset() != first.offset()) {
 				// if this is not the first allocation, there should be an oldLast
-				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "NodeBuffer malloc failed due to invalid last element pointer.";
+				oxTrace("ox::ptrarith::NodeBuffer::malloc::fail", "NodeBuffer malloc failed due to invalid last element pointer.");
 				return nullptr;
 			}
 			out->prev = out.offset();
 		}
 		m_header.bytesUsed += out.size();
-		oxTrace("ox::ptrarith::NodeBuffer::malloc") << "Offset:" << out.offset();
+		oxTracef("ox::ptrarith::NodeBuffer::malloc", "Offset: {}", out.offset());
 		return out;
 	}
-	oxTrace("ox::ptrarith::NodeBuffer::malloc::fail") << "Insufficient space:" << fullSize << "needed," << available() << "available";
+	oxTracef("ox::ptrarith::NodeBuffer::malloc::fail", "Insufficient space: {} needed, {} available", fullSize, available());
 	return nullptr;
 }
 
 template<typename size_t, typename Item>
 Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
-	oxTrace("ox::ptrarith::NodeBuffer::free") << "offset:" << item.offset();
+	oxTracef("ox::ptrarith::NodeBuffer::free", "offset: {}", item.offset());
 	auto prev = this->prev(item);
 	auto next = this->next(item);
 	if (prev.valid() && next.valid()) {
@@ -339,16 +339,16 @@ Error NodeBuffer<size_t, Item>::free(ItemPtr item) noexcept {
 			}
 		} else {
 			// only one item, null out first
-			oxTrace("ox::ptrarith::NodeBuffer::free") << "Nulling out firstItem.";
+			oxTrace("ox::ptrarith::NodeBuffer::free", "Nulling out firstItem.");
 			m_header.firstItem = 0;
 		}
 	} else {
 		if (!prev.valid()) {
-			oxTrace("ox::ptrarith::NodeBuffer::free::fail") << "NodeBuffer free failed due to invalid prev element pointer:" << prev.offset();
+			oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid prev element pointer: {}", prev.offset());
 			return OxError(1);
 		}
 		if (!next.valid()) {
-			oxTrace("ox::ptrarith::NodeBuffer::free::fail") << "NodeBuffer free failed due to invalid next element pointer:" << next.offset();
+			oxTracef("ox::ptrarith::NodeBuffer::free::fail", "NodeBuffer free failed due to invalid next element pointer: {}", next.offset());
 			return OxError(1);
 		}
 	}
diff --git a/deps/ox/src/ox/fs/ptrarith/ptr.hpp b/deps/ox/src/ox/fs/ptrarith/ptr.hpp
index cb85e54e..2c6bfb2e 100644
--- a/deps/ox/src/ox/fs/ptrarith/ptr.hpp
+++ b/deps/ox/src/ox/fs/ptrarith/ptr.hpp
@@ -29,7 +29,7 @@ class [[nodiscard]] Ptr {
 
 		constexpr Ptr(std::nullptr_t) noexcept;
 
-		constexpr Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T)) noexcept;
+		constexpr Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize = sizeof(T), size_t itemTypeSize = sizeof(T), bool prevalidated = false) noexcept;
 
 		[[nodiscard]]
 		constexpr bool valid() const noexcept;
@@ -77,6 +77,8 @@ class [[nodiscard]] Ptr {
 		template<typename SubT>
 		constexpr const Ptr<SubT, size_t, minOffset> to() const noexcept;
 
+		constexpr Result<Ptr<T, size_t, minOffset>> validate() const noexcept;
+
 };
 
 template<typename T, typename size_t, size_t minOffset>
@@ -84,7 +86,7 @@ constexpr Ptr<T, size_t, minOffset>::Ptr(std::nullptr_t) noexcept {
 }
 
 template<typename T, typename size_t, size_t minOffset>
-constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize) noexcept {
+constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_t itemStart, size_t itemSize, size_t itemTypeSize, bool prevalidated) noexcept {
 	// do some sanity checks before assuming this is valid
 	if (itemSize >= itemTypeSize &&
 	    dataStart &&
@@ -94,6 +96,7 @@ constexpr Ptr<T, size_t, minOffset>::Ptr(void *dataStart, size_t dataSize, size_
 		m_dataSize = dataSize;
 		m_itemOffset = itemStart;
 		m_itemSize = itemSize;
+		m_validated = prevalidated;
 	}
 }
 
@@ -205,7 +208,7 @@ constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(s
 template<typename T, typename size_t, size_t minOffset>
 template<typename SubT>
 constexpr const Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) const noexcept {
-	oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset);
+	oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
 	return subPtr<SubT>(offset, m_itemSize - offset);
 }
 
@@ -218,7 +221,8 @@ constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t
 template<typename T, typename size_t, size_t minOffset>
 template<typename SubT>
 constexpr Ptr<SubT, size_t, sizeof(T)> Ptr<T, size_t, minOffset>::subPtr(size_t offset) noexcept {
-	oxTrace("ox::fs::Ptr::subPtr") << m_itemOffset << this->size() << offset << m_itemSize << (m_itemSize - offset);
+	oxTracef("ox::fs::Ptr::subPtr", "{} {} {} {} {}", m_itemOffset, this->size(), offset, m_itemSize, (m_itemSize - offset));
+	return subPtr<SubT>(offset, m_itemSize - offset);
 	return subPtr<SubT>(offset, m_itemSize - offset);
 }
 
@@ -228,4 +232,12 @@ constexpr const Ptr<SubT, size_t, minOffset> Ptr<T, size_t, minOffset>::to() con
 	return Ptr<SubT, size_t, minOffset>(m_dataStart, m_dataSize, m_itemOffset, m_itemSize);
 }
 
+template<typename T, typename size_t, size_t minOffset>
+constexpr Result<Ptr<T, size_t, minOffset>> Ptr<T, size_t, minOffset>::validate() const noexcept {
+	 if (valid()) {
+	 	return *this;
+	 }
+	 return OxError(1);
+}
+
 }
diff --git a/deps/ox/src/ox/fs/test/tests.cpp b/deps/ox/src/ox/fs/test/tests.cpp
index acb7c250..7f4e587e 100644
--- a/deps/ox/src/ox/fs/test/tests.cpp
+++ b/deps/ox/src/ox/fs/test/tests.cpp
@@ -20,6 +20,7 @@
 template<typename T>
 struct OX_PACKED NodeType: public ox::ptrarith::Item<T> {
 	public:
+		[[nodiscard]]
 		size_t fullSize() const {
 			return this->size() + sizeof(*this);
 		}
@@ -239,12 +240,12 @@ int main(int argc, const char **args) {
 	int retval = -1;
 	if (argc > 1) {
 		std::string_view testName = args[1];
-		std::string_view testArg = "";
+		std::string_view testArg;
 		if (args[2]) {
 			testArg = args[2];
 		}
 		if (tests.find(testName) != tests.end()) {
-			retval = tests.at(testName)(testArg);
+			retval = static_cast<int>(tests.at(testName)(testArg));
 		}
 	}
 	return retval;