pke: refactor FontRender to pk_bkt_arr

12 files changed, 469 insertions, 422 deletions

diff --git a/editor/editor.cpp b/editor/editor.cpp
index df5724c..2c66c8c 100644
--- a/editor/editor.cpp
+++ b/editor/editor.cpp
@@ -1423,10 +1423,10 @@ void RecordImGuiUITree() {
 			selected_ui_box = box;
 			FontRenderSettings frs{};
 			if (type == PKE_UI_BOX_TYPE_TEXT) {
-				box->type_data->text.font_render_handle = FontType_AddStringRender(FontTypeIndex(0), std::move(cstring_to_pk_cstr("")), &frs, box);
+				box->type_data->text.font_type_render = FontType_AddStringRender(FontTypeIndex(0), std::move(cstring_to_pk_cstr("")), &frs, box);
 			}
 			if (type == PKE_UI_BOX_TYPE_BUTTON_TEXT) {
-				box->type_data->button_text.font_render_handle = FontType_AddStringRender(FontTypeIndex(0), std::move(cstring_to_pk_cstr("")), &frs, box);
+				box->type_data->button_text.font_type_render = FontType_AddStringRender(FontTypeIndex(0), std::move(cstring_to_pk_cstr("")), &frs, box);
 			}
 			is_creating_new_box = false;
 			is_child = false;
@@ -1532,7 +1532,8 @@ void RecordImGuiUIEdit() {
 		assert(selected_ui_box->type_data != NULL);
 		ImGui::Text("Type: Text");
 		ImGui::Separator();
-		FontRender fr = *FontType_GetFontRender(selected_ui_box->type_data->text.font_render_handle);
+		FontRender fr = *FontType_GetFontRender(selected_ui_box->type_data->text.font_type_render);
+		ImGui::Text("FontRender: %.4hu:%.4hu", fr.fr_handle.b, fr.fr_handle.i);
 		const int buffer_len = 1024;
 		char *text_buffer = pk_new_arr<char>(buffer_len, pkeSettings.mem_bkt.game_transient);
 		size_t len = fr.text.length;
@@ -1546,14 +1547,14 @@ void RecordImGuiUIEdit() {
 			cstr.reserved = len+1;
 			cstr.length = len;
 			cstr.val = s;
-			FontType_UpdateStringRenderText(fr.fr_handle, std::move(cstr));
+			FontType_UpdateStringRenderText({fr.index_ft, {fr.fr_handle}}, std::move(cstr));
 			changed = true;
 		}
 		ImGui::SameLine();
 		ImGui::Text("(%.4zu/%4i)", len, buffer_len);
 		changed_sub = RecordImGui_FontRenderSettings(fr.settings, false);
 		if (changed_sub) {
-			FontType_UpdateStringRender(fr.fr_handle, &fr.settings);
+			FontType_UpdateStringRender({fr.index_ft, {fr.fr_handle}}, &fr.settings);
 		}
 		changed |= changed_sub;
 	}
@@ -1622,7 +1623,8 @@ void RecordImGuiUIEdit() {
 		assert(selected_ui_box->type_data != NULL);
 		ImGui::Text("Type: Button Text");
 		ImGui::Separator();
-		FontRender fr = *FontType_GetFontRender(selected_ui_box->type_data->button_text.font_render_handle);
+		FontRender fr = *FontType_GetFontRender(selected_ui_box->type_data->button_text.font_type_render);
+		ImGui::Text("FontRender: %.4hu:%.4hu", fr.fr_handle.b, fr.fr_handle.i);
 		const int buffer_len = 1024;
 		char *text_buffer = pk_new_arr<char>(buffer_len, pkeSettings.mem_bkt.game_transient);
 		size_t len = fr.text.length;
@@ -1636,14 +1638,14 @@ void RecordImGuiUIEdit() {
 			cstr.reserved = len+1;
 			cstr.length = len;
 			cstr.val = s;
-			FontType_UpdateStringRenderText(fr.fr_handle, std::move(cstr));
+			FontType_UpdateStringRenderText({fr.index_ft, {fr.fr_handle}}, std::move(cstr));
 			changed = true;
 		}
 		ImGui::SameLine();
 		ImGui::Text("(%.4zu/%4i)", len, buffer_len);
 		changed_sub = RecordImGui_FontRenderSettings(fr.settings, false);
 		if (changed_sub) {
-			FontType_UpdateStringRender(fr.fr_handle, &fr.settings);
+			FontType_UpdateStringRender({fr.index_ft, {fr.fr_handle}}, &fr.settings);
 		}
 		changed |= changed_sub;
 	}
diff --git a/src/font.cpp b/src/font.cpp
index 9ca42c5..496c052 100644
--- a/src/font.cpp
+++ b/src/font.cpp
@@ -29,7 +29,6 @@ const char *PKE_PROJECT_FONT_SPACING_UNDERLINE_Y = "spacing_underline_y: ";
 const char *PKE_PROJECT_FONT_SPACING_UNDERLINE_THICKNESS = "spacing_underline_thickness: ";
 
 TypeSafeInt_B(FontTypeIndex);
-TypeSafeInt_B(FontRenderIndex);
 TypeSafeInt_B(FONT_GLYPH_CHAR_FLAG);
 TypeSafeInt_B(FONT_RENDER_SURFACE_AREA_TYPE_FLAG);
 
@@ -37,6 +36,7 @@ struct FontTypeData {
 	FontType *arr_ft = nullptr;
 	uint64_t unused_fts = 0xFFFFFFFFFFFFFFFF;
 	FontTypeIndex n_ft{0};
+	pk_membucket *bkt;
 } ftd;
 
 struct FontInstanceBufferItem {
@@ -322,12 +322,13 @@ bool FontType_Inner_CalcTransforms(const FontType *ft, FontRender *fr, FontInsta
 
 void FontType_Init() {
 	FontTypeIndex fti;
+	ftd.bkt = pk_mem_bucket_create(__FILE__, PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
 	ftd.n_ft = FontTypeIndex{8};
-	ftd.arr_ft = pk_new_arr<FontType>(8);
+	ftd.arr_ft = pk_new_arr<FontType>(8, ftd.bkt);
 	for (FontTypeIndex_T i = 0; i < 8; ++i) {
 		FontType *ft = &ftd.arr_ft[i];
 		ft->glyphs = nullptr;
-		ft->renders = nullptr;
+		new (&ft->renders) pk_bkt_arr_t<FontRender>{pk_bkt_arr_handle_MAX, ftd.bkt, ftd.bkt};
 	}
 	union pke_asset_details ak_img_details {
 		.texture = {
@@ -359,7 +360,9 @@ void FontType_Teardown() {
 		if ((ftd.unused_fts & (1llu << i)) != 0) continue;
 		FontType_Unload(FontTypeIndex{(FontTypeIndex_T)i});
 	}
-	if (ftd.arr_ft != nullptr) pk_delete_arr<FontType>(ftd.arr_ft, (FontTypeIndex_T)ftd.n_ft);
+	if (ftd.arr_ft != nullptr) pk_delete_arr<FontType>(ftd.arr_ft, (FontTypeIndex_T)ftd.n_ft, ftd.bkt);
+	pk_mem_bucket_destroy(ftd.bkt);
+	ftd.bkt = nullptr;
 }
 
 // TODO - Memory Pressure
@@ -369,10 +372,8 @@ void FontType_Teardown() {
 void FontType_Tick(double delta) {
 	(void)delta;
 	VkResult vkResult;
-	FontInstanceBufferItem *fibis = nullptr;
 	size_t index;
 	FontType *ft;
-	FontRender *fr;
 	for (FontTypeIndex_T i = 0; i < (FontTypeIndex_T)ftd.n_ft; ++i) {
 
 		if ((ftd.unused_fts & (1llu << i)) != 0) continue;
@@ -380,24 +381,17 @@ void FontType_Tick(double delta) {
 		index = 0;
 		ft = &ftd.arr_ft[i];
 
-		for (FontRenderIndex_T k = 0; k < (FontRenderIndex_T)ft->n_render; ++k) {
-			if ((ft->unused_frs & (1llu << k)) != 0) continue;
-			fr = &ft->renders[k];
+		pk_bkt_arr_t<FontRender>::FN_Iter iter_fn;
+		iter_fn.func = [&ft, &index](FontRender *fr) {
 			if (fr->isMarkedForRemoval == true) {
-				if (fr->text.reserved > 0) {
-					// 2025-04-16 - JCB
-					// not passing a specific bucket because pk_cstr doesn't store it.
-					// FontType_AddStringRender requires a `pk_cstr &&`, so we are the proper owner.
-					// It's up to us to free it.
-					pk_delete_arr<char>(fr->text.val, fr->text.reserved);
-				}
-				ft->unused_frs |= (1llu << k);
-				new (fr) FontRender{};
+				if (fr->text.reserved > 0) { pk_delete_arr<char>(fr->text.val, fr->text.reserved); }
+				pk_bkt_arr_free_handle(&ft->renders, fr->fr_handle);
 				ft->gr.should_update_instance_buffer = true;
-				continue;
+				return;
 			}
 			index += fr->n_glyphs;
-		}
+		};
+		pk_bkt_arr_iterate(&ft->renders, iter_fn.invoke, &iter_fn);
 
 		if (ft->isMarkedForRemoval == true) {
 			FontType_Unload(FontTypeIndex{i});
@@ -408,22 +402,27 @@ void FontType_Tick(double delta) {
 			continue;
 		}
 
+		ft->bindings.instance_counter = index;
 		if (index == 0) {
-			ft->bindings.instance_counter = index;
 			continue;
 		}
 		ft->gr.should_update_instance_buffer = false;
 
-		fibis = pk_new_arr<FontInstanceBufferItem>(index);
-		ft->bindings.instance_counter = index;
+		pk_arr_t<FontInstanceBufferItem> fibis{};
+		pk_arr_resize(&fibis, index);
 		index = 0;
-		for (FontRenderIndex_T k = 0; k < (FontRenderIndex_T)ft->n_render; ++k) {
-			if ((ft->unused_frs & (1llu << k)) != 0) continue;
-			fr = &ft->renders[k];
+
+		iter_fn.func = [&ft, &index, &fibis](FontRender *fr) {
+			if (fr->isMarkedForRemoval == true) {
+				return;
+			}
+			pk_arr_resize(&fibis, index + fr->n_glyphs);
 			if (FontType_Inner_CalcTransforms(ft, fr, &fibis[index])) {
 				index += fr->n_glyphs;
 			}
-		}
+		};
+		pk_bkt_arr_iterate(&ft->renders, iter_fn.invoke, &iter_fn);
+		ft->bindings.instance_counter = index;
 
 		// check recreate buffer
 		if (ft->bindings.instance_buffer_max_count < index) {
@@ -436,7 +435,7 @@ void FontType_Tick(double delta) {
 			}
 
 			pkvk_buffer_create_data create_data{};
-			create_data.buffer_byte_length[0] = sizeof(FontInstanceBufferItem) * ft->bindings.instance_counter;
+			create_data.buffer_byte_length[0] = fibis.stride * fibis.next;
 			create_data.n_buffers = 1;
 			create_data.index_instance = 0;
 			create_data.index_index = -1;
@@ -450,7 +449,7 @@ void FontType_Tick(double delta) {
 		}
 
 		PKVK_TmpBufferDetails tmpBufferDetails{};
-		PKVK_BeginBuffer(graphicsFamilyIndex, sizeof(FontInstanceBufferItem) * ft->bindings.instance_counter, tmpBufferDetails);
+		PKVK_BeginBuffer(graphicsFamilyIndex, fibis.stride * fibis.next, tmpBufferDetails);
 		assert(tmpBufferDetails.buffer != VK_NULL_HANDLE);
 		{
 			VkCommandBufferBeginInfo vkCommandBufferBeginInfo;
@@ -462,12 +461,12 @@ void FontType_Tick(double delta) {
 			vkResult = vkBeginCommandBuffer(tmpBufferDetails.cmdBuffer, &vkCommandBufferBeginInfo);
 			assert(vkResult == VK_SUCCESS);
 
-			memcpy(tmpBufferDetails.deviceData, fibis, sizeof(FontInstanceBufferItem) * ft->bindings.instance_counter);
+			memcpy(tmpBufferDetails.deviceData, fibis.data, fibis.stride * fibis.next);
 
 			VkBufferCopy vk_buffer_copy{};
 			vk_buffer_copy.srcOffset = 0;
 			vk_buffer_copy.dstOffset = 0;
-			vk_buffer_copy.size = sizeof(FontInstanceBufferItem) * ft->bindings.instance_counter;
+			vk_buffer_copy.size = fibis.stride * fibis.next;
 			vkCmdCopyBuffer(tmpBufferDetails.cmdBuffer, tmpBufferDetails.buffer, ft->bindings.bd_instance.buffer, 1, &vk_buffer_copy);
 
 			vkResult = vkEndCommandBuffer(tmpBufferDetails.cmdBuffer);
@@ -489,7 +488,7 @@ void FontType_Tick(double delta) {
 			assert(vkResult == VK_SUCCESS);
 		}
 		PKVK_EndBuffer(tmpBufferDetails);
-		pk_delete_arr<FontInstanceBufferItem>(fibis, ft->bindings.instance_counter);
+		pk_arr_reset(&fibis);
 	}
 }
 
@@ -653,7 +652,6 @@ FontType* FontType_GetFonts(uint64_t &idx_unused) {
 
 FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle, AssetHandle glyphsHandle, FontTypeMSDFSettings *msdf_settings, FontTypeSpacing *spacing) {
 	VkResult vkResult;
-	constexpr VkDeviceSize startingGlyphCount = 4;
 	const Asset *fontTexture = nullptr;
 	const Asset *glyphs = nullptr;
 	FontTypeIndex idx{0};
@@ -680,11 +678,11 @@ FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle
 			throw "[font.cpp] out of font type slots";
 		}
 		ftd.n_ft = FontTypeIndex{8};
-		FontType *arr = pk_new_arr<FontType>((FontTypeIndex_T)ftd.n_ft);
+		FontType *arr = pk_new_arr<FontType>((FontTypeIndex_T)ftd.n_ft, ftd.bkt);
 		if (idx > FontTypeIndex{0}) {
 			memcpy(arr, ftd.arr_ft, sizeof(FontType) * (FontTypeIndex_T)idx);
 		}
-		if (ftd.arr_ft != nullptr && ftd.arr_ft != CAFE_BABE(FontType)) pk_delete_arr<FontType>(ftd.arr_ft, (FontTypeIndex_T)idx);
+		if (ftd.arr_ft != nullptr && ftd.arr_ft != CAFE_BABE(FontType)) pk_delete_arr<FontType>(ftd.arr_ft, (FontTypeIndex_T)idx, ftd.bkt);
 		ftd.arr_ft = arr;
 	}
 
@@ -695,9 +693,7 @@ FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle
 	ft->title = title;
 	ft->fontTextureAssetHandle = fontTextureHandle;
 	ft->glyphDetailsAssetHandle = glyphsHandle;
-	ft->renders = pk_new_arr<FontRender>(startingGlyphCount);
-	ft->n_render = FontRenderIndex{startingGlyphCount};
-	ft->unused_frs = 0xFFFFFFFFFFFFFFFF;
+	new (&ft->renders) pk_bkt_arr_t<FontRender>{pk_bkt_arr_handle_MAX, ftd.bkt, ftd.bkt};
 	ft->msdf_settings = *msdf_settings;
 	ft->spacing = *spacing;
 
@@ -832,15 +828,15 @@ void FontType_Unload(FontTypeIndex idx) {
 
 	FontType *ft = &ftd.arr_ft[(FontTypeIndex_T)idx];
 
-	// TODO specific bucket
-	if (ft->renders != nullptr) {
-		for (FontRenderIndex_T i = 0; i < (FontRenderIndex_T)ft->n_render; ++i) {
-			if ((ft->unused_frs & (1llu << i)) != 0) continue;
-			if (ft->renders[i].glyph_indices != nullptr) {
-				pk_delete_arr<uint32_t>(ft->renders[i].glyph_indices, ft->renders[i].n_glyphs);
+	if (ft->renders.head_r.b > 0 || ft->renders.head_r.i > 0) {
+		pk_bkt_arr_t<FontRender>::FN_Iter iter_fn{};
+		iter_fn.func = [](FontRender *fr) {
+			if (fr->glyph_indices != nullptr) {
+				pk_delete_arr<uint32_t>(fr->glyph_indices, fr->n_glyphs, ftd.bkt);
 			}
-		}
-		pk_delete_arr<FontRender>(ft->renders, (FontTypeIndex_T)ft->n_render);
+		};
+		pk_bkt_arr_iterate(&ft->renders, iter_fn.invoke, &iter_fn);
+		pk_bkt_arr_teardown(&ft->renders);
 	}
 
 	if (ft->gr.vkDescriptorSet != VK_NULL_HANDLE && ft->gr.vkDescriptorPool != VK_NULL_HANDLE) {
@@ -962,44 +958,27 @@ void FontType_cstr_to_unicode(const FontType &ft, pk_arr_t<uint32_t> &arr, const
 // However, the new buffer is exactly the length it needs to be and no greater.
 // Consider using a heuristic to allocate a buffer larger than needed.
 // At the time of writing, the only way to do this is to un-register text.
-FontRenderHandle FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&str, FontRenderSettings *settings, Entity_Base *parent, pk_uuid uuid) {
+FontTypeRender FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&str, FontRenderSettings *settings, Entity_Base *parent, pk_uuid uuid) {
 	assert(settings != nullptr);
 	FontType *ft = &ftd.arr_ft[(FontTypeIndex_T)idx_ft];
 	FontRender *fr;
-	FontRenderIndex_T fri;
+	FontTypeRender ret{};
 	uint32_t i, count;
-	FontRenderIndex idx_fr = FontRenderIndex{0};
 
-	for (fri = 0; fri < (FontRenderIndex_T)ft->n_render; ++fri) {
-		if ((ft->unused_frs & (1llu << fri)) != 0) {
-			ft->unused_frs &= ~(1llu << fri);
-			idx_fr = FontRenderIndex{fri};
-			break;
-		}
-	}
+	ret.index_ft = idx_ft;
+	ret.handle_fr = (FontRenderHandle)pk_bkt_arr_new_handle(&ft->renders);
+	fr = &ft->renders[ret.handle_fr];
 
-	if (idx_fr >= ft->n_render) {
-		if (idx_fr >= FontRenderIndex{PKE_FONT_MAX_FONT_RENDERS}) {
-			throw "[font.cpp] out of FontRender slots";
-		}
-		FontRenderIndex_T old_count{static_cast<FontRenderIndex_T>(ft->n_render)};
-		ft->n_render += FontRenderIndex{8};
-		FontRender *arr = pk_new_arr<FontRender>((FontRenderIndex_T)ft->n_render);
-		memcpy(arr, ft->renders, sizeof(FontRender) * old_count);
-		pk_delete_arr<FontRender>(ft->renders, old_count);
-		ft->renders = arr;
-	}
-	fr = &ft->renders[(FontRenderIndex_T)idx_fr];
 	new (fr) FontRender{};
 	fr->uuid = uuid;
 	ECS_CreateEntity(fr, parent);
-	fr->fr_handle.index_ft = idx_ft;
-	fr->fr_handle.index_fr = idx_fr;
+	fr->index_ft = idx_ft;
+	fr->fr_handle = ret.handle_fr;
 	fr->settings = *settings;
 	fr->text = str;
 
 	if (window == NULL) {
-		return fr->fr_handle;
+		return ret;
 	}
 
 	// insert new characters into tmp buffer
@@ -1013,7 +992,7 @@ FontRenderHandle FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&
 	// TODO specific bucket
 	count = glyph_indices.next;
 	fr->n_glyphs = count;
-	fr->glyph_indices = pk_new_arr<uint32_t>(count);
+	fr->glyph_indices = pk_new_arr<uint32_t>(count, ftd.bkt);
 	for (i = 0; i < count; ++i) {
 		fr->glyph_indices[i] = glyph_indices[i];
 	}
@@ -1021,35 +1000,35 @@ FontRenderHandle FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&
 
 	ft->gr.should_update_instance_buffer = true;
 
-	return fr->fr_handle;
+	return ret;
 }
 
-FontRender *FontType_GetFontRender(FontRenderHandle frh) {
+FontRender *FontType_GetFontRender(FontTypeRender frh) {
 	if ((ftd.unused_fts & (1llu << (FontTypeIndex_T)frh.index_ft)) != 0) {
 		return nullptr;
 	}
 	FontType *ft = &ftd.arr_ft[static_cast<FontTypeIndex_T>(frh.index_ft)];
-	if ((ft->unused_frs & (1llu << (FontRenderIndex_T)frh.index_fr)) != 0) {
+	if (pk_bkt_arr_handle_validate(&ft->renders, frh.handle_fr) != PK_BKT_ARR_HANDLE_VALIDATION_VALID) {
 		return nullptr;
 	}
-	return &ft->renders[static_cast<FontRenderIndex_T>(frh.index_fr)];
+	return &ft->renders[frh.handle_fr];
 }
 
-void FontType_UpdateStringRender(FontRenderHandle frh, FontRenderSettings *settings) {
+void FontType_UpdateStringRender(FontTypeRender frh, FontRenderSettings *settings) {
 	assert(settings != nullptr);
 	assert((ftd.unused_fts & (1llu << (FontTypeIndex_T)frh.index_ft)) == 0);
 	FontType *ft = &ftd.arr_ft[(FontTypeIndex_T)frh.index_ft];
-	assert((ft->unused_frs & (1llu << (FontTypeIndex_T)frh.index_fr)) == 0);
+	assert(pk_bkt_arr_handle_validate(&ft->renders, frh.handle_fr) == PK_BKT_ARR_HANDLE_VALIDATION_VALID);
 	ft->gr.should_update_instance_buffer = true;
-	ft->renders[(FontRenderIndex_T)frh.index_fr].settings = *settings;
+	ft->renders[frh.handle_fr].settings = *settings;
 }
 
-void FontType_UpdateStringRenderText(FontRenderHandle frh, pk_cstr &&cstr) {
+void FontType_UpdateStringRenderText(FontTypeRender frh, pk_cstr &&cstr) {
 	uint32_t i, count;
 	assert((ftd.unused_fts & (1llu << (FontTypeIndex_T)frh.index_ft)) == 0);
 	FontType &ft = ftd.arr_ft[static_cast<FontTypeIndex_T>(frh.index_ft)];
-	assert((ft.unused_frs & (1llu << (FontTypeIndex_T)frh.index_fr)) == 0);
-	FontRender &fr = ft.renders[static_cast<FontRenderIndex_T>(frh.index_fr)];
+	assert(pk_bkt_arr_handle_validate(&ft.renders, frh.handle_fr) == PK_BKT_ARR_HANDLE_VALIDATION_VALID);
+	FontRender &fr = ft.renders[frh.handle_fr];
 	pk_cstr old_str = fr.text;
 	if (window == NULL) {
 		return;
@@ -1063,23 +1042,23 @@ void FontType_UpdateStringRenderText(FontRenderHandle frh, pk_cstr &&cstr) {
 	// TODO specific bucket
 	count = glyph_indices.next;
 	fr.n_glyphs = count;
-	fr.glyph_indices = pk_new_arr<uint32_t>(count);
+	fr.glyph_indices = pk_new_arr<uint32_t>(count, ftd.bkt);
 	for (i = 0; i < count; ++i) {
 		fr.glyph_indices[i] = glyph_indices[i];
 	}
 	glyph_indices.data = nullptr;
-	if (fr.text.reserved > 0 && fr.text.val != NULL) pk_delete_arr<char>(fr.text.val, fr.text.reserved);
+	if (fr.text.reserved > 0 && fr.text.val != NULL) pk_delete_arr<char>(fr.text.val, fr.text.reserved, ftd.bkt);
 	fr.text = cstr;
 
 	ft.gr.should_update_instance_buffer = true;
 }
 
-void FontType_RemoveStringRender(FontRenderHandle handle) {
+void FontType_RemoveStringRender(FontTypeRender handle) {
 	FontRender *fr;
 	FontType *ft = &ftd.arr_ft[(FontTypeIndex_T)handle.index_ft];
 	// hack, but works
 	ft->gr.should_update_instance_buffer = true;
 
-	fr = &ft->renders[(FontRenderIndex_T)handle.index_fr];
+	fr = &ft->renders[handle.handle_fr];
 	ECS_MarkForRemoval(fr);
 }
diff --git a/src/font.hpp b/src/font.hpp
index dd1b682..cdbc309 100644
--- a/src/font.hpp
+++ b/src/font.hpp
@@ -8,10 +8,11 @@
 #include "vendor-glm-include.hpp"
 
 #define PKE_FONT_MAX_FONT_TYPES 64
-#define PKE_FONT_MAX_FONT_RENDERS 64
 
 TypeSafeInt_H(FontTypeIndex, uint16_t, 0xFFFF);
-TypeSafeInt_H(FontRenderIndex, uint16_t, 0xFFFF);
+struct FontRenderHandle : pk_bkt_arr_handle {};
+
+constexpr FontRenderHandle FontRenderHandle_MAX = FontRenderHandle{ pk_bkt_arr_handle_MAX_constexpr };
 
 TypeSafeInt_H(FONT_GLYPH_CHAR_FLAG, uint8_t, 0xFF);
 TypeSafeInt_H(FONT_RENDER_FLAG, uint8_t, 0xFF);
@@ -40,14 +41,14 @@ const FONT_RENDER_SURFACE_AREA_TYPE_FLAG FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CEN
 const FONT_RENDER_SURFACE_AREA_TYPE_FLAG FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH
     = FONT_RENDER_SURFACE_AREA_TYPE_FLAG((1u << 0) | (1u << 1));
 
-struct FontRenderHandle {
+struct FontTypeRender {
 	FontTypeIndex index_ft;
-	FontRenderIndex index_fr;
+	FontRenderHandle handle_fr;
 };
 
-constexpr struct FontRenderHandle FontRenderHandle_MAX = {
+constexpr FontTypeRender FontTypeRender_MAX = {
 	.index_ft = FontTypeIndex_MAX,
-	.index_fr = FontRenderIndex_MAX,
+	.handle_fr = { pk_bkt_arr_handle_MAX },
 };
 
 struct FontGlyphChar {
@@ -71,6 +72,7 @@ struct FontRenderSettings {
 };
 struct FontRender : public Entity_Base {
 	uint32_t *glyph_indices = nullptr;
+	FontTypeIndex index_ft = FontTypeIndex{0};
 	FontRenderHandle fr_handle = FontRenderHandle_MAX;
 	uint32_t n_glyphs = 0;
 	uint32_t buffer_start_index = 0;
@@ -95,11 +97,9 @@ struct FontType : public Entity_Base {
 	AssetHandle fontTextureAssetHandle;
 	AssetHandle glyphDetailsAssetHandle;
 	FontGlyphChar *glyphs;
-	FontRender *renders = nullptr;
 	glm::vec2 atlas_size;
 	uint32_t n_glyphs;
-	FontRenderIndex n_render = FontRenderIndex{0};
-	uint64_t unused_frs;
+	pk_bkt_arr_t<FontRender> renders;
 	FontTypeIndex index_ft = FontTypeIndex{0};
 	struct FontTypeMSDFSettings msdf_settings;
 	struct FontTypeSpacing spacing;
@@ -134,10 +134,10 @@ FontType* FontType_Get(FontTypeIndex idx);
 FontType* FontType_GetByTitle(const pk_cstr title);
 FontType* FontType_GetFonts(uint64_t &idx_unused);
 FontTypeIndex FontType_RegisterFont(pk_cstr title, AssetHandle fontTextureHandle, AssetHandle glyphsHandle, FontTypeMSDFSettings *msdf_settings, FontTypeSpacing *spacing);
-FontRenderHandle FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&str, FontRenderSettings *settings, Entity_Base *parent = nullptr, pk_uuid uuid = pk_uuid_zed);
-FontRender *FontType_GetFontRender(FontRenderHandle frh);
-void FontType_UpdateStringRender(FontRenderHandle frh, FontRenderSettings *settings);
-void FontType_UpdateStringRenderText(FontRenderHandle frh, pk_cstr &&cstr);
-void FontType_RemoveStringRender(FontRenderHandle frh);
+FontTypeRender FontType_AddStringRender(FontTypeIndex idx_ft, const pk_cstr &&str, FontRenderSettings *settings, Entity_Base *parent = nullptr, pk_uuid uuid = pk_uuid_zed);
+FontRender *FontType_GetFontRender(FontTypeRender frh);
+void FontType_UpdateStringRender(FontTypeRender frh, FontRenderSettings *settings);
+void FontType_UpdateStringRenderText(FontTypeRender frh, pk_cstr &&cstr);
+void FontType_RemoveStringRender(FontTypeRender frh);
 
 #endif /* PKE_FONT_TYPE_HPP */
diff --git a/src/plugins.cpp b/src/plugins.cpp
index 838237b..a702e39 100644
--- a/src/plugins.cpp
+++ b/src/plugins.cpp
@@ -13,9 +13,9 @@
 	#include <dlfcn.h>
 #endif
 
-pk_arr_t<PKEPluginInterface> LoadedPkePlugins;
-pk_arr_t<PkeCallback> pkePluginCallbacks;
-pk_arr_t<CallbackSignature> sortedSignatures;
+pk_arr_t<PKEPluginInterface> LoadedPkePlugins{};
+pk_arr_t<PkeCallback> pkePluginCallbacks{};
+pk_arr_t<CallbackSignature> sortedSignatures{};
 
 void PkePlugin_Load(const char *path) {
 	if (path == nullptr || path == CAFE_BABE(const char)) {
diff --git a/src/serialization-font.cpp b/src/serialization-font.cpp
index f2fb24b..328aa94 100644
--- a/src/serialization-font.cpp
+++ b/src/serialization-font.cpp
@@ -41,7 +41,7 @@ pk_handle pke_serialize_font_render(srlztn_serialize_helper *h, FontRender *fr)
 	}
 	{
 		kve.key = SRLZTN_UI_FONT_RENDER_FONT_TYPE_TITLE;
-		FontType *ft = FontType_Get(fr->fr_handle.index_ft);
+		FontType *ft = FontType_Get(fr->index_ft);
 		len = snprintf(nullptr, 0, "%s", ft->title.val);
 		s = pk_new_arr<char>(len+1, h->bkt);
 		sprintf(s, "%s", ft->title.val);
diff --git a/src/serialization-static-ui.cpp b/src/serialization-static-ui.cpp
index ae948ab..373bc16 100644
--- a/src/serialization-static-ui.cpp
+++ b/src/serialization-static-ui.cpp
@@ -25,7 +25,7 @@ pk_handle pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_t
 	{
 		kve.key = SRLZTN_UI_BOX_DATA_TEXT_FONT_RENDER_UUID;
 		s = pk_new_arr<char>(37, h->bkt);
-		FontRender *fr = FontType_GetFontRender(data->font_render_handle);
+		FontRender *fr = FontType_GetFontRender(data->font_type_render);
 		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(fr->uuid));
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
@@ -58,7 +58,7 @@ pk_handle pke_serialize_ui_box_internal(srlztn_serialize_helper *h, pke_ui_box_t
 	{
 		kve.key = SRLZTN_UI_BOX_DATA_BUTTON_TEXT_FONT_RENDER_UUID;
 		s = pk_new_arr<char>(37, h->bkt);
-		FontRender *fr = FontType_GetFontRender(data->font_render_handle);
+		FontRender *fr = FontType_GetFontRender(data->font_type_render);
 		sprintf(s, pk_uuid_printf_format, pk_uuid_printf_var(fr->uuid));
 		kve.val = s;
 		kve.end = SRLZTN_KVE_END;
@@ -139,7 +139,7 @@ void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_conta
 
 	FontRender *fr = static_cast<FontRender *>(ECS_GetEntityByUUID(font_render_uuid));
 
-	data->font_render_handle = fr->fr_handle;
+	data->font_type_render = {fr->index_ft, {fr->fr_handle}};
 }
 
 void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_ui_box_type_data::pke_ui_box_type_data_button_text *data) {
@@ -150,7 +150,7 @@ void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_conta
 	pk_uuid font_render_uuid = pk_uuid_zed;
 
 	// TODO
-	data->font_render_handle = FontRenderHandle_MAX;
+	data->font_type_render = FontTypeRender_MAX;
 	data->pke_event_handle = PkeEventHandle_MAX;
 	data->ev_id = pk_ev_id_T{0};
 
@@ -163,7 +163,7 @@ void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_conta
 
 	FontRender *fr = static_cast<FontRender *>(ECS_GetEntityByUUID(font_render_uuid));
 
-	data->font_render_handle = fr->fr_handle;
+	data->font_type_render = {fr->index_ft, {fr->fr_handle}};
 }
 
 void pke_deserialize_ui_box_internal(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_ui_box_type_data::pke_ui_box_type_data_button_image *data) {
diff --git a/src/serialization.cpp b/src/serialization.cpp
index 63415e0..a09a332 100644
--- a/src/serialization.cpp
+++ b/src/serialization.cpp
@@ -85,10 +85,11 @@ void pke_serialize_scene(srlztn_serialize_helper *h) {
 	for (FontTypeIndex_T b = 0; b < PKE_FONT_MAX_FONT_TYPES; ++b) {
 		if ((idx_unused & (1llu << b)) != 0) continue;
 		FontType *ft = &fonts[b];
-		for (FontRenderIndex_T i = 0; i < (FontRenderIndex_T)ft->n_render; ++i) {
-			if ((ft->unused_frs & (1llu << i)) != 0) continue;
-			pke_serialize_font_render(h, &ft->renders[i]);
-		}
+		pk_bkt_arr_t<FontRender>::FN_Iter iter_fn{};
+		iter_fn.func = [&h](FontRender *fr) {
+			pke_serialize_font_render(h, fr);
+		};
+		pk_bkt_arr_iterate(&ft->renders, iter_fn.invoke, &iter_fn);
 	}
 
 	pke_ui_box_count_T box_count;
diff --git a/src/static-ui.cpp b/src/static-ui.cpp
index 505f4bc..8addb7e 100644
--- a/src/static-ui.cpp
+++ b/src/static-ui.cpp
@@ -396,7 +396,7 @@ bool pke_ui_calc_px(pk_arr_t<pke_ui_box_instance_buffer_item> &buffer, pk_arr_t<
 	FontRenderSettings frs;
 	switch (box->type) {
 		case PKE_UI_BOX_TYPE_TEXT:
-			frs = FontType_GetFontRender(box->type_data->text.font_render_handle)->settings;
+			frs = FontType_GetFontRender(box->type_data->text.font_type_render)->settings;
 			frs.surface_area_pos = box->internal.px_corner;
 			frs.surface_area_size = box->internal.px_size;
 			if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE)) {
@@ -404,10 +404,10 @@ bool pke_ui_calc_px(pk_arr_t<pke_ui_box_instance_buffer_item> &buffer, pk_arr_t<
 			} else {
 				frs.flags = FONT_RENDER_FLAG(FONT_RENDER_FLAG_T(frs.flags) & (~FONT_RENDER_FLAG_T(FONT_RENDER_FLAG_VISIBILITY_INVISIBLE)));
 			}
-			FontType_UpdateStringRender(box->type_data->text.font_render_handle, &frs);
+			FontType_UpdateStringRender(box->type_data->text.font_type_render, &frs);
 			break;
 		case PKE_UI_BOX_TYPE_BUTTON_TEXT:
-			frs = FontType_GetFontRender(box->type_data->button_text.font_render_handle)->settings;
+			frs = FontType_GetFontRender(box->type_data->button_text.font_type_render)->settings;
 			frs.surface_area_pos = box->internal.px_corner;
 			frs.surface_area_size = box->internal.px_size;
 			if (PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE)) {
@@ -415,7 +415,7 @@ bool pke_ui_calc_px(pk_arr_t<pke_ui_box_instance_buffer_item> &buffer, pk_arr_t<
 			} else {
 				frs.flags = FONT_RENDER_FLAG(FONT_RENDER_FLAG_T(frs.flags) & (~FONT_RENDER_FLAG_T(FONT_RENDER_FLAG_VISIBILITY_INVISIBLE)));
 			}
-			FontType_UpdateStringRender(box->type_data->button_text.font_render_handle, &frs);
+			FontType_UpdateStringRender(box->type_data->button_text.font_type_render, &frs);
 			break;
 		case PKE_UI_BOX_TYPE_BUTTON_IMAGE:
 			break;
@@ -749,15 +749,15 @@ void pke_ui_teardown_box_recursive(pke_ui_box *box, uint8_t depth) {
 				// If correctly parented, this is unnecessary, but serialization does
 				//  not construct text boxes in this way.
 				// Handle to avoid memory leaks.
-				fr = FontType_GetFontRender(box->type_data->text.font_render_handle);
+				fr = FontType_GetFontRender(box->type_data->text.font_type_render);
 				if (fr != nullptr && fr->parentHandle != box->handle) {
-					FontType_RemoveStringRender(box->type_data->text.font_render_handle);
+					FontType_RemoveStringRender(box->type_data->text.font_type_render);
 				}
 				break;
 			case PKE_UI_BOX_TYPE_BUTTON_TEXT:
-				fr = FontType_GetFontRender(box->type_data->button_text.font_render_handle);
+				fr = FontType_GetFontRender(box->type_data->button_text.font_type_render);
 				if (fr != nullptr && fr->parentHandle != box->handle) {
-					FontType_RemoveStringRender(box->type_data->button_text.font_render_handle);
+					FontType_RemoveStringRender(box->type_data->button_text.font_type_render);
 				}
 				break;
 			case PKE_UI_BOX_TYPE_BUTTON_IMAGE:
@@ -887,7 +887,7 @@ void pke_ui_internal_new_typed_box(pke_ui_box *box, const PKE_UI_BOX_TYPE type)
 			break;
 		case PKE_UI_BOX_TYPE_BUTTON_TEXT:
 			tp_data = pk_new<pke_ui_box_type_data>(pke_ui_master.bkt);
-			tp_data->button_text.font_render_handle = FontRenderHandle_MAX;
+			tp_data->button_text.font_type_render = FontTypeRender_MAX;
 			pressed_ev = ECS_CreateEv(box, pk_uuid_max);
 			tp_data->button_text.pke_event_handle = pressed_ev->pke_event_handle;
 			tp_data->button_text.ev_id = pressed_ev->ev_id;
diff --git a/src/static-ui.hpp b/src/static-ui.hpp
index e4c86af..17301a1 100644
--- a/src/static-ui.hpp
+++ b/src/static-ui.hpp
@@ -141,10 +141,10 @@ struct pke_ui_box : public Entity_Base {
 // separate these if they become silly
 union pke_ui_box_type_data {
 	struct pke_ui_box_type_data_text {
-		FontRenderHandle font_render_handle;
+		FontTypeRender font_type_render;
 	} text;
 	struct pke_ui_box_type_data_button_text {
-		FontRenderHandle font_render_handle;
+		FontTypeRender font_type_render;
 		PkeEventHandle pke_event_handle;
 		pk_ev_id_T ev_id;
 	} button_text;
diff --git a/tests/pke-test-font.cpp b/tests/pke-test-font.cpp
index a766f26..620715d 100644
--- a/tests/pke-test-font.cpp
+++ b/tests/pke-test-font.cpp
@@ -51,25 +51,53 @@ int pke_test_font_001() {
 int pke_test_font_002() {
 	int err_index = 0;
 	FontTypeIndex fti{0};
-	FontRenderHandle handle_001{};
-	FontRenderHandle handle_002{};
+	FontTypeRender handle_001{};
+	FontTypeRender handle_002{};
 	FontRenderSettings frs{};
 
 	handle_001 = FontType_AddStringRender(fti, std::move(cstring_to_pk_cstr("string one")), &frs);
 
 	PKE_TEST_ASSERT(handle_001.index_ft == FontTypeIndex{0}, err_index);
-	PKE_TEST_ASSERT(handle_001.index_fr == FontRenderIndex{0}, err_index);
+	PKE_TEST_ASSERT(handle_001.handle_fr.b == 0u, err_index);
+	PKE_TEST_ASSERT(handle_001.handle_fr.i == 0u, err_index);
 
 	handle_002 = FontType_AddStringRender(fti, std::move(cstring_to_pk_cstr("string two")), &frs);
 
 	PKE_TEST_ASSERT(handle_002.index_ft == FontTypeIndex{0}, err_index);
-	PKE_TEST_ASSERT(handle_002.index_fr == FontRenderIndex{1}, err_index);
+	PKE_TEST_ASSERT(handle_002.handle_fr.b == 0u, err_index);
+	PKE_TEST_ASSERT(handle_002.handle_fr.i == 1u, err_index);
+
+	return 0;
+}
+
+/* Ensure we can have a lot of FontRenders
+ */
+int pke_test_font_003() {
+	unsigned short u;
+	const unsigned short count = 96;
+	FontTypeIndex fti{0};
+	FontTypeRender handles[count];
+	FontRenderSettings frs{};
+
+	for (u = 0; u < count; ++u) {
+		handles[u].index_ft = FontTypeIndex{0};
+		handles[u].handle_fr = {0,0};
+	}
+
+	for (u = 0; u < count; ++u) {
+		char *s = (char*)malloc(64);
+		snprintf(s, 1024, "%s - %u", "test", u);
+		handles[u] = FontType_AddStringRender(fti, std::move(cstring_to_pk_cstr(s)), &frs);
+		PK_TEST_ASSERT_EQ_RET((FontTypeIndex_T)FontTypeIndex{0}, (FontTypeIndex_T)handles[u].index_ft);
+		PK_TEST_ASSERT_EQ_RET(floor(u / (float)PK_BKT_ARR_HANDLE_I_MAX), handles[u].handle_fr.b);
+		PK_TEST_ASSERT_EQ_RET(u % PK_BKT_ARR_HANDLE_I_MAX, handles[u].handle_fr.i);
+	}
 
 	return 0;
 }
 
 struct pk_test_group *pke_test_font_get_group() {
-	static const uint64_t test_count = 2;
+	static const uint64_t test_count = 3;
 	static struct pk_test tests[test_count] = {
 		{
 			.title = "test 001",
@@ -81,6 +109,11 @@ struct pk_test_group *pke_test_font_get_group() {
 			.func = pke_test_font_002,
 			.expected_result = 0,
 		},
+		{
+			.title = "test 003",
+			.func = pke_test_font_003,
+			.expected_result = 0,
+		},
 	};
 	static struct pk_test_group group = {};
 	group.title = "font test";
diff --git a/tests/pke-test-load-unload.cpp b/tests/pke-test-load-unload.cpp
index e421aee..61d901c 100644
--- a/tests/pke-test-load-unload.cpp
+++ b/tests/pke-test-load-unload.cpp
@@ -141,7 +141,7 @@ int pke_test_load_unload_do_thing_002(int iteration) {
 	pkeSettings.rt.nextLevel = level_01;
 	pke_ui_box *bx = pke_ui_box_new_root(PKE_UI_BOX_TYPE_TEXT);
 	FontRenderSettings frs_01{};
-	bx->type_data->text.font_render_handle = FontType_AddStringRender(FontTypeIndex{0}, std::move(cstring_to_pk_cstr("one")), &frs_01, bx);
+	bx->type_data->text.font_type_render = FontType_AddStringRender(FontTypeIndex{0}, std::move(cstring_to_pk_cstr("one")), &frs_01, bx);
 	bx->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
 	pke_level_register_root_ui_box(level_01, bx);
 
diff --git a/tests/pke-test-serialization.cpp b/tests/pke-test-serialization.cpp
index 73d5a1b..021b659 100644
--- a/tests/pke-test-serialization.cpp
+++ b/tests/pke-test-serialization.cpp
@@ -2,10 +2,10 @@
 #include "./pke-test-serialization.h"
 
 #include "asset-manager.hpp"
-#include "font.hpp"
-#include "game-settings.hpp"
 #include "camera.hpp"
 #include "ecs.hpp"
+#include "font.hpp"
+#include "game-settings.hpp"
 #include "level.hpp"
 #include "physics.hpp"
 #include "pk.h"
@@ -16,6 +16,7 @@
 #include "serialization.hpp"
 #include "static-ui.hpp"
 #include "thread-pool.hpp"
+#include "vendor-glm-include.hpp"
 
 #include <cstring>
 #include <sstream>
@@ -92,46 +93,42 @@ void pke_test_serialization_teardown() {
 };
 
 int pke_test_serialization_999() {
-	int64_t err_index = 0;
 	pke_kve_container kvec{};
 	pke_kve kve{};
 	const pk_handle zed_handle = {0,0};
-	PKE_TEST_ASSERT(kvec.srlztn_handle == zed_handle, err_index);
-
-	PKE_TEST_ASSERT(kvec.type_code.length == 0, err_index);
-	PKE_TEST_ASSERT(kvec.type_code.reserved == 0, err_index);
-	PKE_TEST_ASSERT(kvec.type_code.val == nullptr, err_index);
-
-	PKE_TEST_ASSERT(kvec.bkt == nullptr, err_index);
-
-	// 6
-	PKE_TEST_ASSERT(kvec.child_handles.next == 0, err_index);
-	PKE_TEST_ASSERT(kvec.child_handles.reserved == 0, err_index);
-	PKE_TEST_ASSERT(kvec.child_handles.stride == sizeof(pk_handle), err_index);
-	PKE_TEST_ASSERT(kvec.child_handles.alignment == alignof(pk_handle), err_index);
-	PKE_TEST_ASSERT(kvec.child_handles.bkt == nullptr, err_index);
-	PKE_TEST_ASSERT(kvec.child_handles.data == nullptr, err_index);
-
-	// 12
-	PKE_TEST_ASSERT(kvec.children.next == 0, err_index);
-	PKE_TEST_ASSERT(kvec.children.reserved == 0, err_index);
-	PKE_TEST_ASSERT(kvec.children.stride == sizeof(pke_kve_container*), err_index);
-	PKE_TEST_ASSERT(kvec.children.alignment == alignof(pke_kve_container*), err_index);
-	PKE_TEST_ASSERT(kvec.children.bkt == nullptr, err_index);
-	PKE_TEST_ASSERT(kvec.children.data == nullptr, err_index);
-
-	// 18
-	PKE_TEST_ASSERT(kvec.arr.next == 0, err_index);
-	PKE_TEST_ASSERT(kvec.arr.reserved == 0, err_index);
-	PKE_TEST_ASSERT(kvec.arr.stride == sizeof(pke_kve), err_index);
-	PKE_TEST_ASSERT(kvec.arr.alignment == alignof(pke_kve), err_index);
-	PKE_TEST_ASSERT(kvec.arr.bkt == nullptr, err_index);
-	PKE_TEST_ASSERT(kvec.arr.data == nullptr, err_index);
-
-	// 24
-	PKE_TEST_ASSERT(kve.key == nullptr, err_index);
-	PKE_TEST_ASSERT(kve.val == nullptr, err_index);
-	PKE_TEST_ASSERT(kve.end == nullptr, err_index);
+	PK_TEST_ASSERT_EQ_RET(zed_handle.bucketIndex, kvec.srlztn_handle.bucketIndex);
+	PK_TEST_ASSERT_EQ_RET(zed_handle.itemIndex, kvec.srlztn_handle.itemIndex);
+
+	PK_TEST_ASSERT_EQ_RET(0, kvec.type_code.length);
+	PK_TEST_ASSERT_EQ_RET(0, kvec.type_code.reserved);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.type_code.val);
+
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.bkt);
+
+	PK_TEST_ASSERT_EQ_RET(0, kvec.child_handles.next);
+	PK_TEST_ASSERT_EQ_RET(0, kvec.child_handles.reserved);
+	PK_TEST_ASSERT_EQ_RET(sizeof(pk_handle), kvec.child_handles.stride);
+	PK_TEST_ASSERT_EQ_RET(alignof(pk_handle), kvec.child_handles.alignment);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.child_handles.bkt);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.child_handles.data);
+
+	PK_TEST_ASSERT_EQ_RET(0, kvec.children.next);
+	PK_TEST_ASSERT_EQ_RET(0, kvec.children.reserved);
+	PK_TEST_ASSERT_EQ_RET(sizeof(pke_kve_container*), kvec.children.stride);
+	PK_TEST_ASSERT_EQ_RET(alignof(pke_kve_container*), kvec.children.alignment);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.children.bkt);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.children.data);
+
+	PK_TEST_ASSERT_EQ_RET(0, kvec.arr.next);
+	PK_TEST_ASSERT_EQ_RET(0, kvec.arr.reserved);
+	PK_TEST_ASSERT_EQ_RET(sizeof(pke_kve), kvec.arr.stride);
+	PK_TEST_ASSERT_EQ_RET(alignof(pke_kve), kvec.arr.alignment);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.arr.bkt);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kvec.arr.data);
+
+	PK_TEST_ASSERT_EQ_RET(nullptr, kve.key);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kve.val);
+	PK_TEST_ASSERT_EQ_RET(nullptr, kve.end);
 	return 0;
 }
 
@@ -145,8 +142,8 @@ Scale:5.000000;4.000000;3.000000
 
 :PKFE:)VOGON";
 int pke_test_serialization_001() {
+	int i;
 	pk_funcinstr_init();
-	int64_t err_index = 0, i;
 	srlztn_serialize_helper *h;
 	std::stringstream ss;
 	try {
@@ -159,21 +156,19 @@ int pke_test_serialization_001() {
 
 		pke_serialize_scene_to_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers.next);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[0].arr.next);
 		for (i = 0; i < 3; ++i) {
-			// 6,9,12
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].key != nullptr, err_index);
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].val != nullptr, err_index);
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].end != nullptr, err_index);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].key);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].val);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].end);
 		}
 
 		std::string s = ss.str();
-		// 15
-		PKE_TEST_ASSERT(strstr(test_001_str, s.c_str()) != nullptr, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_001_str, s.c_str()));
 
 		pke_serialize_teardown(h);
 
@@ -193,16 +188,15 @@ int pke_test_deserialization_101() {
 
 		pke_deserialize_scene_from_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers.next);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[0].arr.next);
 		for (i = 0; i < 3; ++i) {
-			// 6,9,12
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].key != nullptr, err_index);
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].val != nullptr, err_index);
-			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].end != nullptr, err_index);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].key);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].val);
+			PK_TEST_ASSERT_NEQ_RET(nullptr, h->kvp_containers[0].arr[i].end);
 		}
 
 		glm::vec3 pos;
@@ -210,10 +204,22 @@ int pke_test_deserialization_101() {
 		glm::vec3 scale;
 		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);
 
-		// 15
-		PKE_TEST_ASSERT(pos == glm::vec3(0,1,2), err_index);
-		PKE_TEST_ASSERT(rot == glm::quat(6,7,8,9), err_index);
-		PKE_TEST_ASSERT(scale == glm::vec3(5,4,3), err_index);
+		const glm::vec3 Spos(0,1,2);
+		const glm::quat Srot(6,7,8,9);
+		const glm::vec3 Scle(5,4,3);
+
+		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
+		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
+		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);
+
+		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
+		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
+		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
+		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);
+
+		PK_TEST_ASSERT_EQ_RET(Scle[0], scale[0]);
+		PK_TEST_ASSERT_EQ_RET(Scle[1], scale[1]);
+		PK_TEST_ASSERT_EQ_RET(Scle[2], scale[2]);
 
 		pke_deserialize_teardown(h);
 
@@ -251,7 +257,6 @@ IsPrimary:1
 
 :PKFE:)VOGON";
 int pke_test_serialization_002() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	srlztn_serialize_helper *h = nullptr;
 	pke_kve *kve = nullptr;
@@ -281,35 +286,32 @@ int pke_test_serialization_002() {
 		pke_serialize_scene_to_stream(ss, h);
 		std::string s = ss.str();
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
 		// instpos
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 1, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].arr.next);
 		// instance
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 4, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers[1].arr.next);
 		// instpos
-		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[2].arr.next);
 		// camera
-		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 5, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(5, h->kvp_containers[3].arr.next);
 
-		// 12
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 12 + (3 * (1 + 4 + 3 + 5))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
-		// 51
-		PKE_TEST_ASSERT(strstr(test_002_str, s.c_str()) != nullptr, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_002_str, s.c_str()));
 
 		pke_serialize_teardown(h);
 
@@ -320,7 +322,6 @@ int pke_test_serialization_002() {
 }
 
 int pke_test_deserialization_102() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	pke_kve *kve;
 	srlztn_deserialize_helper *h;
@@ -330,26 +331,24 @@ int pke_test_deserialization_102() {
 
 		pke_deserialize_scene_from_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 4, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 3, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 5, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].arr.next);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers[1].arr.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[2].arr.next);
+		PK_TEST_ASSERT_EQ_RET(5, h->kvp_containers[3].arr.next);
 
-		// 12
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 12 + (3 * (1 + 4 + 3 + 5))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key );
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val );
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end );
 			}
 		}
 
@@ -357,28 +356,53 @@ int pke_test_deserialization_102() {
 		glm::quat rot = glm::quat(1,0,0,0);
 		glm::vec3 scale = glm::vec3(1,1,1);
 
+		glm::vec3 Spos = glm::vec3(0,0,0);
+		glm::quat Srot = glm::quat(1,0,0,0);
+		glm::vec3 Sscl = glm::vec3(1,1,1);
+
 		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);
-		// 51
-		PKE_TEST_ASSERT(pos == glm::vec3(0,0,0), err_index);
-		PKE_TEST_ASSERT(rot == glm::quat(1,0,0,0), err_index);
-		PKE_TEST_ASSERT(scale == glm::vec3(1,1,1), err_index);
+
+		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
+		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
+		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);
+
+		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
+		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
+		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
+		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);
+
+		PK_TEST_ASSERT_EQ_RET(Sscl[0], scale[0]);
+		PK_TEST_ASSERT_EQ_RET(Sscl[1], scale[1]);
+		PK_TEST_ASSERT_EQ_RET(Sscl[2], scale[2]);
 
 		pke_deserialize_inst_pos(h, &h->kvp_containers[2], pos, rot, scale);
-		// 54
-		PKE_TEST_ASSERT(pos == glm::vec3(0,-10,-10), err_index);
-		PKE_TEST_ASSERT(rot == glm::quat(1,0,0,0), err_index);
-		PKE_TEST_ASSERT(scale == glm::vec3(5,4,3), err_index);
+
+		Spos = glm::vec3(0,-10,-10);
+		Srot = glm::quat(1,0,0,0);
+		Sscl = glm::vec3(5,4,3);
+
+		PK_TEST_ASSERT_EQ_RET(Spos[0], pos[0]);
+		PK_TEST_ASSERT_EQ_RET(Spos[1], pos[1]);
+		PK_TEST_ASSERT_EQ_RET(Spos[2], pos[2]);
+
+		PK_TEST_ASSERT_EQ_RET(Srot[0], rot[0]);
+		PK_TEST_ASSERT_EQ_RET(Srot[1], rot[1]);
+		PK_TEST_ASSERT_EQ_RET(Srot[2], rot[2]);
+		PK_TEST_ASSERT_EQ_RET(Srot[3], rot[3]);
+
+		PK_TEST_ASSERT_EQ_RET(Sscl[0], scale[0]);
+		PK_TEST_ASSERT_EQ_RET(Sscl[1], scale[1]);
+		PK_TEST_ASSERT_EQ_RET(Sscl[2], scale[2]);
 
 		pke_deserialize_scene(h);
 
 		PkeCamera *des_cam = PkeCamera_Get(CameraHandle{0,0});
-		// 57
-		PKE_TEST_ASSERT(des_cam != nullptr, err_index);
-		PKE_TEST_ASSERT(des_cam->uuid == uuid_n[2], err_index);
-		PKE_TEST_ASSERT(des_cam->type == PKE_CAMERA_TYPE_PERSPECTIVE, err_index);
-		PKE_TEST_ASSERT(des_cam->view == PKE_CAMERA_VIEW_TARGET, err_index);
-		PKE_TEST_ASSERT(des_cam->phys.target_inst_uuid == uuid_n[1], err_index);
-		PKE_TEST_ASSERT(des_cam->isPrimary == true, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, des_cam );
+		PK_TEST_ASSERT_EQ_RET(uuid_n[2], des_cam->uuid);
+		PK_TEST_ASSERT_EQ_RET(static_cast<PkeCameraType_T>(PKE_CAMERA_TYPE_PERSPECTIVE), static_cast<PkeCameraType_T>(des_cam->type));
+		PK_TEST_ASSERT_EQ_RET(static_cast<PkeCameraType_T>(PKE_CAMERA_VIEW_TARGET), static_cast<PkeCameraType_T>(des_cam->view));
+		PK_TEST_ASSERT_EQ_RET(uuid_n[1], des_cam->phys.target_inst_uuid);
+		PK_TEST_ASSERT_EQ_RET(true, des_cam->isPrimary);
 
 		pke_deserialize_teardown(h);
 
@@ -424,7 +448,6 @@ Layer:0x00
 
 :PKFE:)VOGON";
 int pke_test_serialization_003() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	srlztn_serialize_helper *h = nullptr;
 	pke_kve *kve = nullptr;
@@ -441,7 +464,7 @@ int pke_test_serialization_003() {
 		frs.surface_area_pos = glm::ivec2(0, 0);
 		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
 		frs.flags = FONT_RENDER_FLAG_NONE;
-		FontRenderHandle fr_handle = FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, std::move(cstring_to_pk_cstr("asdf")), &frs, nullptr, uuid_n[1]);
+		FontTypeRender fr_handle = FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, std::move(cstring_to_pk_cstr("asdf")), &frs, nullptr, uuid_n[1]);
 
 		pke_ui_box *ui_box = pke_ui_box_new_root(PKE_UI_BOX_TYPE_TEXT, uuid_n[2]);
 		ui_box->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
@@ -449,41 +472,41 @@ int pke_test_serialization_003() {
 		ui_box->pos_top_left.y = 0.1;
 		ui_box->max_size.x = 0.8;
 		ui_box->max_size.y = 0.8;
-		ui_box->type_data->text.font_render_handle = fr_handle;
+		ui_box->type_data->text.font_type_render = fr_handle;
 
 		pke_serialize_scene(h);
 		pke_serialize_scene_to_stream(ss, h);
 		std::string s = ss.str();
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
 		// FontRenderSettings
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 9, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
 		// FontRender
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
 		// ui box type text
-		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 1, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[2].arr.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 6, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(6, h->kvp_containers[3].arr.next);
 
 		// 12
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
 				// 12 + (3 * (8 + 3 + 1 + 6))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
 		// 66
-		PKE_TEST_ASSERT(strstr(test_003_str, s.c_str()) != nullptr, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_003_str, s.c_str()));
 
 		pke_serialize_teardown(h);
 
@@ -494,7 +517,6 @@ int pke_test_serialization_003() {
 }
 
 int pke_test_deserialization_103() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	pke_kve *kve;
 	srlztn_deserialize_helper *h;
@@ -504,30 +526,28 @@ int pke_test_deserialization_103() {
 
 		pke_deserialize_scene_from_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(4, h->kvp_containers.next);
 		// FontRenderSettings
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 9, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
 		// FontRender
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
 		// ui box type text
-		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 1, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[2].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[2].arr.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 6, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[3].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(6, h->kvp_containers[3].arr.next);
 
-		// 12
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 12 + (3 * (8 + 3 + 1 + 6))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
@@ -535,42 +555,46 @@ int pke_test_deserialization_103() {
 
 		uint64_t idx_unused;
 		FontType *fonts = FontType_GetFonts(idx_unused);
-		// 66
-		PKE_TEST_ASSERT(fonts != nullptr, err_index);
-		PKE_TEST_ASSERT(idx_unused != 0xFFFFFFFFFFFFFFFF, err_index);
-		PKE_TEST_ASSERT(fonts->n_render > FontRenderIndex{0}, err_index);
-		FontRender *fr = &fonts[0].renders[0];
-
-		// 69
-		PKE_TEST_ASSERT(fr->settings.char_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.line_height_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.char_spacing_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_size == glm::ivec2(250,250), err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_pos == glm::ivec2(0,0), err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_type_flags == FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, fonts);
+		PK_TEST_ASSERT_NEQ_RET(0xFFFFFFFFFFFFFFFF, idx_unused);
+		// PK_TEST_ASSERT_LTE_RET(0, fonts->renders.head_r.i); // always true, unsigned
+		FontRender *fr = &fonts[0].renders[{0,0}];
+
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_scale);
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.line_height_scale);
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_spacing_scale);
+		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.x);
+		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.y);
+		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.x);
+		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.y);
+		PK_TEST_ASSERT_EQ_RET(static_cast<FONT_RENDER_FLAG_T>(FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH), static_cast<FONT_RENDER_FLAG_T>(fr->settings.surface_area_type_flags));
 		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
 		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
-		PKE_TEST_ASSERT(fr->settings.color_foreground == glm::vec4(0.4, 0.9, 0.5, 0.8), err_index);
-		PKE_TEST_ASSERT(fr->settings.color_background == glm::vec4(0.0, 0.0, 0.0, 0.0), err_index);
-
-		// 77
-		PKE_TEST_ASSERT(fr->uuid == uuid_n[1], err_index);
-		PKE_TEST_ASSERT(fr->text.val != nullptr, err_index);
-		PKE_TEST_ASSERT(fr->text.val[0] == 'a', err_index);
-		PKE_TEST_ASSERT(fr->text.val[1] == 's', err_index);
-		PKE_TEST_ASSERT(fr->text.val[2] == 'd', err_index);
-		PKE_TEST_ASSERT(fr->text.val[3] == 'f', err_index);
-		PKE_TEST_ASSERT(fr->text.val[4] == '\0', err_index);
-
-		// 84
+		PK_TEST_ASSERT_EQ_RET(0.4f, fr->settings.color_foreground.x);
+		PK_TEST_ASSERT_EQ_RET(0.9f, fr->settings.color_foreground.y);
+		PK_TEST_ASSERT_EQ_RET(0.5f, fr->settings.color_foreground.z);
+		PK_TEST_ASSERT_EQ_RET(0.8f, fr->settings.color_foreground.w);
+		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.x);
+		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.y);
+		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.z);
+		PK_TEST_ASSERT_EQ_RET(0.0, fr->settings.color_background.w);
+
+		PK_TEST_ASSERT_EQ_RET(uuid_n[1], fr->uuid);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, fr->text.val);
+		PK_TEST_ASSERT_EQ_RET('a', fr->text.val[0]);
+		PK_TEST_ASSERT_EQ_RET('s', fr->text.val[1]);
+		PK_TEST_ASSERT_EQ_RET('d', fr->text.val[2]);
+		PK_TEST_ASSERT_EQ_RET('f', fr->text.val[3]);
+		PK_TEST_ASSERT_EQ_RET('\0', fr->text.val[4]);
+
 		pke_ui_box_count_T count;
 		pke_ui_box **boxes = pke_ui_get_root_boxes(&count);
 		pke_ui_box *box = boxes[0];
-		PKE_TEST_ASSERT(count == 1, err_index)
-		PKE_TEST_ASSERT(box->internal.h_children == 0, err_index)
-		PKE_TEST_ASSERT(box->type == PKE_UI_BOX_TYPE_TEXT, err_index)
-		PKE_TEST_ASSERT(PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC), err_index)
-		PKE_TEST_ASSERT(PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE), err_index)
+		PK_TEST_ASSERT_EQ_RET(1, count)
+		PK_TEST_ASSERT_EQ_RET(0, box->internal.h_children)
+		PK_TEST_ASSERT_EQ_RET(static_cast<PKE_UI_BOX_TYPE_T>(PKE_UI_BOX_TYPE_TEXT), static_cast<PKE_UI_BOX_TYPE_T>(box->type));
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC));
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE));
 
 		pke_deserialize_teardown(h);
 
@@ -607,7 +631,6 @@ ColorBackground:0.200000;0.300000;0.200000;0.500000
 
 :PKFE:)VOGON";
 int pke_test_serialization_004() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	srlztn_serialize_helper *h = nullptr;
 	pke_kve *kve = nullptr;
@@ -633,29 +656,29 @@ int pke_test_serialization_004() {
 		pke_serialize_scene_to_stream(ss, h);
 		std::string s = ss.str();
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(8, h->kvp_containers[0].arr.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 9, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[1].arr.next);
 
 		// 8
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
 				// 8 + (3 * (9 + 8))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
 		// 59
-		PKE_TEST_ASSERT(strstr(test_004_str, s.c_str()) != nullptr, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_004_str, s.c_str()));
 
 		pke_serialize_teardown(h);
 
@@ -666,7 +689,6 @@ int pke_test_serialization_004() {
 }
 
 int pke_test_deserialization_104() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	srlztn_deserialize_helper *h = nullptr;
 	pke_kve *kve = nullptr;
@@ -676,24 +698,22 @@ int pke_test_deserialization_104() {
 
 		pke_deserialize_scene_from_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(8, h->kvp_containers[0].arr.next);
 		// ui box
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 9, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[1].arr.next);
 
-		// 8
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 8 + (3 * (9 + 8))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
@@ -701,38 +721,51 @@ int pke_test_deserialization_104() {
 
 		pke_ui_box_count_T box_count;
 		pke_ui_box **root_boxes = pke_ui_get_root_boxes(&box_count);
-		// 59
-		PKE_TEST_ASSERT(root_boxes != nullptr, err_index);
-		PKE_TEST_ASSERT(box_count == 1, err_index);
-		PKE_TEST_ASSERT(root_boxes[0] != nullptr, err_index);
-
-		// 62
-		PKE_TEST_ASSERT(root_boxes[0]->uuid == uuid_n[2], err_index);
-		PKE_TEST_ASSERT(PK_HAS_FLAG(root_boxes[0]->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC), err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->pos_top_left == glm::vec2(1.f,1.f), err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->max_size == glm::vec2(1278.f,718.f), err_index);
-		PKE_TEST_ASSERT(PK_HAS_FLAG(root_boxes[0]->type, PKE_UI_BOX_TYPE_STANDARD), err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->layer == 0, err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->internal.parent == nullptr, err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->internal.h_children == 1, err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->internal.children != nullptr, err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->internal.children[0] != nullptr, err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->color_border     == glm::vec4(1.0,0.0,0.0,1.0), err_index);
-		PKE_TEST_ASSERT(root_boxes[0]->color_background == glm::vec4(0.2,0.3,0.2,0.5), err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes);
+		PK_TEST_ASSERT_EQ_RET(1, box_count);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]);
+
+		PK_TEST_ASSERT_EQ_RET(uuid_n[2], root_boxes[0]->uuid);
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(root_boxes[0]->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC));
+		PK_TEST_ASSERT_EQ_RET(1.f, root_boxes[0]->pos_top_left.x);
+		PK_TEST_ASSERT_EQ_RET(1.f, root_boxes[0]->pos_top_left.y);
+		PK_TEST_ASSERT_EQ_RET(1278.f, root_boxes[0]->max_size.x);
+		PK_TEST_ASSERT_EQ_RET(718.f, root_boxes[0]->max_size.y);
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(root_boxes[0]->type, PKE_UI_BOX_TYPE_STANDARD));
+		PK_TEST_ASSERT_EQ_RET(0, root_boxes[0]->layer);
+		PK_TEST_ASSERT_EQ_RET(nullptr, root_boxes[0]->internal.parent);
+		PK_TEST_ASSERT_EQ_RET(1, root_boxes[0]->internal.h_children);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]->internal.children);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, root_boxes[0]->internal.children[0]);
+		PK_TEST_ASSERT_EQ_RET(1.0f, root_boxes[0]->color_border.x);
+		PK_TEST_ASSERT_EQ_RET(0.0f, root_boxes[0]->color_border.y);
+		PK_TEST_ASSERT_EQ_RET(0.0f, root_boxes[0]->color_border.z);
+		PK_TEST_ASSERT_EQ_RET(1.0f, root_boxes[0]->color_border.w);
+		PK_TEST_ASSERT_EQ_RET(0.2f, root_boxes[0]->color_background.x);
+		PK_TEST_ASSERT_EQ_RET(0.3f, root_boxes[0]->color_background.y);
+		PK_TEST_ASSERT_EQ_RET(0.2f, root_boxes[0]->color_background.z);
+		PK_TEST_ASSERT_EQ_RET(0.5f, root_boxes[0]->color_background.w);
 
 		pke_ui_box *box_c = root_boxes[0]->internal.children[0];
-		// 74
-		PKE_TEST_ASSERT(box_c->uuid == uuid_n[1], err_index);
-		PKE_TEST_ASSERT(PK_HAS_FLAG(box_c->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC), err_index);
-		PKE_TEST_ASSERT(box_c->pos_top_left == glm::vec2(0.1,0.1), err_index);
-		PKE_TEST_ASSERT(box_c->max_size == glm::vec2(0.8,0.8), err_index);
-		PKE_TEST_ASSERT(PK_HAS_FLAG(box_c->type, PKE_UI_BOX_TYPE_STANDARD), err_index);
-		PKE_TEST_ASSERT(box_c->layer == 0, err_index);
-		PKE_TEST_ASSERT(box_c->internal.parent == root_boxes[0], err_index);
-		PKE_TEST_ASSERT(box_c->internal.h_children == 0, err_index);
-		PKE_TEST_ASSERT(box_c->internal.children == nullptr, err_index);
-		PKE_TEST_ASSERT(box_c->color_border     == glm::vec4(1.0,0.0,0.0,1.0), err_index);
-		PKE_TEST_ASSERT(box_c->color_background == glm::vec4(0.2,0.3,0.2,0.5), err_index);
+		PK_TEST_ASSERT_EQ_RET(uuid_n[1], box_c->uuid);
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box_c->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC));
+		PK_TEST_ASSERT_EQ_RET(0.1f, box_c->pos_top_left.x);
+		PK_TEST_ASSERT_EQ_RET(0.1f, box_c->pos_top_left.y);
+		PK_TEST_ASSERT_EQ_RET(0.8f, box_c->max_size.x);
+		PK_TEST_ASSERT_EQ_RET(0.8f, box_c->max_size.y);
+		PK_TEST_ASSERT_EQ_RET(true, PK_HAS_FLAG(box_c->type, PKE_UI_BOX_TYPE_STANDARD));
+		PK_TEST_ASSERT_EQ_RET(0, box_c->layer);
+		PK_TEST_ASSERT_EQ_RET(root_boxes[0], box_c->internal.parent);
+		PK_TEST_ASSERT_EQ_RET(0, box_c->internal.h_children);
+		PK_TEST_ASSERT_EQ_RET(nullptr, box_c->internal.children);
+		PK_TEST_ASSERT_EQ_RET(1.0f, box_c->color_border.x);
+		PK_TEST_ASSERT_EQ_RET(0.0f, box_c->color_border.y);
+		PK_TEST_ASSERT_EQ_RET(0.0f, box_c->color_border.z);
+		PK_TEST_ASSERT_EQ_RET(1.0f, box_c->color_border.w);
+		PK_TEST_ASSERT_EQ_RET(0.2f, box_c->color_background.x);
+		PK_TEST_ASSERT_EQ_RET(0.3f, box_c->color_background.y);
+		PK_TEST_ASSERT_EQ_RET(0.2f, box_c->color_background.z);
+		PK_TEST_ASSERT_EQ_RET(0.5f, box_c->color_background.w);
 
 		pke_deserialize_teardown(h);
 
@@ -784,35 +817,32 @@ int pke_test_serialization_005() {
 		frs.surface_area_pos = glm::ivec2(0, 0);
 		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
 		frs.flags = FONT_RENDER_FLAG_NONE;
-		FontRenderHandle fr_handle = FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, cstring_to_pk_cstr(""), &frs, nullptr, uuid_n[1]);
+		FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, cstring_to_pk_cstr(""), &frs, nullptr, uuid_n[1]);
 
 		pke_serialize_scene(h);
 		pke_serialize_scene_to_stream(ss, h);
 		std::string s = ss.str();
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
 		// FontRenderSettings
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
 		// FontRender
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
 
-		// 8
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 8 + (3 * (8 + 3))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
-		// 41
-		PKE_TEST_ASSERT(strstr(test_005_str, s.c_str()) != nullptr, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, strstr(test_005_str, s.c_str()));
 
 		pke_serialize_teardown(h);
 
@@ -823,7 +853,6 @@ int pke_test_serialization_005() {
 }
 
 int pke_test_deserialization_105() {
-	int64_t err_index = 0;
 	uint32_t i, k;
 	pke_kve *kve;
 	srlztn_deserialize_helper *h;
@@ -833,24 +862,22 @@ int pke_test_deserialization_105() {
 
 		pke_deserialize_scene_from_stream(ss, h);
 
-		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->bkt);
+		PK_TEST_ASSERT_EQ_RET(bkt, h->kvp_containers.bkt);
+		PK_TEST_ASSERT_EQ_RET(2, h->kvp_containers.next);
 		// FontRenderSettings
-		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
+		PK_TEST_ASSERT_EQ_RET(0, h->kvp_containers[0].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(9, h->kvp_containers[0].arr.next);
 		// FontRender
-		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
-		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
+		PK_TEST_ASSERT_EQ_RET(1, h->kvp_containers[1].child_handles.next);
+		PK_TEST_ASSERT_EQ_RET(3, h->kvp_containers[1].arr.next);
 
-		// 8
 		for (k = 0; k < h->kvp_containers.next; ++k) {
 			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
-				// 8 + (3 * (8 + 3))
 				kve = &h->kvp_containers[k].arr[i];
-				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
-				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->key);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->val);
+				PK_TEST_ASSERT_NEQ_RET(nullptr, kve->end);
 			}
 		}
 
@@ -858,28 +885,33 @@ int pke_test_deserialization_105() {
 
 		uint64_t idx_unused;
 		FontType *fonts = FontType_GetFonts(idx_unused);
-		// 41
-		PKE_TEST_ASSERT(fonts != nullptr, err_index);
-		PKE_TEST_ASSERT(idx_unused != 0xFFFFFFFFFFFFFFFF, err_index);
-		PKE_TEST_ASSERT(fonts->n_render > FontRenderIndex{0}, err_index);
-		FontRender *fr = &fonts[0].renders[0];
-
-		// 44
-		PKE_TEST_ASSERT(fr->settings.char_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.line_height_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.char_spacing_scale == 1.f, err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_size == glm::ivec2(250,250), err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_pos == glm::ivec2(0,0), err_index);
-		PKE_TEST_ASSERT(fr->settings.surface_area_type_flags == FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH, err_index);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, fonts);
+		PK_TEST_ASSERT_NEQ_RET(0xFFFFFFFFFFFFFFFF, idx_unused);
+		// PK_TEST_ASSERT_LTE_RET(fonts->renders.head_r.i > 0u, err_index); // always true, unsigned
+		FontRender *fr = &fonts[0].renders[{0,0}];
+
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_scale);
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.line_height_scale);
+		PK_TEST_ASSERT_EQ_RET(1.f, fr->settings.char_spacing_scale);
+		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.x);
+		PK_TEST_ASSERT_EQ_RET(250, fr->settings.surface_area_size.y);
+		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.x);
+		PK_TEST_ASSERT_EQ_RET(0, fr->settings.surface_area_pos.y);
+		PK_TEST_ASSERT_EQ_RET(static_cast<FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T>(FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH), static_cast<FONT_RENDER_SURFACE_AREA_TYPE_FLAG_T>(fr->settings.surface_area_type_flags));
 		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
 		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
-		PKE_TEST_ASSERT(fr->settings.color_foreground == glm::vec4(0.4, 0.9, 0.5, 0.8), err_index);
-		PKE_TEST_ASSERT(fr->settings.color_background == glm::vec4(0.0, 0.0, 0.0, 0.0), err_index);
-
-		// 52
-		PKE_TEST_ASSERT(fr->uuid == uuid_n[1], err_index);
-		PKE_TEST_ASSERT(fr->text.val != nullptr, err_index);
-		PKE_TEST_ASSERT(fr->text.val[0] == '\0', err_index);
+		PK_TEST_ASSERT_EQ_RET(0.4f, fr->settings.color_foreground.x);
+		PK_TEST_ASSERT_EQ_RET(0.9f, fr->settings.color_foreground.y);
+		PK_TEST_ASSERT_EQ_RET(0.5f, fr->settings.color_foreground.z);
+		PK_TEST_ASSERT_EQ_RET(0.8f, fr->settings.color_foreground.w);
+		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.x);
+		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.y);
+		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.z);
+		PK_TEST_ASSERT_EQ_RET(0.0f, fr->settings.color_background.w);
+
+		PK_TEST_ASSERT_EQ_RET(uuid_n[1], fr->uuid);
+		PK_TEST_ASSERT_NEQ_RET(nullptr, fr->text.val);
+		PK_TEST_ASSERT_EQ_RET('\0', fr->text.val[0]);
 
 		pke_deserialize_teardown(h);