write function for bulk removal of chunks

2025-12-18 11:35:46 +01:00 · 2025-08-27 12:30:38 +02:00
57 changed files with 1261 additions and 1177 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,7 +1,3 @@
-# Copyright (c) 2025 Quinn.
-# This is a file from the project MCA-Selector-Lite and is
-# licensed under the MIT Licence. See included LICENSE file for details.
-#
 ---
 # ---------------------------
 # general style settings
@@ -25,9 +21,9 @@ AlignTrailingComments:        true
 AlignConsecutiveMacros:       AcrossEmptyLines
 AlignEscapedNewlines:         Left
 AlignArrayOfStructures:       Left
-AlignConsecutiveAssignments:  Consecutive
+AlignConsecutiveAssignments:  None
 AlignConsecutiveBitFields:    AcrossEmptyLines
-AlignConsecutiveDeclarations: Consecutive
+AlignConsecutiveDeclarations: None
 AlignConsecutiveShortCaseStatements:
  Enabled: true

@@ -35,9 +31,9 @@ AlignConsecutiveShortCaseStatements:
 # short constructs on a single line
 # ---------------------------
 AllowShortBlocksOnASingleLine:       Always
-AllowShortFunctionsOnASingleLine:    None
+AllowShortFunctionsOnASingleLine:    All
 AllowShortLambdasOnASingleLine:      All
-AllowShortIfStatementsOnASingleLine: Never
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
 AllowShortCaseLabelsOnASingleLine:   true
 AllowShortEnumsOnASingleLine:        true
 AllowShortLoopsOnASingleLine:        true
@@ -62,7 +58,7 @@ BraceWrapping:
  AfterCaseLabel:        false
  AfterClass:            false
  AfterEnum:             false
-  AfterFunction:         true
+  AfterFunction:         false
  AfterNamespace:        false
  AfterObjCDeclaration:  false
  AfterStruct:           false
@@ -100,6 +96,10 @@ IncludeIsMainSourceRegex: ''
 IncludeIsMainRegex:       '([-_](test|unittest))?$'
 IncludeBlocks:      Regroup
 IncludeCategories:
+  - Regex:         '^<glad/gl\.h>'
+    Priority:      1
+    SortPriority:  0
+    CaseSensitive: true
  - Regex:         '^<.*\.h>'
    Priority:      2
    SortPriority:  0
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,6 +1,5 @@
-# Copyright (c) 2025 Quinn.
-# This is a file from the project MCA-Selector-Lite and is
-# licensed under the MIT Licence. See included LICENSE file for details.
+# Copyright (c) 2025 Quinn
+# Licensed under the MIT Licence. See LICENSE for details

 [*]
 charset = utf-8
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1,57 +0,0 @@
-name: CI
-on:
-  push:
-    branches: [main]
-
-jobs:
-  compile-and-test:
-    strategy:
-      fail-fast: false # disable fail fast, so feedback is provided for all matrix combinations
-      matrix:
-        include:
-          - os: ubuntu-latest
-            cc: cc
-          - os: ubuntu-24.04-arm
-            cc: cc
-          - os: windows-latest
-            cc: gcc
-          - os: windows-11-arm
-            cc: gcc
-          # - os: macos-latest
-          #   cc: cc
-    env:
-        CC: ${{matrix.cc}}
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          submodules: true
-          fetch-depth: 1
-
-      - name: "Linux: install deps"
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt update
-          sudo apt install -y libwayland-dev libxkbcommon-dev xorg-dev cmake xxd
-
-      - name: get submodule hash
-        id: get-hash
-        run: echo "HASH=$(git submodule | sha1sum | cut -d' ' -f1)" >$GITHUB_OUTPUT
-        shell: bash
-
-      - uses: actions/cache@v4
-        id: cache-deps
-        with:
-          path: lib/obj/
-          # I swear to god, if runner.arch displays x64 for x86_64, I will eat a potato.
-          # note: it is... fucking shit.
-          key: ${{runner.os}}_${{runner.arch}}-lib/obj-${{steps.get-hash.outputs.HASH}}
-          restore-keys: ${{runner.os}}_${{runner.arch}}-lib/obj-
-
-      - run: make -Bj libs
-        if: steps.cache-deps.outputs.cache-hit != 'true' && runner.os != 'Windows'
-      - run: make -Bj2 libs # compile fewer cores, to save memory.
-        if: steps.cache-deps.outputs.cache-hit != 'true' && runner.os == 'Windows'
-
-      - run: make -j all
-      - run: make -j check
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,5 @@
-# Copyright (c) 2025 Quinn.
-# This is a file from the project MCA-Selector-Lite and is
-# licensed under the MIT Licence. See included LICENSE file for details.
+# Copyright (c) 2025 Quinn
+# Licensed under the MIT Licence. See LICENSE for details

 # ignore all dotfiles by default
 .*
@@ -19,6 +18,4 @@
 *.lock
 /bin/
 /obj/
-/lib/obj/
 compile_commands.json
-compile_commands.events.json
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,11 +0,0 @@
-# Copyright (c) 2025 Quinn.
-# This is a file from the project MCA-Selector-Lite and is
-# licensed under the MIT Licence. See included LICENSE file for details.
-
-[submodule "lib/glfw"]
-	path = lib/glfw
-	url = https://github.com/glfw/glfw
-
-[submodule "lib/libarchive"]
-	path = lib/libarchive
-	url = https://github.com/libarchive/libarchive
--- a/105
+++ b/105
@@ -1,105 +0,0 @@
-# Copyright (c) 2025 Quinn.
-# This is a file from the project MCA-Selector-Lite and is
-# licensed under the MIT Licence. See included LICENSE file for details.
-
-SHELL = /bin/sh
-.SUFFIXES:
-
-NAME    = mcaselector-lite
-
-CC     ?= cc
-RM     ?= rm -vf
-CMAKE  ?= cmake -G 'Unix Makefiles'
-
-CPPFLAGS ?= -DNDEBUG
-CFLAGS   ?= -O2
-LDFLAGS  ?= -flto
-
-CPPFLAGS += -DGLFW_INCLUDE_NONE
-CPPFLAGS += -Iinclude -Ilib/glad/include -Ilib/glfw/include -Ilib/libarchive/libarchive
-LDFLAGS  += -Llib/obj/glfw/src -Llib/obj/libarchive/libarchive
-LDLIBS   += -lglfw3 -larchive -lm
-CFLAGS   += -std=gnu99 -g -MMD -MP
-CFLAGS   += -Wall -Wextra -Wpedantic -Wno-pointer-arith
-
-# detect if we're compiling on Windows, meaning
-# a lot of things considered "standard" are unavailable.
-ifeq ($(OS),Windows_NT)
-NAME   := $(NAME).exe
-LDLIBS += -lopengl32 -lgdi32
-$(warning Detected  Windows_NT, please refer to the documentation if you encounter issues.)
-# in the case of Mac OS X
-else ifeq ($(shell uname -s),Darwin)
-LDLIBS += -framework Coca -framework OpenGL -framework IOKit
-$(info Mac OS X detected.)
-endif
-
-# find all the source files using wildcards
-# TODO: find a better method to find all source files
-# NOTE: MS-DOS and MS-Windows uses backslash `\`, this might break.
-RES  := $(wildcard res/*)
-SRC  := $(wildcard src/*.c src/*/*.c src/*/*/*.c src/*/*/*/*.c src/*/*/*/*/*.c src/*/*/*/*/*/*.c src/*/*/*/*/*/*/*.c src/*/*/*/*/*/*/*/*.c)
-SRC  += lib/glad/src/gl.c
-TSRC := $(wildcard test/*.c test/*/*.c test/*/*/*.c test/*/*/*/*.c test/*/*/*/*/*.c test/*/*/*/*/*/*.c test/*/*/*/*/*/*/*.c test/*/*/*/*/*/*/*/*.c)
-
-OBJ   := $(RES:%=obj/%.o) $(SRC:%.c=obj/%.o)
-TOBJ  := $(TSRC:%.c=obj/%.o)
-
-# TODO: potentially automatically detect whether we should compile libs, or if we can just go ahead.
-
-.PHONY: all libs check clean clean-libs
-all: bin/$(NAME)
-libs: lib/obj/glfw/ lib/obj/libarchive/
-check: bin/TEST_$(NAME); ./$<
-clean:;      @-$(RM) -r bin/ obj/
-clean-libs:; @-$(RM) -r lib/obj/
-
-.PHONY:
-install: all
-ifneq ($(OS),Windows_NT)
-	# TODO: POSIX-compliant installation
-else
-	# TODO: WINDOWS_NT installation
-endif
-
-.PHONY:
-install-strip: install
-	# TODO: strip the produced installation
-
-# compiles the libraries using cmake
-lib/obj/%/: lib/%/
-	$(CMAKE) -S $< -B $@
-	$(MAKE) -C $@
-
-# link together a runtime binary
-bin/$(NAME): $(OBJ)
-	$(info [LD]	$@)
-	@mkdir -p $(@D)
-	@$(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-# link together a testing binary
-bin/TEST_$(NAME): $(TOBJ) $(filter-out obj/src/main.o,$(OBJ))
-	$(info [LD]	$@)
-	@mkdir -p $(@D)
-	@$(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-obj/res/%.c: res/%
-	$(info [XXD]	$@)
-	@mkdir -p $(@D)
-	@cd res/ && xxd -i $(patsubst res/%,%,$<) $(abspath $@)
-
-obj/%.o: %.c
-	$(info [CC]	$@)
-	@mkdir -p $(@D)
-	@$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
-
-obj/%.o: obj/%.c
-	$(info [CC]	$@)
-	@mkdir -p $(@D)
-	@$(CC) -c $(CPPFLAGS) $(CFLAGS) -o $@ $<
-
-# Include the generated dependency files.
-# Which creates rules for all dependencies,
-# as a result updating an .o file when a .h is updated.
-include $(OBJ:%.o=%.d)
-include $(TOBJ:%.o=%.d)
--- a/docs/README.md
+++ b/docs/README.md
@@ -7,8 +7,6 @@ A from-scratch rewrite of [mcaselector](https://github.com/Querz/mcaselector) in
 [![licence](https://img.shields.io/github/license/thepigeongenerator/mcaselector-lite.svg)](https://github.com/thepigeongenerator/mcaselector-lite/blob/main/LICENSE)
 [![issues](https://img.shields.io/github/issues/thepigeongenerator/mcaselector-lite.svg)](https://github.com/thepigeongenerator/mcaselector-lite/issues/)

-[![CI-status](https://github.com/thepigeongenerator/mcaselector-lite/actions/workflows/ci.yaml/badge.svg)](https://github.com/thepigeongenerator/mcaselector-lite/actions/workflows/ci.yaml)
-
 ## what does it do
 MCA selector lite is a tool used to edit [region files](https://minecraft.wiki/w/Region_file_format) of your [Minecraft java](https://minecraft.wiki/w/Java_Edition) worlds.
 This is useful for reducing world size, general world management, perhaps copying chunks from one world to another or various other administrative tasks.
--- a/docs/dev/styleref.md
+++ b/docs/dev/styleref.md
@@ -21,7 +21,7 @@ Where we have dependencies on:
 | [openGL](https://www.opengl.org/) | hardware accelleration, for handling graphics.          |

 It is intended to be platform-agnostic, within reason. But the main focus is for [Linux](https://wikipedia.org/wiki/Linux) systems with [x86_64](https://wikipedia.org/wiki/X86-64) architecture.
-Within [types.h](/src/types.h) there live definitions for fixed-width integer types.
+Within [intdef.h](/src/util/intdef.h) there live definitions for fixed-width integer types.

 ### style guide
 - Code must be written correctly, read [Correct C](./correct-c.md) if more information is required.
--- a/lib/glfw
+++ b/lib/glfw
--- a/lib/libarchive
+++ b/lib/libarchive
--- a/107
+++ b/107
@@ -0,0 +1,107 @@
+# Copyright (c) 2025 Quinn
+# Licensed under the MIT Licence. See LICENSE for details
+SHELL = bash
+.SHELLFLAGS = -O globstar -c
+
+# build configuration, information about the current build process
+NAME    = mcaselector-lite
+VERSION = 0.0.0
+DEBUG   ?= 0
+CC      ?= cc
+LD      ?= ld
+CFLAGS  += -c -std=gnu99 -Wall -MMD -MP
+CFLAGS  += -Ilib/glad/include
+LDFLAGS += -flto -lm
+MARCH   ?= $(shell uname -m)
+KERNEL  ?= $(shell uname -s | tr '[:upper:]' '[:lower:]')
+
+# compilation flags
+CFLAGS  = -c -std=gnu99 -Wall -Wextra -Wpedantic -MMD -MP
+LDFLAGS = -flto
+
+# architecture/OS detection
+ifeq ($(KERNEL),)
+ISWIN := $(if $(filter $(OS),Windows_NT),1,0)
+ifeq ($(ISWIN),1)
+KERNEL = mingw
+MARCH  = x86_64
+else
+MARCH  := $(shell uname -m)
+KERNEL := $(shell uname -s | tr '[:upper:]' '[:lower:]')
+endif
+else
+ISWIN := $(if $(filter $(KERNEL),mingw),1,0)
+endif
+ifeq ($(MARCH),)
+$(error must also set MARCH when manually setting KERNEL)
+endif
+
+# profiles
+ifeq ($(DEBUG),1)
+PROF = dbg
+CFLAGS  += -UNDEBUG -Og -g -Wextra -Wpedantic
+CFLAGS  += $(if $(filter 1,$(ISWIN)),,-fsanitize=address,undefined)
+LDFLAGS += $(if $(filter 1,$(ISWIN)),,-fsanitize=address,undefined)
+# |--profile: testing
+else ifeq ($(DEBUG),test)
+PROF = test
+CFLAGS  += -UNDEBUG -O2 -g
+CFLAGS  += $(if $(filter 1,$(ISWIN)),,-fsanitize=address)
+LDFLAGS += $(if $(filter 1,$(ISWIN)),,-fsanitize=address)
+else
+PROF = rel
+CFLAGS += -DNDEBUG -O2
+endif
+
+CFLAGS  += $(shell pkg-config --cflags glfw3 libarchive) -Ilib/glad/include
+LDFLAGS += $(shell pkg-config --libs glfw3 libarchive) -lm
+
+# get source files
+SRC := $(shell echo src/**/*.c) lib/glad/src/gl.c
+RES := $(wildcard res/*.glsl)
+ifeq ($(DEBUG),test)
+SRC := $(filter-out src/main.c, $(SRC)) $(shell echo test/**/*.c)
+endif
+
+NAME += $(if $(filter 1,$(ISWIN)),.exe,)
+DIR_BIN := bin/$(MARCH)-$(KERNEL)/$(VERSION)/$(PROF)
+DIR_OBJ := obj/$(MARCH)-$(KERNEL)/$(VERSION)/$(PROF)
+
+# output files
+BIN := $(DIR_BIN)/$(NAME)
+OBJ := $(SRC:%.c=$(DIR_OBJ)/%.o) $(RES:%=$(DIR_OBJ)/%.o)
+DEP := $(OBJ:%.o=%.d)
+
+.PHONY:
+run: compile
+	$(if $(filter 1,$(ISWIN)),wine,) $(BIN)
+
+.PHONY:
+compile: $(BIN)
+
+.PHONY .NOTPARALLEL:
+clean:
+	@rm -rv obj/
+	@rm -rv bin/
+
+$(BIN): $(OBJ)
+	$(info [CC/LD] $@)
+	@mkdir -p $(@D)
+	@$(CC) -o $@ $^ $(LDFLAGS)
+
+$(DIR_OBJ)/%.o: %.c
+	$(info [CC] $@)
+	@mkdir -p $(@D)
+	@$(CC) $(CFLAGS) -o $@ $<
+
+$(DIR_OBJ)/res/%.o: res/%
+	$(info [LD] $@)
+	@mkdir -p $(@D)
+	@$(LD) -r -b binary -o $@ $<
+
+# some definitions for "default" and assumed compilers, for bulk selection
+.PHONY: x86_64-linux-gnu-gcc x86_64-w64-mingw32-gcc
+x86_64-linux-gnu-gcc:;   $(MAKE) $(CALL) $(MAKEFLAGS) CC=$@ MARCH=x86_64 KERNEL=linux
+x86_64-w64-mingw32-gcc:; $(MAKE) $(CALL) $(MAKEFLAGS) CC=$@ MARCH=x86_64 KERNEL=mingw
+
+-include $(DEP)
--- a/src/dat/mcx.c
+++ b/src/dat/mcx.c
@@ -1,187 +1,83 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
 #include "mcx.h"

-#include <archive.h>
-#include <assert.h>
 #include <endian.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>

-#include "../types.h"
-#include "../util/error.h"
+#include "../util/compat/endian.h"
+#include "../util/intdef.h"

-#define SECTOR 0x1000 // sector size
-#define TABLE  0x800  // table (total) element count
-#define CHUNKS 0x400  // amount of chunks in a file
-
-enum mcx_compression {
-	MCX_COMPRESSION_GZIP   = 0x01,
-	MCX_COMPRESSION_ZLIB   = 0x02,
-	MCX_COMPRESSION_NONE   = 0x03,
-	MCX_COMPRESSION_LZ4    = 0x04,
-	MCX_COMPRESSION_CUSTOM = 0x7F,
-};
-
-/* first 4 bytes is an i32 indicating remaining bytes, the following byte defines the compression scheme */
-static int mcx_loadchunk(const u8 *restrict buf, const i32 *restrict table, int idx)
-{
-	const u8 *chunk = buf + (be32toh(table[idx]) >> 8) * SECTOR;
-
-	i32 len;
-	memcpy(&len, chunk, 4);
-	len = be32toh(len);
-	chunk += 4;
-
-	struct archive *archive = archive_read_new();
-	archive_read_support_format_raw(archive);
-	switch (*chunk) {
-	case MCX_COMPRESSION_GZIP: /* fall-through; ZLIB is handled under the GZIP filter */
-	case MCX_COMPRESSION_ZLIB:   archive_read_support_filter_gzip(archive); break;
-	case MCX_COMPRESSION_NONE:   archive_read_support_filter_none(archive); break;
-	case MCX_COMPRESSION_LZ4:    archive_read_support_filter_lz4(archive); break;
-	case MCX_COMPRESSION_CUSTOM: archive_read_support_filter_all(archive); break;
-	default:                     fatal("compression type of '%i' is unsupported!", *chunk);
-	}
-
-	if (archive_read_open_memory(archive, chunk, len) != ARCHIVE_OK) {
-		error("failed to decompress %i bytes of compression type %i", len, *chunk);
-		return 1;
-	}
-
-	struct archive_entry *entry;
-	if (archive_read_next_header(archive, &entry) != ARCHIVE_OK) {
-		error("failed to decompress %i bytes of compression type %i", len, *chunk);
-		return 1;
-	}
-
-	ssize size = -1;
-	for (;;) {
-		// TODO: handle buffer
-		// size = archive_read_data(archive, , );
-		if (size < 0) {
-			error("failed to decompress %i bytes of compression type %i", len, *chunk);
-			return 1;
-		}
-		if (size == 0)
-			break;
-		// TODO: handle data
-	}
-
-	return 0;
-}
-
-/* Moves chunks `src_s` to `src_e` (inclusive) from `src`, back onto `dst`. */
-static void mvchunks(u8 *dst, u8 *src, u32 *restrict table, int src_s, int src_e)
-{
-	assert(src > dst);
-	uintptr len = src - dst; // acquire the amount of bytes that we shall move
-	assert(!(len % SECTOR));
-
-	// count how many bytes we need to move, whilst updating location data
-	usize blen = 0;
-	for (src_s++; src_s <= src_e; src_s++) {
-		blen += (be32toh(table[src_s]) & 0xFF) * SECTOR;
-		table[src_s] -= htobe32((len / SECTOR) << 8);
-	}
-	memmove(dst, src, blen);
-}
-
-/* Deletes chunk `sidx` by moving chunks up to `eidx` back over `sidx` in `buf`.
+/* Deletes chunk `sidx`, by moving chunks up to `eidx` back over `sidx` in `buf`.
 * `rmb` is an optional additional offset that can be applied, and signifies bytes already removed.
 * Returns the bytes removed by this function. */
-static usize delchunk(u8 *restrict buf, u32 *restrict table, usize rmb, int sidx, int eidx)
-{
-	// load the table data
-	usize slen, bidx, blen;
-	slen = be32toh(table[sidx]) & 0xFF;          // acquire the sector length of the chunk
-	bidx = (be32toh(table[sidx]) >> 8) * SECTOR; // acquire and compute the byte offset the chunk starts at
-	blen = slen * SECTOR;                        // compute the byte length of the chunk
+static size_t delchunk(u8 *restrict buf, size_t rmb, int sidx, int eidx) {
+	// load the table data, and clear it
+	u32 *table = (u32 *)buf;
+	size_t slen, bidx, blen;
+	slen = be32toh(table[sidx] & 0xFF);        // acquire the sector length of the chunk
+	bidx = be32toh(table[sidx] >> 8) * 0x1000; // acquire and compute the byte offset the chunk starts at
+	blen = slen * 0x1000;                      // compute the byte length of the chunk
+	table[sidx] = 0;
+	table[sidx + 0x400] = time(NULL); // assign the current time to the timestamp, for correctness  NOTE: might need to zero-out instead

-	// reset the table data
-	table[sidx]          = 0;
-	table[sidx + CHUNKS] = htobe32(time(NULL)); // assign the current time to the timestamp, for correctness  NOTE: might need to zero-out instead
-
-	// move the succeeding chunks over the deleted chunk
 	u8 *dst = buf + bidx - rmb;
 	u8 *src = buf + bidx + blen;
-	mvchunks(dst, src, table, sidx, eidx - 1);
-	return blen;
-}
-
-/* Call `delchunk` with the parameters and some defaults. Ensuring the table is copied correctly as well.
- * This is done instead of `delchunk` being globally linked, because
- * `delchunk` requests more specific parameters, which is confusing outside this module. */
-usize mcx_delchunk(u8 *restrict buf, int chunk)
-{
-	u32 table[TABLE];
-	memcpy(table, buf, sizeof(table));
-	usize res = delchunk(buf, table, 0, chunk, CHUNKS);
-	memcpy(buf, table, sizeof(table));
-	return res;
-}
-
-usize mcx_delchunk_range(u8 *restrict buf, int start, int end)
-{
-	assert(start < end && end < CHUNKS);
-	u32 table[TABLE];
-	memcpy(table, buf, sizeof(table));
-	u8 *dst = buf + (be32toh(table[start]) >> 8) * SECTOR;
-	u8 *src = buf + (be32toh(table[end]) >> 8) * SECTOR;
-	src += (be32toh(table[end]) & 0xFF) * SECTOR;
-
-	// zeroes-out the chunk data within this range. (and set the timestamp)
-	u32 ts = htobe32(time(NULL));
-	for (int i = start; i <= end; i++) {
-		table[i]          = 0;
-		table[i + CHUNKS] = ts;
+	rmb = blen;
+	blen = 0;
+	for (sidx++; sidx < eidx; sidx++) {
+		blen += be32toh(table[sidx] & 0xFF) * 0x1000;
+		table[sidx] -= htobe32(slen << 8);
 	}
+	memmove(dst, src, blen);
+	return rmb;
+}

-	// move the remaining chunks down
-	if (end < (CHUNKS - 1))
-		mvchunks(dst, src, table, end, (CHUNKS - 1));
-	memcpy(buf, table, sizeof(table));
-	return src - dst;
+size_t mcx_delchunk(u8 *restrict buf, int chunk) {
+	return delchunk(buf, 0, chunk, 0x400);
 }

 /* comparer function for to be inputted into `qsort` to compare two */
-static int cmp_chunkids(const void *restrict x, const void *restrict y)
-{
+static int cmp_chunkids(const void *restrict x, const void *restrict y) {
 	u16 x2 = *(u16 *)x;
 	u16 y2 = *(u16 *)y;
 	return (x2 > y2) - (x2 < y2);
 }

-/* Sorts the chunks marked for deletion from smallest to greatest index.
- * Then performs the deletion in this order. Making sure to only update the chunks up to the next. */
-usize mcx_delchunk_bulk(u8 *restrict buf, const u16 *restrict chunks, int chunkc)
-{
+void mcx_delchunks(u8 *restrict buf, const u16 *restrict chunks, int chunkc) {
 	// ensure the chunks ids we're working on are sorted from least to greatest
 	u16 chunkids[chunkc + 1];
 	memcpy(chunkids, chunks, chunkc);
 	qsort(chunkids, chunkc, sizeof(int), cmp_chunkids);
-	chunkids[chunkc] = CHUNKS; // set the spare chunk to the max chunks, so the rest of the chunks are moved
+	chunkids[chunkc] = 0; // set the spare chunk to zero, to prevent out-of-bounds access

-	u32 table[TABLE];
-	memcpy(table, buf, sizeof(table));
-
-	usize rmb = 0;
+	size_t rmb = 0;
 	for (int i = 0; i < chunkc; i++)
-		rmb += delchunk(buf, table, rmb, chunkids[i], chunkids[i + 1]);
-
-	memcpy(buf, table, sizeof(table));
-	return rmb;
+		rmb += delchunk(buf, rmb, chunkids[i], chunkids[i + 1]);
 }

 /* Sum together the 4th byte in each location integer to compute the sector size of all chunks.
- * Multiplying by `SECTOR`, and adding the size of the table itself. */
-usize mcx_calcsize(const u8 *restrict buf)
-{
-	usize size = 0;
-	for (uint i = 0; i < CHUNKS; i++)
+ * Multiplying by `0x1000`, and adding the size of the table itself. */
+size_t mcx_calcsize(const u8 *restrict buf) {
+	size_t size = 0;
+	for (uint i = 0; i < 0x400; i++)
 		size += *(buf + (i * 4) + 3);
-	return (size * SECTOR) + (TABLE * 4);
+	return (size * 0x1000) + 0x2000;
+}
+
+/* an `*.mcX` contains a `0x2000` byte long table, the first `0x1000` containing
+ * `0x400` entries of chunk data.
+ * This chunk data is big-endian, where bytes `0xFFFFFF00` represent the `0x1000` sector offset.
+ * From the start, and bytes `0x000000FF` represent the length in `0x1000` sectors. */
+void mcx_index(const u8 *restrict buf, struct mcx_chunk *restrict chunks) {
+	const u32 *ptr = (u32 *)buf;
+	for (uint i = 0; i < 0x400; i++) {
+		u32 dat = be32toh(ptr[i]);
+		chunks[i] = (struct mcx_chunk){
+			.idx = (dat >> 8) * 0x1000,
+			.len = (dat & 0xFF) * 0x1000,
+			.time = be32toh(ptr[i + 0x400]),
+		};
+	}
 }
--- a/src/dat/mcx.h
+++ b/src/dat/mcx.h
@@ -1,38 +1,44 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #include <stdlib.h>

-#include "../types.h"
 #include "../util/atrb.h"
+#include "../util/intdef.h"

 /* contains chunk metadata */
 struct mcx_chunk {
-	usize idx;  // byte offset for start of chunk data
-	u32   len;  // byte length of chunk (+ padding)
-	u32   time; // modification time in epoch seconds
+	size_t idx; // byte offset for start of chunk data
+	u32 len;    // byte length of chunk (+ padding)
+	u32 time;   // modification time in epoch seconds
 };

-/* Deletes a single chunk (`chunk`) out of `buf`.
- * The chunk's location data shall become `0`, and timestamp data the current time.
- * All succeeding chunks shall be moved back, freeing space.
- * Returns the amount of bytes removed. */
-usize mcx_delchunk(u8 *restrict buf, int chunk) NONNULL((1));
+/* Deletes chunk `idx` from `buf`, moving all chunks downwards in the process. */
+size_t mcx_delchunk(u8 *restrict buf, int idx);

-/* Deletes the range defined by `start`—`end` (inclusive) of chunks out of `buf`.
- * The chunk's location data shall become `0`, and timestamp data the current time.
- * All succeeding chunks shall be moved back, freeing space.
- * Returns the amount of bytes removed */
-usize mcx_delchunk_range(u8 *restrict buf, int start, int end) NONNULL((1));
-
-/* Deletes a `chunkc` chunks from `chunks` out of `buf`.
- * If the `chunks` indices are known to be sequential, i.e. have a constant difference of `1`, `mcx_delchunk_range` should be preferred.
- * The chunk's location data shall become `0`, and timestamp data the current time.
- * All succeeding chunks shall be moved back, freeing space.
- * Returns the amount of bytes removed */
-usize mcx_delchunk_bulk(u8 *restrict buf, const u16 *restrict chunks, int chunkc) NONNULL((1, 2));
+/* Deletes `chunkc` chunks specified in `chunks` from the `*.mcX` file.
+ * This is done in a way to perform minimal memmove operations. */
+void mcx_delchunks(u8 *restrict buf, const u16 *restrict chunks, int chunkc);

 /* Computes the byte size of the `*.mcX` file in `buf` and returns it. */
-usize mcx_calcsize(const u8 *restrict buf) NONNULL((1)) PURE;
+size_t mcx_calcsize(const u8 *restrict buf) NONNULL((1)) PURE;
+
+/* indexes the chunks in an `*.mcX` file, writing `0x400` of entries to `chunks` */
+void mcx_index(const u8 *restrict buf, struct mcx_chunk *restrict chunks) NONNULL((1, 2));
+
+/* the MCR (Minecraft region) and MCA (Minecraft anvil) files are similar
+ * MCA is the newer variant, where it includes:
+ *  - a world height of 256, rather than 128.
+ *  - block IDs have been extended to 4096 from 256
+ *  - block ordering is now YZX, rather than XZY.
+ *  - biomes are included in the data per XZ column.
+ * MCR start with an 8KiB header, split in two 4KiB tables
+ * - the first containing the offsets of chunks in the region file itself.
+ * - the second providing timestamps on when they were last updated.
+ * -
+ *
+ *
+ *
+ *
+ */
--- a/src/dat/nbt.c
+++ b/src/dat/nbt.c
@@ -1,69 +1,39 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #include "nbt.h"

 #include <assert.h>
-#include <endian.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>

-#include "../types.h"
+#include "../util/compat/endian.h"
+#include "../util/intdef.h"

 #define MAX_DEPTH 512

-/* Extracts a big endian 16 bit integer from address `buf`, converts it to host byte size if needed and returns. */
-static inline u16 buftoh16(const void *restrict buf)
-{
-	u16 i;
-	memcpy(&i, buf, sizeof(i));
-	return be16toh(i);
-}
-
-/* Extracts a big endian 32 bit integer from address `buf`, converts it to host byte size if needed and returns. */
-static inline u32 buftoh32(const void *restrict buf)
-{
-	u32 i;
-	memcpy(&i, buf, sizeof(i));
-	return be32toh(i);
-}
-
-/* Extracts a big endian 64 bit integer from address `buf`, converts it to host byte size if needed and returns. */
-static inline u64 buftoh64(const void *restrict buf)
-{
-	u64 i;
-	memcpy(&i, buf, sizeof(i));
-	return be64toh(i);
-}
-
 /* Processes the incoming array data in `buf`. Which contains `nmem` items of `size`.
 * The data shall be converted to little-endian on little-endian systems
 * Outputs the allocated data to `out`, returns where the next pointer would be. */
-static const u8 *procarr(const u8 *restrict buf, i32 nmemb, uint size, struct nbt_array *restrict out)
-{
-	usize len = nmemb * size;
-	*out      = (struct nbt_array){
-                out->nmemb = nmemb,
-                out->dat   = malloc(len),
-        };
-	if (!out->dat)
-		return buf + len;
+static const u8 *procarr(const u8 *restrict buf, i32 nmem, uint size, struct nbt_array *restrict *restrict out) {
+	size_t len = nmem * size;
+	*out = malloc(sizeof(struct nbt_array) + len);
+	if (!*out) return buf + len;

-	memcpy(out->dat, buf, len);
+	memcpy((*out)->dat, buf, len);
+	(*out)->len = nmem;
 	buf += len;

 	/* Only include this code for little-endian systems. Since only they require this logic.
 	 * Producing optimised code for other platforms. */
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-	if (size == 1)
-		return buf;
-	i32 i = 0;
-	while (i < nmemb) {
+	if (size == 1) return buf;
+	size_t i = 0;
+	while (i < len) {
 		switch (size) {
-		case 2:  ((u16 *)out->dat)[i] = be16toh(((u16 *)out->dat)[i]); break;
-		case 4:  ((u32 *)out->dat)[i] = be16toh(((u32 *)out->dat)[i]); break;
-		case 8:  ((u64 *)out->dat)[i] = be16toh(((u64 *)out->dat)[i]); break;
+		case 2:  *(u16 *)((*out)->dat + i) = be16toh(*(u16 *)((*out)->dat + i)); break;
+		case 4:  *(u32 *)((*out)->dat + i) = be32toh(*(u32 *)((*out)->dat + i)); break;
+		case 8:  *(u64 *)((*out)->dat + i) = be64toh(*(u64 *)((*out)->dat + i)); break;
 		default: __builtin_unreachable(); // this should be impossible
 		}
 		i += size;
@@ -73,11 +43,12 @@ static const u8 *procarr(const u8 *restrict buf, i32 nmemb, uint size, struct nb
 }

 /* calls `procarr` for the simple types available. */
-static const u8 *proclist(const u8 *restrict buf, struct nbt_array *restrict out)
-{
+static const u8 *proclist(const u8 *restrict buf, struct nbt_array *restrict *restrict out) {
 	uint size;

-	switch (*(u8 *)buf) {
+	*out = NULL;
+
+	switch (*buf) {
 	case NBT_I8:  size = 1; break;
 	case NBT_I16: size = 2; break;
 	case NBT_I32: // fall through
@@ -88,42 +59,39 @@ static const u8 *proclist(const u8 *restrict buf, struct nbt_array *restrict out
 	}

 	buf++;
-	i32 len;
-	memcpy(&len, buf, 4);
-	len = be32toh(len);
+	i32 len = (i32)be32toh(*(u32 *)buf);
 	buf += 4;
 	return procarr(buf, len, size, out);
 }

-const u8 *nbt_proctag(const u8 *restrict buf, u16 slen, void *restrict out)
-{
+const u8 *nbt_proctag(const u8 *restrict buf, u16 slen, void *restrict out) {
 	const u8 *ptr, *tmp;
 	ptr = buf + 3 + slen;

-	i32  nmem;
+	i32 nmem;
 	uint size;

 	switch (*buf) {
 	case NBT_I8:  *(u8 *)out = *ptr; return ptr + 1;
-	case NBT_I16: *(u16 *)out = buftoh16(ptr); return ptr + 2;
+	case NBT_I16: *(u16 *)out = be16toh(*(u16 *)ptr); return ptr + 2;
 	case NBT_I32: // fall through
-	case NBT_F32: *(u32 *)out = buftoh32(ptr); return ptr + 4;
+	case NBT_F32: *(u32 *)out = be16toh(*(u32 *)ptr); return ptr + 4;
 	case NBT_I64: // fall through
-	case NBT_F64: *(u64 *)out = buftoh64(ptr); return ptr + 8;
+	case NBT_F64: *(u64 *)out = be16toh(*(u64 *)ptr); return ptr + 8;

-	case NBT_STR:     nmem = buftoh16(ptr), size = 1, ptr += 2; break;
-	case NBT_ARR_I8:  nmem = buftoh32(ptr), size = 1, ptr += 4; break;
-	case NBT_ARR_I32: nmem = buftoh32(ptr), size = 4, ptr += 4; break;
-	case NBT_ARR_I64: nmem = buftoh32(ptr), size = 8, ptr += 4; break;
+	case NBT_STR:     nmem = be16toh(*(u16 *)ptr), size = 1, ptr += 2; break;
+	case NBT_ARR_I8:  nmem = be32toh(*(u32 *)ptr), size = 1, ptr += 4; break;
+	case NBT_ARR_I32: nmem = be32toh(*(u32 *)ptr), size = 4, ptr += 4; break;
+	case NBT_ARR_I64: nmem = be32toh(*(u32 *)ptr), size = 8, ptr += 4; break;

 	case NBT_LIST:
-		return proclist(ptr, (struct nbt_array *)out);
+		return proclist(ptr, (struct nbt_array **)out);
 		return tmp;

 	default: return NULL;
 	}

-	return procarr(ptr, nmem, size, (struct nbt_array *)out);
+	return procarr(ptr, nmem, size, (struct nbt_array **)out);
 }


@@ -131,23 +99,22 @@ const u8 *nbt_proctag(const u8 *restrict buf, u16 slen, void *restrict out)
 * `ptr` is assumed to be the start of the `NBT_LIST` data, e.i. The list's ID, followed by the list's length.
 * If `ID` is `NBT_I8`, `NBT_I16`, `NBT_I32`, `NBT_I64`, `NBT_F32`, or `NBT_F64`, the entire list length is computed and returned.
 * For other types this won't be possible, and thus will add `1` to `dpt`, and write the list data to `lens` and `tags` at this new `dpt`. */
-static const u8 *nexttag_list(const u8 *restrict ptr, uint *restrict const dpt, i32 *restrict const lens, u8 *restrict const tags)
-{
+static const u8 *nexttag_list(const u8 *restrict ptr, uint *restrict const dpt, i32 *restrict const lens, u8 *restrict const tags) {
 	const u8 *tag = ptr;
 	ptr++;
 	switch (*tag) {
 	case NBT_END: break;
-	case NBT_I8:  ptr += (i32)buftoh32(ptr) * 1; break;
-	case NBT_I16: ptr += (i32)buftoh32(ptr) * 2; break;
+	case NBT_I8:  ptr += (i32)be32toh(*(u32 *)ptr) * 1; break;
+	case NBT_I16: ptr += (i32)be32toh(*(u32 *)ptr) * 2; break;
 	case NBT_I32: // fall through
-	case NBT_F32: ptr += (i32)buftoh32(ptr) * 4; break;
+	case NBT_F32: ptr += (i32)be32toh(*(u32 *)ptr) * 4; break;
 	case NBT_I64: // fall through
-	case NBT_F64: ptr += (i32)buftoh32(ptr) * 8; break;
+	case NBT_F64: ptr += (i32)be32toh(*(u32 *)ptr) * 8; break;
 	default:
 		// TODO: handle out of bounds... Might not be required if we use flexible array member
 		(*dpt)++;
 		tags[*dpt] = *tag;
-		lens[*dpt] = (i32)buftoh32(ptr);
+		lens[*dpt] = (i32)be32toh(*(u32 *)ptr);
 		break;
 	}
 	ptr += 4;
@@ -160,9 +127,8 @@ static const u8 *nexttag_list(const u8 *restrict ptr, uint *restrict const dpt,
 * - `lens` shall contain `MAX_DEPTH` of items representing the list length, if the current item is non-zero we shall assume we're in a list.
 *     Where the value is decremented until we reach `0`.
 * - `tags` shall contain `MAX_DEPTH` of items representing the list's stored type. */
-static const u8 *nexttag(const u8 *restrict tag, uint *restrict const dpt, i32 *restrict const lens, u8 *restrict const tags)
-{
-	u8        type;
+static const u8 *nexttag(const u8 *restrict tag, uint *restrict const dpt, i32 *restrict const lens, u8 *restrict const tags) {
+	u8 type;
 	const u8 *ptr = tag;
 	if (lens[*dpt]) {
 		type = tags[*dpt];
@@ -170,7 +136,7 @@ static const u8 *nexttag(const u8 *restrict tag, uint *restrict const dpt, i32 *
 		*dpt -= !lens[*dpt];
 	} else {
 		type = *tag;
-		ptr += buftoh16(tag + 1) + 3;
+		ptr += be16toh(*(u16 *)(tag + 1)) + 3;
 	}

 	switch (type) {
@@ -181,10 +147,10 @@ static const u8 *nexttag(const u8 *restrict tag, uint *restrict const dpt, i32 *
 	case NBT_I64: // fall through
 	case NBT_F64: ptr += 8; break;

-	case NBT_ARR_I8:  ptr += 4 + (i32)buftoh32(ptr) * 1; break;
-	case NBT_ARR_I32: ptr += 4 + (i32)buftoh32(ptr) * 4; break;
-	case NBT_ARR_I64: ptr += 4 + (i32)buftoh32(ptr) * 8; break;
-	case NBT_STR:     ptr += 2 + (u16)buftoh16(ptr) * 1; break;
+	case NBT_ARR_I8:  ptr += 4 + (i32)be32toh(*(u32 *)ptr) * 1; break;
+	case NBT_ARR_I32: ptr += 4 + (i32)be32toh(*(u32 *)ptr) * 4; break;
+	case NBT_ARR_I64: ptr += 4 + (i32)be32toh(*(u32 *)ptr) * 8; break;
+	case NBT_STR:     ptr += 2 + (u16)be16toh(*(u16 *)ptr) * 1; break;

 	case NBT_END:      (*dpt)--; break;
 	case NBT_COMPOUND: (*dpt)++; break;
@@ -203,12 +169,11 @@ static const u8 *nexttag(const u8 *restrict tag, uint *restrict const dpt, i32 *
 * - compound:list:int32
 * - string
 */
-const u8 *nbt_nexttag(const u8 *restrict buf)
-{
+const u8 *nbt_nexttag(const u8 *restrict buf) {
 	const u8 *tag;
-	u8        tags[MAX_DEPTH] = {0};
-	i32       lens[MAX_DEPTH] = {0};
-	uint      dpt             = 0;
+	u8 tags[MAX_DEPTH] = {0};
+	i32 lens[MAX_DEPTH] = {0};
+	uint dpt = 0;

 	tag = buf;
 	do {
--- a/src/dat/nbt.h
+++ b/src/dat/nbt.h
@@ -1,15 +1,14 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #include <assert.h>
-#include <endian.h>
 #include <stdbool.h>
 #include <stdlib.h>

-#include "../types.h"
 #include "../util/atrb.h"
+#include "../util/compat/endian.h"
+#include "../util/intdef.h"

 /* NBT (named binary tag) is a tree data structure. Tags have a numeric type ID, name and a payload.
 * NBT files are a compressed `compound` tag. GZip is the compression used in most cases,
@@ -22,24 +21,24 @@
 /* specifies the NBT tag IDs.
 * NOTE: every type is stored as BE (big-endian) in the file. */
 enum nbt_tagid {
-	NBT_END      = 0x00, // signifies the end of a compound tag
-	NBT_I8       = 0x01, // next byte is for an 8 bit signed integer.
-	NBT_I16      = 0x02, // next 2 bytes are for a 16 bit signed integer
-	NBT_I32      = 0x03, // next 4 bytes are for a 32 bit signed integer
-	NBT_I64      = 0x04, // next 8 bytes are for a 64 bit signed integer
-	NBT_F32      = 0x05, // next 4 bytes are for a single-precision floating-point
-	NBT_F64      = 0x06, // next 8 bytes are for a double-precision floating-point
-	NBT_ARR_I8   = 0x07, // starts with a i32, denoting size, followed by the i8 data
-	NBT_STR      = 0x08, // starts with a u16, denoting size, followed by the UTF-8 data
-	NBT_LIST     = 0x09, // starts with an ID, followed by a 32 bit signed integer denoting the size
+	NBT_END = 0x00,      // signifies the end of a compound tag
+	NBT_I8 = 0x01,       // next byte is for an 8 bit signed integer.
+	NBT_I16 = 0x02,      // next 2 bytes are for a 16 bit signed integer
+	NBT_I32 = 0x03,      // next 4 bytes are for a 32 bit signed integer
+	NBT_I64 = 0x04,      // next 8 bytes are for a 64 bit signed integer
+	NBT_F32 = 0x05,      // next 4 bytes are for a single-precision floating-point
+	NBT_F64 = 0x06,      // next 8 bytes are for a double-precision floating-point
+	NBT_ARR_I8 = 0x07,   // starts with a i32, denoting size, followed by the i8 data
+	NBT_STR = 0x08,      // starts with a u16, denoting size, followed by the UTF-8 data
+	NBT_LIST = 0x09,     // starts with an ID, followed by a 32 bit signed integer denoting the size
 	NBT_COMPOUND = 0x0A, // compound tag, contains tags and is delimited by `NBT_END`
-	NBT_ARR_I32  = 0x0B, // starts with a i32, denoting size, followed by the i32 data
-	NBT_ARR_I64  = 0x0C, // starts with a i32, denoting size, followed by the u32 data
+	NBT_ARR_I32 = 0x0B,  // starts with a i32, denoting size, followed by the i32 data
+	NBT_ARR_I64 = 0x0C,  // starts with a i32, denoting size, followed by the u32 data
 };

 struct nbt_array {
-	i32   nmemb;
-	void *dat;
+	i32 len;
+	u8 dat[];
 };


--- a/src/error.h
+++ b/src/error.h
@@ -0,0 +1,21 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+#if __INCLUDE_LEVEL__ > 0
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "util/macro.h"
+#endif
+
+#define debug(s, ...) printf("\033[95m" __FILE__ ":" MACRO_STR2(__LINE__) ": [DBG]: " s "\033[0m\n", ##__VA_ARGS__)
+#define info(s, ...)  printf(__FILE__ ":" MACRO_STR2(__LINE__) ": [INF]: " s "\n", ##__VA_ARGS__)
+#define warn(s, ...)  fprintf(stderr, "\033[93m" __FILE__ ":" MACRO_STR2(__LINE__) ": [WAR]: " s "\033[0m\n", ##__VA_ARGS__)
+#define error(s, ...) fprintf(stderr, "\033[91m" __FILE__ ":" MACRO_STR2(__LINE__) ": [ERR]: " s "\033[0m\n", ##__VA_ARGS__)
+
+#define fatal(s, ...)                                                                                                    \
+	do {                                                                                                             \
+		fprintf(stderr, "\033[101m" __FILE__ ":" MACRO_STR2(__LINE__) ": [FAT]: " s "\033[0m\n", ##__VA_ARGS__); \
+		exit(EXIT_FAILURE);                                                                                      \
+	} while (0)
--- a/src/io/conf.c
+++ b/src/io/conf.c
@@ -1,35 +0,0 @@
-#include "conf.h"
-
-#include <string.h>
-
-#include "../types.h"
-#include "../util/atrb.h"
-
-/* Matches s1 with s2, returns a pointer to s1 where the match stopped. */
-static const char *strmat(const char *s1, const char *s2) PURE NONNULL((1, 2));
-static const char *strmat(const char *s1, const char *s2)
-{
-	while ((*s1 == *s2) & !!*s1)
-		s1++, s2++;
-	return s1;
-}
-
-int conf_getkeyval(const char *restrict buf, const char *const restrict *restrict keys, int klen, const char *restrict *restrict out)
-{
-	const char *tmp = NULL;
-
-	ASSUME((klen > 0));
-	int i = 0;
-	for (; i < klen && !tmp; i++) {
-		tmp = strmat(buf, keys[i]);
-		tmp = keys[i][buf - tmp] ? tmp : 0;
-	}
-
-	if (!tmp || *tmp != '=')
-		return -1;
-
-	*out = tmp + 1;
-	return i;
-}
-
-int conf_val(int);
--- a/src/io/conf.h
+++ b/src/io/conf.h
@@ -1,12 +0,0 @@
-#pragma once
-#include "../types.h"
-#include "../util/atrb.h"
-
-/* Gets the key and value, if present. Writes the pointer for the value to `out`.
- * Returns the key index, or <0 upon failure. */
-int conf_getkeyval(const char *restrict buf, const char *const restrict *restrict keys, int klen,
-	const char *restrict *restrict out) NONNULL((1, 2, 4));
-
-/* Processes the value of `type` in `val`. Outputs to `out`.
- * Returns non-zero on failure. */
-int conf_procval(u8 type, const char *restrict val, void *restrict out) NONNULL((2, 3));
--- a/src/io/win/input.c
+++ b/src/io/win/input.c
@@ -1,12 +1,10 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #include "input.h"

 #include <GLFW/glfw3.h>

-void input_callback(GLFWwindow *win, int key, int scancode, int action, int mods)
-{
+void key_callback(GLFWwindow *win, int key, int scancode, int action, int mods) {
 	(void)win, (void)key, (void)scancode, (void)action, (void)mods; // make the compiler shut up as this is fine
 #ifndef NDEBUG
 	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
--- a/src/io/input.h
+++ b/src/io/input.h
@@ -0,0 +1,7 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+#include <GLFW/glfw3.h>
+
+void key_callback(GLFWwindow *win, int key, int scancode, int action, int mods);
--- a/src/io/win/render.c
+++ b/src/io/win/render.c
@@ -1,14 +1,14 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #include "render.h"

-#include <GLFW/glfw3.h>
 #include <glad/gl.h>
+
+#include <GLFW/glfw3.h>
 #include <stdint.h>

-#include "../../types.h"
-#include "../../util/error.h"
+#include "../error.h"
+#include "../util/intdef.h"
 #include "shader.h"

 #define VERTC 3
@@ -16,10 +16,9 @@ static GLuint pipe;
 static GLuint vbo;        // vertex buffer object
 static GLuint vao;        // vertex array object
 static GLuint screen_loc; // location to where OpenGL sends to the shaders of the screen dimensions
-static int    win_w, win_h;
+static int win_w, win_h;

-static void screen_resize(int w, int h)
-{
+static void screen_resize(int w, int h) {
 	i32 verts[VERTC][4] = {
 		{0, 0,  w, 20    },
 		{0, 20, w, h - 40},
@@ -33,8 +32,7 @@ static void screen_resize(int w, int h)
 	win_h = h;
 }

-int render_init(void)
-{
+int render_init(void) {
 	pipe = glCreateProgram();
 	shader_init(pipe);       // initialise and include the shaders
 	glLinkProgram(pipe);     // link the application
@@ -66,8 +64,7 @@ int render_init(void)
 	return 0;
 }

-void render_update(GLFWwindow *win)
-{
+void render_update(GLFWwindow *win) {
 	glDisable(GL_DEPTH_TEST);
 	glDisable(GL_CULL_FACE);

@@ -83,13 +80,3 @@ void render_update(GLFWwindow *win)
 	glBindVertexArray(vao);
 	glDrawArrays(GL_POINTS, 0, VERTC);
 }
-
-void render_free(void)
-{
-	glDeleteVertexArrays(1, &vao);
-	glDeleteBuffers(1, &vbo);
-	glDeleteProgram(pipe);
-	vbo  = 0;
-	vao  = 0;
-	pipe = 0;
-}
--- a/src/io/render.h
+++ b/src/io/render.h
@@ -0,0 +1,10 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+#include <glad/gl.h>
+
+#include <GLFW/glfw3.h>
+
+int render_init(void);
+void render_update(GLFWwindow *win);
--- a/src/io/render/mapcolour.c
+++ b/src/io/render/mapcolour.c
@@ -0,0 +1,68 @@
+#include "mapcolour.h"
+
+#include "../../util/vec.h"
+
+u8vec4 map_colours[MAP_COLOUR_COUNT] = {
+	{0,   0,   0,   0  },
+	{127, 178, 56,  255},
+	{247, 233, 163, 255},
+	{199, 199, 199, 255},
+	{255, 0,   0,   255},
+	{160, 160, 255, 255},
+	{167, 167, 167, 255},
+	{0,   124, 0,   255},
+	{255, 255, 255, 255},
+	{164, 168, 184, 255},
+	{151, 109, 77,  255},
+	{112, 112, 112, 255},
+	{64,  64,  255, 255},
+	{143, 119, 72,  255},
+	{255, 252, 245, 255},
+	{216, 127, 51,  255},
+	{178, 76,  216, 255},
+	{102, 153, 216, 255},
+	{229, 229, 51,  255},
+	{127, 204, 25,  255},
+	{242, 127, 165, 255},
+	{76,  76,  76,  255},
+	{153, 153, 153, 255},
+	{76,  127, 153, 255},
+	{127, 63,  178, 255},
+	{51,  76,  178, 255},
+	{102, 76,  51,  255},
+	{102, 127, 51,  255},
+	{153, 51,  51,  255},
+	{25,  25,  25,  255},
+	{250, 238, 77,  255},
+	{92,  219, 213, 255},
+	{74,  128, 255, 255},
+	{0,   217, 58,  255},
+	{129, 86,  49,  255},
+	{112, 2,   0,   255},
+	{209, 177, 161, 255},
+	{159, 82,  36,  255},
+	{149, 87,  108, 255},
+	{112, 108, 138, 255},
+	{186, 133, 36,  255},
+	{103, 117, 53,  255},
+	{160, 77,  78,  255},
+	{57,  41,  35,  255},
+	{135, 107, 98,  255},
+	{87,  92,  92,  255},
+	{122, 73,  88,  255},
+	{76,  62,  92,  255},
+	{76,  50,  35,  255},
+	{76,  82,  42,  255},
+	{142, 60,  46,  255},
+	{37,  22,  16,  255},
+	{189, 48,  49,  255},
+	{148, 63,  97,  255},
+	{92,  25,  29,  255},
+	{22,  126, 134, 255},
+	{58,  142, 140, 255},
+	{86,  44,  62,  255},
+	{20,  180, 133, 255},
+	{100, 100, 100, 255},
+	{216, 175, 147, 255},
+	{127, 167, 150, 255},
+};
--- a/src/io/render/mapcolour.h
+++ b/src/io/render/mapcolour.h
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "../../util/vec.h"
+
+enum map_colour_id {
+	MAP_COLOUR_NONE,
+	MAP_COLOUR_GRASS,
+	MAP_COLOUR_SAND,
+	MAP_COLOUR_WOOL,
+	MAP_COLOUR_FIRE,
+	MAP_COLOUR_ICE,
+	MAP_COLOUR_METAL,
+	MAP_COLOUR_PLANT,
+	MAP_COLOUR_SNOW,
+	MAP_COLOUR_CLAY,
+	MAP_COLOUR_DIRT,
+	MAP_COLOUR_STONE,
+	MAP_COLOUR_WATER,
+	MAP_COLOUR_WOOD,
+	MAP_COLOUR_QUARTZ,
+	MAP_COLOUR_ORANGE,
+	MAP_COLOUR_MAGENTA,
+	MAP_COLOUR_LIGHT_BLUE,
+	MAP_COLOUR_YELLOW,
+	MAP_COLOUR_LIGHT_GREEN,
+	MAP_COLOUR_PINK,
+	MAP_COLOUR_GREY,
+	MAP_COLOUR_LIGHT_GREY,
+	MAP_COLOUR_CYAN,
+	MAP_COLOUR_PURPLE,
+	MAP_COLOUR_BLUE,
+	MAP_COLOUR_BROWN,
+	MAP_COLOUR_GREEN,
+	MAP_COLOUR_RED,
+	MAP_COLOUR_BLACK,
+	MAP_COLOUR_GOLD,
+	MAP_COLOUR_DIAMOND,
+	MAP_COLOUR_LAPIS,
+	MAP_COLOUR_EMERALD,
+	MAP_COLOUR_PODZOL,
+	MAP_COLOUR_NETHER,
+	MAP_COLOUR_TERRACOTTA_WHITE,
+	MAP_COLOUR_TERRACOTTA_ORANGE,
+	MAP_COLOUR_TERRACOTTA_MAGENTA,
+	MAP_COLOUR_TERRACOTTA_LIGHT_BLUE,
+	MAP_COLOUR_TERRACOTTA_YELLOW,
+	MAP_COLOUR_TERRACOTTA_LIGHT_GREEN,
+	MAP_COLOUR_TERRACOTTA_PINK,
+	MAP_COLOUR_TERRACOTTA_GREY,
+	MAP_COLOUR_TERRACOTTA_LIGHT_GREY,
+	MAP_COLOUR_TERRACOTTA_CYAN,
+	MAP_COLOUR_TERRACOTTA_PURPLE,
+	MAP_COLOUR_TERRACOTTA_BLUE,
+	MAP_COLOUR_TERRACOTTA_BROWN,
+	MAP_COLOUR_TERRACOTTA_GREEN,
+	MAP_COLOUR_TERRACOTTA_RED,
+	MAP_COLOUR_TERRACOTTA_BLACK,
+	MAP_COLOUR_CRIMSON_NYLIUM,
+	MAP_COLOUR_CRIMSON_STEM,
+	MAP_COLOUR_CRIMSON_HYPHAE,
+	MAP_COLOUR_WARPED_NYLIUM,
+	MAP_COLOUR_WARPED_STEM,
+	MAP_COLOUR_WARPED_HYPHAE,
+	MAP_COLOUR_WARPED_WART_BLOCK,
+	MAP_COLOUR_DEEPSLATE,
+	MAP_COLOUR_RAW_IRON,
+	MAP_COLOUR_GLOW_LICHEN,
+
+	// contains count, leave last
+	MAP_COLOUR_COUNT,
+};
+
+/* contains the colours of the map on their' respective index - 1. (NONE should be handled separately) */
+extern u8vec4 map_colours[MAP_COLOUR_COUNT];
--- a/src/io/shader.c
+++ b/src/io/shader.c
@@ -0,0 +1,59 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#include "shader.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "../error.h"
+
+#define NAM_S(name) _binary_res_##name##_start // name of a start variable
+#define NAM_E(name) _binary_res_##name##_end   // name of an end variable
+
+// macro for generating the variable declarations
+#define DEF_GLSL(name)                   \
+	extern char const NAM_S(name)[]; \
+	extern char const NAM_E(name)[]
+
+// NOTE: we are currently just sucking up the memory costs for ease. We can either include the source files themselves. Or use compression, where I'd prefer the latter for ease of installation.
+// NOLINTBEGIN (bugprone-reserved-identifier)
+DEF_GLSL(sh_vert_glsl);
+DEF_GLSL(sh_frag_glsl);
+DEF_GLSL(sh_geom_glsl);
+// NOLINTEND
+
+/* compile a shader */
+static GLuint shader_compile(GLenum type, const char *src, size_t len) {
+	int ilen = len;
+	GLuint shader = glCreateShader(type);
+	glShaderSource(shader, 1, &src, &ilen);
+	glCompileShader(shader);
+
+	// repurposing ilen for the max length of the shader log
+	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &ilen);
+	if (ilen > 0) {
+		char log[ilen];
+		glGetShaderInfoLog(shader, ilen, &ilen, log);
+		log[ilen - 1] = '\0'; // terminate the string one character sooner since the log includes a newline
+		error("error whilst compiling shader type '0X%X': '%s'", type, log);
+	}
+
+	return shader;
+}
+
+#define COMPILE_NAME(_type, _name) shader_compile(_type, NAM_S(_name), (uintptr_t)NAM_E(_name) - (uintptr_t)NAM_S(_name))
+int shader_init(GLuint pipe) {
+	GLuint vs = COMPILE_NAME(GL_VERTEX_SHADER, sh_vert_glsl);
+	GLuint fs = COMPILE_NAME(GL_FRAGMENT_SHADER, sh_frag_glsl);
+	GLuint gs = COMPILE_NAME(GL_GEOMETRY_SHADER, sh_geom_glsl);
+
+	glAttachShader(pipe, vs);
+	glAttachShader(pipe, fs);
+	glAttachShader(pipe, gs);
+
+	glDeleteShader(vs);
+	glDeleteShader(fs);
+	glDeleteShader(gs);
+	return 1;
+}
--- a/src/io/shader.h
+++ b/src/io/shader.h
@@ -0,0 +1,10 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+#include <glad/gl.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+int shader_init(GLuint pipe);
--- a/src/io/win/input.h
+++ b/src/io/win/input.h
@@ -1,10 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-#include <GLFW/glfw3.h>
-
-/* Handles incoming key inputs for `win`.
- * Intended to be given as an argument to `glfwSetKeyCallback`. */
-void input_callback(GLFWwindow *win, int key, int scancode, int action, int mods);
--- a/src/io/win/render.h
+++ b/src/io/win/render.h
@@ -1,11 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-#include <GLFW/glfw3.h>
-#include <glad/gl.h>
-
-int  render_init(void);
-void render_update(GLFWwindow *win);
-void render_free(void);
--- a/src/io/win/shader.c
+++ b/src/io/win/shader.c
@@ -1,57 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include "shader.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include "../../util/error.h"
-
-
-// NOTE: we are currently just sucking up the memory costs for ease. We can either include the source files themselves. Or use compression, where I'd prefer the latter for ease of installation.
-extern const char sh_vert_glsl[];
-extern const char sh_frag_glsl[];
-extern const char sh_geom_glsl[];
-extern const uint sh_vert_glsl_len;
-extern const uint sh_frag_glsl_len;
-extern const uint sh_geom_glsl_len;
-
-/* Compiles a shader of `type` from `src` with `len` bytes.
- * Returns the integer for the shader. */
-static GLuint shader_compile(GLenum type, const char *src, usize len)
-{
-	int    ilen   = len;
-	GLuint shader = glCreateShader(type);
-	glShaderSource(shader, 1, &src, &ilen);
-	glCompileShader(shader);
-
-	// repurposing ilen for the max length of the shader log
-	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &ilen);
-	if (ilen > 0) {
-		char log[ilen];
-		glGetShaderInfoLog(shader, ilen, &ilen, log);
-		log[ilen - 1] = '\0'; // terminate the string one character sooner since the log includes a newline
-		error("error whilst compiling shader type '0x%X': '%s'", type, log);
-	}
-
-	return shader;
-}
-
-int shader_init(GLuint pipe)
-{
-	GLuint vs = shader_compile(GL_VERTEX_SHADER, sh_vert_glsl, sh_vert_glsl_len);
-	GLuint fs = shader_compile(GL_FRAGMENT_SHADER, sh_frag_glsl, sh_frag_glsl_len);
-	GLuint gs = shader_compile(GL_GEOMETRY_SHADER, sh_geom_glsl, sh_geom_glsl_len);
-
-	glAttachShader(pipe, vs);
-	glAttachShader(pipe, fs);
-	glAttachShader(pipe, gs);
-
-	// mark shaders off for deletion
-	glDeleteShader(vs);
-	glDeleteShader(fs);
-	glDeleteShader(gs);
-	return 1;
-}
--- a/src/io/win/shader.h
+++ b/src/io/win/shader.h
@@ -1,11 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-#include <glad/gl.h>
-#include <stddef.h>
-#include <stdint.h>
-
-/* Initialises the (embedded) shaders onto `pipe` */
-int shader_init(GLuint pipe);
--- a/src/io/win/window.c
+++ b/src/io/win/window.c
@@ -1,89 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include "window.h"
-
-#include <GLFW/glfw3.h>
-#include <assert.h>
-#include <glad/gl.h>
-
-#include "../../types.h"
-#include "../../util/error.h"
-#include "input.h"
-#include "render.h"
-
-static struct GLFWwindow *win = NULL;
-
-/* Initialises the GLFW window with some defaults,
- * then proceed to activate OpenGL on it. */
-int window_init(void)
-{
-	// initialise the window
-#ifndef NDEBUG
-	glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
-#endif
-	glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 1);
-	glfwWindowHint(GLFW_RED_BITS, 8);
-	glfwWindowHint(GLFW_GREEN_BITS, 8);
-	glfwWindowHint(GLFW_BLUE_BITS, 8);
-	glfwWindowHint(GLFW_ALPHA_BITS, 0);
-	/* NOTE: on my system; x86_64, GTX 1650 580.82.09-2, X11, i3, this causes one direct, 2 indirect memory leaks.
-	 * This is not my fault, and can safely be ignored. */
-	win = glfwCreateWindow(640, 480, "MCA-Selector lite", NULL, NULL);
-	if (!win)
-		return 1;
-
-	glfwMakeContextCurrent(win);
-	if (!gladLoadGL(glfwGetProcAddress))
-		return 1;
-	glfwSwapInterval(1); // wait 1 screen update for a redraw a.k.a. "vsync". (not really applicable in this case but eh)
-
-	glfwSetKeyCallback(win, input_callback);
-
-	debug(
-		"version info:\n"
-		"\tvendor:       %s\n"
-		"\trenderer:     %s\n"
-		"\tversion:      %s\n"
-		"\tshading lang: %s\n",
-		glGetString(GL_VENDOR),
-		glGetString(GL_RENDERER),
-		glGetString(GL_VERSION),
-		glGetString(GL_SHADING_LANGUAGE_VERSION));
-	return 0;
-}
-
-void window_loop(void)
-{
-	assert(win);
-	render_init();
-	while (!glfwWindowShouldClose(win)) {
-		glfwWaitEvents();
-
-		render_update(win);
-		glfwSwapBuffers(win);
-		glfwPollEvents();
-	}
-}
-
-void window_close(void)
-{
-	assert(win);
-	glfwSetWindowShouldClose(win, 1);
-}
-
-void window_free(void)
-{
-	if (!win) {
-		debug("window has already been freed.");
-		return;
-	}
-
-	glfwDestroyWindow(win);
-	render_free();
-	win = NULL;
-}
--- a/src/io/win/window.h
+++ b/src/io/win/window.h
@@ -1,20 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-/* Set up the window, enabling OpenGL, and
- * configuring the settings that are needed.
- * Returns `0` upon success, otherwise `1`. */
-int window_init(void);
-
-/* Calls the update loop for the window.
- * This function does not exit until the window does. */
-void window_loop(void);
-
-/* Requests the window to close (gracefully). */
-void window_close(void);
-
-/* Cleans up all resources held by the window.
- * If the window is still open, it will be terminated. */
-void window_free(void);
--- a/src/io/window.c
+++ b/src/io/window.c
@@ -0,0 +1,74 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#include "window.h"
+
+#include <glad/gl.h>
+
+#include <GLFW/glfw3.h>
+#include <assert.h>
+
+#include "../error.h"
+#include "input.h"
+#include "render.h"
+
+// macros for ease of access
+#define WIN_NAME           "MCA Selector Lite"
+#define WIN_DEFAULT_WIDTH  640
+#define WIN_DEFAULT_HEIGHT 480
+
+static GLFWwindow *win = NULL;
+
+int window_init(void) {
+#ifndef NDEBUG
+	glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);
+#endif
+
+	// initialize the window
+	glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // sets the profile to "core", so old, deprecated functions are disabled.
+	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
+	glfwWindowHint(GLFW_RED_BITS, 8);
+	glfwWindowHint(GLFW_GREEN_BITS, 8);
+	glfwWindowHint(GLFW_BLUE_BITS, 8);
+	glfwWindowHint(GLFW_ALPHA_BITS, 0);
+	win = glfwCreateWindow(WIN_DEFAULT_WIDTH, WIN_DEFAULT_HEIGHT, WIN_NAME, NULL, NULL);
+	if (!win) return 1;
+
+	// setup OpenGL for the window
+	glfwMakeContextCurrent(win);
+	if (!gladLoadGL(glfwGetProcAddress)) return 1;
+	glfwSwapInterval(1); // wait 1 screen update for a redraw a.k.a. "vsync". (not really applicable in this case but eh)
+
+	// configure callbacks
+	glfwSetKeyCallback(win, key_callback);
+
+	// print the OpenGL version information
+	debug(
+		"version info:\n"
+		"\tvendor:       %s\n"
+		"\trenderer:     %s\n"
+		"\tversion:      %s\n"
+		"\tshading lang: %s\n",
+		glGetString(GL_VENDOR),
+		glGetString(GL_RENDERER),
+		glGetString(GL_VERSION),
+		glGetString(GL_SHADING_LANGUAGE_VERSION));
+
+	return 0;
+}
+
+void window_loop(void) {
+	assert(win != NULL);
+
+	render_init();
+	while (!glfwWindowShouldClose(win)) {
+		glfwWaitEvents(); // wait till an update has been given
+
+		render_update(win);
+		glfwSwapBuffers(win);
+	}
+
+	glfwDestroyWindow(win);
+}
--- a/src/io/window.h
+++ b/src/io/window.h
@@ -0,0 +1,6 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+int window_init(void);  // initializes the global window, returns non-zero upon failure
+void window_loop(void); // performs the window updates
--- a/src/main.c
+++ b/src/main.c
@@ -1,45 +1,48 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include <GLFW/glfw3.h>
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#define GLAD_GL_IMPLEMENTATION
 #include <glad/gl.h>
+#undef GLAD_GL_IMPLEMENTATION
+
+#include <GLFW/glfw3.h>
 #include <stdio.h>
 #include <stdlib.h>

-#include "io/win/window.h"
-#include "util/error.h"
+#include "error.h"
+#include "io/window.h"

-/* reroutes GLFW errors to our logging system. */
-static void error_callback(int err, const char *const msg)
-{
-	error("glfw returned (%i); \"%s\"", err, msg);
+
+#define WIN_NAME           "MCA Selector Lite"
+#define WIN_DEFAULT_WIDTH  640
+#define WIN_DEFAULT_HEIGHT 480
+
+// callback for GLFW errors
+static void error_callback(int err, const char *const msg) {
+	fprintf(stderr, "\033[91mE: glfw returned (%i); \"%s\"\033[0m\n", err, msg);
 }

-static void quit(void)
-{
-	window_free();
+static inline int init(void) {
+	glfwSetErrorCallback(error_callback);
+	glfwInitHint(GLFW_JOYSTICK_HAT_BUTTONS, GLFW_FALSE); // disable joystick buttons

-	/* terminates GLFW; destroying any
-	 * remaining windows, or other resources held by GLFW. */
+	if (!glfwInit()) return 1; // initialize GLFW
+	if (window_init()) return 1;
+
+	return 0;
+}
+
+static inline void quit(void) {
 	glfwTerminate();
 }

-
-/* Entry-point of the application. */
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
 	(void)argc, (void)argv;
 	printf("debug: [DBG], info: [INF], warning: [WAR], error: [ERR], fatal: [FAT]\n");
-	atexit(quit);
-
-	glfwSetErrorCallback(error_callback);
-	glfwInitHint(GLFW_JOYSTICK_HAT_BUTTONS, GLFW_FALSE); // disable joystick buttons; since we won't need them
-	if (!glfwInit() || window_init())
-		fatal("failed to initialise!");
+	if (init()) fatal("failed to initialize!");

 	window_loop();
+	quit();

-	/* return success, since some architectures do not follow 0=success
-	 * This action will call `quit`. */
+	// return success, since some architectures do not follow 0=success
 	return EXIT_SUCCESS;
 }
--- a/src/types.h
+++ b/src/types.h
@@ -1,36 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-typedef signed long long int llong;
-typedef unsigned short int   ushort;
-typedef unsigned int         uint;
-typedef unsigned long        ulong;
-typedef unsigned long long   ullong;
-typedef __INT8_TYPE__        i8;
-typedef __INT16_TYPE__       i16;
-typedef __INT32_TYPE__       i32;
-typedef __INT64_TYPE__       i64;
-typedef __UINT8_TYPE__       u8;
-typedef __UINT16_TYPE__      u16;
-typedef __UINT32_TYPE__      u32;
-typedef __UINT64_TYPE__      u64;
-typedef __SIZE_TYPE__        usize;
-typedef __INTPTR_TYPE__      intptr;
-typedef __UINTPTR_TYPE__     uintptr;
-
-#if __SIZEOF_SIZE_T__ == __SIZEOF_LONG_LONG__
-typedef llong ssize;
-#elif __SIZEOF_SIZE_T__ == __SIZEOF_LONG__
-typedef long ssize;
-#elif __SIZEOF_SIZE_T__ == __SIZEOF_INT__
-typedef int ssize;
-#endif
-
-#if __SIZEOF_FLOAT__ == 4
-typedef float f32;
-#endif
-#if __SIZEOF_DOUBLE__ == 8
-typedef double f64;
-#endif
--- a/src/util/atrb.h
+++ b/src/util/atrb.h
@@ -1,6 +1,5 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #if defined(__GNUC__)
@@ -57,8 +56,4 @@
 #else
 #define NONNULL(args)
 #endif
-
-#if __has_attribute(__assume__)
-#define ASSUME(args) __attribute__((__assume__ args))
-#endif
 #endif
--- a/src/util/colour32.h
+++ b/src/util/colour32.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+#include <stdint.h>
+
+#include "vec.h"
+
+#define COLOUR32_BLACK   ((u8vec4){0x00, 0x00, 0x00, 0xFF})
+#define COLOUR32_RED     ((u8vec4){0xFF, 0x00, 0x00, 0xFF})
+#define COLOUR32_YELLOW  ((u8vec4){0xFF, 0xFF, 0x00, 0xFF})
+#define COLOUR32_ORANGE  ((u8vec4){0xFF, 0x6D, 0x00, 0xFF})
+#define COLOUR32_GREEN   ((u8vec4){0x00, 0xFF, 0x00, 0xFF})
+#define COLOUR32_CYAN    ((u8vec4){0x00, 0xFF, 0xFF, 0xFF})
+#define COLOUR32_BLUE    ((u8vec4){0x00, 0x00, 0xFF, 0xFF})
+#define COLOUR32_MAGENTA ((u8vec4){0xFF, 0x00, 0xFF, 0xFF})
+#define COLOUR32_WHITE   ((u8vec4){0xFF, 0xFF, 0xFF, 0xFF})
+
+// american macros:
+#define COLOR32_BLACK   COLOUR32_BLACK
+#define COLOR32_RED     COLOUR32_RED
+#define COLOR32_YELLOW  COLOUR32_YELLOW
+#define COLOR32_ORANGE  COLOUR32_ORANGE
+#define COLOR32_GREEN   COLOUR32_GREEN
+#define COLOR32_CYAN    COLOUR32_CYAN
+#define COLOR32_BLUE    COLOUR32_BLUE
+#define COLOR32_MAGENTA COLOUR32_MAGENTA
+#define COLOR32_WHITE   COLOUR32_WHITE
--- a/src/util/compat/endian.h
+++ b/src/util/compat/endian.h
@@ -1,9 +1,10 @@
-/* Copyright (c) 2025 Quinn
- * Licensed under the MIT Licence. See LICENSE for details */
-#ifndef PORTABLE_ENDIAN_H
-#define PORTABLE_ENDIAN_H 1
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once

-#if defined(__GNUC__)
+#if __has_include(<endian.h>)
+#include <endian.h>
+#else
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #define le16toh(x) __uint16_identity(x)
 #define le32toh(x) __uint32_identity(x)
@@ -32,9 +33,5 @@
 #define htobe64(x) __uint64_identity(x)
 #else
 #error machine architecture unsupported! Expected either big-endian or little-endian, make sure to use a compiler which defines __BYTE_ORDER__ (like clang or gcc)
-#endif /* byte order */
-
-#else
-#error GNU C is unavailable
-#endif /* __GNUC__ */
-#endif /* PORTABLE_ENDIAN_H */
+#endif
+#endif
--- a/src/util/compat/io.h
+++ b/src/util/compat/io.h
@@ -1,6 +1,5 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #if defined __unix__
@@ -34,16 +33,14 @@ static inline int faccess(const char *restrict fname, int perms);
 #define PATH_SEP     '/' // contains the path separator as a character. Yes it is extremely annoying that this has to exist.
 #define PATH_SEP_STR "/" // contains the path separator as a string, useful for concatenation. Yes it is extremely annoying that this has to exist.

-int faccess(char const *restrict fname, int perms)
-{
+int faccess(char const *restrict fname, int perms) {
 	return access(fname, perms);
 }
 #elif defined(_WIN32)
 #define PATH_SEP     '\\' // contains the path separator as a character. Yes it is extremely annoying that this has to exist.
 #define PATH_SEP_STR "\\" // contains the path separator as a string, useful for concatenation. Yes it is extremely annoying that this has to exist.

-int faccess(char const *restrict fname, int perms)
-{
+int faccess(char const *restrict fname, int perms) {
 	return _access(fname, perms);
 }
 #else
--- a/src/util/compat/os.h
+++ b/src/util/compat/os.h
@@ -1,6 +1,5 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #if defined(__unix__)
--- a/src/util/conf.c
+++ b/src/util/conf.c
@@ -0,0 +1,180 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#include "conf.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../error.h"
+#include "atrb.h"
+#include "intdef.h"
+
+int conf_procbuf(const char *restrict buf, char *restrict kout, char *restrict vout, size_t len) {
+	bool feq = false; // whether we've found the equal sign
+
+	// data traversal
+	char *pos = kout; // will point to the next point in the buffer, where we'll write data
+
+	// acquire data
+	for (size_t i = 0; i < len; i++) {
+		// handling of termination tokens
+		bool brk = false; // whether we broke out of the loop, and are done reading
+		switch (buf[i]) {
+		case '\n':
+		case '\r':
+		case '\0':
+		case '#':
+			brk = true;
+			break;
+		}
+		if (brk) break;
+
+		// everything after `=` is interpreted as a value
+		if (!feq && buf[i] == '=') {
+			feq = true;
+			*pos = '\0'; // terminate string
+			pos = vout;  // move pointer to start of value data
+			continue;
+		}
+		*pos = buf[i]; // copy over the buffer's data
+		pos++;         // increment the position pointer
+	}
+	// null-terminate what we've got now (yes, there should be enough space for this since \0 isn't stored)
+	// this also ensures the value is valid, even if none is given
+	*pos = '\0';
+
+	// no data if we didn't move from the key position
+	// syntax error if we couldn't find the equal sign
+	return (pos == kout) ? CONF_ENODAT : (!feq ? CONF_ESYNTAX : 0);
+}
+
+struct conf_entry const *conf_matchopt(struct conf_entry const *opts, size_t optc, const char *restrict key) {
+	// find a match for the current key
+	size_t i = 0;
+	for (; i < optc; i++) {
+		if (strcmp(opts[i].key, key) == 0)
+			return opts + i;
+	}
+	return NULL;
+}
+
+int conf_procval(struct conf_entry const *opt, const char *restrict val) {
+	// parse the data
+	errno = 0;
+	char *end;
+	u8 dat[sizeof(u64)];
+
+	switch (opt->type) {
+	// signed integer data parsing
+	case CONF_I8:
+	case CONF_I16:
+	case CONF_I32:
+	case CONF_I64:
+		*(i64 *)dat = strtoll(val, &end, 10); // for signed integer types
+		break;
+	// unsigned integer data parsing
+	case CONF_U8:
+	case CONF_U16:
+	case CONF_U32:
+	case CONF_U64:
+		*(u64 *)dat = strtoull(val, &end, 10); // for unsigned integer types
+		break;
+
+	// floating-point data parsing
+	case CONF_F32: *(f32 *)dat = strtof(val, &end); break;
+	case CONF_F64: *(f64 *)dat = strtod(val, &end); break;
+
+	// string data parsing
+	case CONF_STR:
+		if (*(char **)opt->out) {
+			free(*(char **)opt->out); // if the same key is given multiple times, free the memory so we don't leak.
+			warn("encountered a dynamic string multiple times, this is sub-optimal.");
+		}
+		*(char **)opt->out = strdup(val);
+		return 0;
+	case CONF_FSTR: {
+		struct conf_fstr *s = opt->out;
+		strncpy(s->out, val, s->len);
+		s->out[s->len - 1] = '\0'; // ensure the string is null-terminated
+		return 0;
+	}
+	default: return CONF_EINVALIDTYPE; // return error code indicating function not implemented
+	}
+
+	if (errno || end == val || *end != '\0') {
+		error("failed to parse '%s' as a numeric value", val);
+		return CONF_EPARSE;
+	}
+
+	switch (opt->type) {
+	case CONF_U8:  *(u8 *)opt->out = *(u64 *)dat >= UINT8_MAX ? UINT8_MAX : *(u64 *)dat; return 0;
+	case CONF_U16: *(u16 *)opt->out = *(u64 *)dat >= UINT16_MAX ? UINT16_MAX : *(u64 *)dat; return 0;
+	case CONF_U32: *(u32 *)opt->out = *(u64 *)dat >= UINT32_MAX ? UINT32_MAX : *(u64 *)dat; return 0;
+	case CONF_U64: *(u64 *)opt->out = *(u64 *)dat >= UINT64_MAX ? UINT64_MAX : *(u64 *)dat; return 0;
+	case CONF_I8:  *(i8 *)opt->out = *(i64 *)dat >= INT8_MAX ? INT8_MAX : (*(i64 *)dat <= INT8_MIN ? INT8_MIN : *(i64 *)dat); return 0;
+	case CONF_I16: *(i16 *)opt->out = *(i64 *)dat >= INT16_MAX ? INT16_MAX : (*(i64 *)dat <= INT16_MIN ? INT16_MIN : *(i64 *)dat); return 0;
+	case CONF_I32: *(i32 *)opt->out = *(i64 *)dat >= INT32_MAX ? INT32_MAX : (*(i64 *)dat <= INT32_MIN ? INT32_MIN : *(i64 *)dat); return 0;
+	case CONF_I64: *(i64 *)opt->out = *(i64 *)dat >= INT64_MAX ? INT64_MAX : (*(i64 *)dat <= INT64_MIN ? INT64_MIN : *(i64 *)dat); return 0;
+	case CONF_F32: *(f32 *)opt->out = *(f32 *)dat; return 0;
+	case CONF_F64: *(f64 *)opt->out = *(f64 *)dat; return 0;
+	default:       fatal("invalid switch state, all cases should be handled already"); // abort; this shouldn't be possible, so I blame the programmer
+	}
+}
+
+/* utility function for conf_getpat to concatenate 3 strings, where we already know the size */
+NONNULL((1, 3))
+static char *conf_getpat_concat(const char *restrict s1, const char *restrict s2, const char *restrict s3, size_t s1len, size_t s2len, size_t s3len) {
+	assert(s2 || (!s2 && !s2len)); // ensuring the programmer passes both s2 and s2len as 0, if they intend to
+	char *buf, *ptr;
+
+	// allocate enough data for all three to the buffer
+	ptr = malloc(s1len + s2len + s3len + 1);
+	if (!ptr) return NULL;
+	buf = ptr; // store the head pointer into buf
+
+	// copy data to the buffer
+	ptr = mempcpy(ptr, s1, s1len);            // copy s1 data to the buffer
+	if (s2len) ptr = mempcpy(ptr, s2, s2len); // copy s2 data to the buffer (excluding null-terminator)
+	(void)strcpy(ptr, s3);                    // copy s3 as a string, thus including null-terminator
+
+	// return the buffer
+	return buf;
+}
+
+/* appends str to the config directory string we acquire from environment variables. */
+char *conf_getpat(const char *restrict str) {
+	char *buf = NULL;
+	size_t len;
+	size_t str_len = strlen(str);
+#if defined(__linux__)
+	buf = getenv("XDG_CONFIG_HOME");
+	if (!buf) {
+		buf = getenv("HOME");
+		if (!buf) return NULL;
+		len = strlen(buf);
+		return conf_getpat_concat(buf, "/.config", str, len, 8, str_len);
+	}
+	return conf_getpat_concat(buf, NULL, str, strlen(buf), 0, str_len);
+#elif defined(__APPLE__)
+	buf = getenv("HOME");
+	if (!buf) return NULL;
+	len = strlen(buf);
+	return conf_getpat_concat(buf, "/Library/Application Support", str, len, 28, str_len);
+#elif defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+	buf = getenv("APPDATA");
+	if (!buf) {
+		buf = getenv("USERPROFILE");
+		if (!buf) return NULL;
+		len = strlen(buf);
+		return conf_getpat_concat(buf, "\\AppData\\Roaming", str, len, 16, str_len);
+	}
+	return conf_getpat_concat(buf, NULL, str, strlen(buf), 0, str_len);
+#else
+#error platform unsupported!
+#endif
+}
--- a/src/util/conf.h
+++ b/src/util/conf.h
@@ -0,0 +1,70 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "atrb.h"
+#include "intdef.h"
+
+/* error codes */
+enum conf_err {
+	CONF_ENODAT = -1,      // no data was found
+	CONF_ESYNTAX = 1,      // couldn't extract clear key/val data
+	CONF_ENOMATCH = 2,     // couldn't find a match for the inputted key
+	CONF_EINVALIDTYPE = 3, // the type inputted in conf_entry was invalid
+	CONF_EPARSE = 4,       // something went wrong whilst parsing
+};
+
+/* defines the primitive types available in the config file */
+enum conf_primitive {
+	CONF_STR = 0,               // expects: `char**`, will output malloc'd data !!must be freed!!
+	CONF_I8 = 1,                // expects: `int8_t*`, will point to a location in memory where an i8 is stored.
+	CONF_I16 = 2,               // expects: `int16_t*`, will point to a location in memory where an i16 is stored.
+	CONF_I32 = 4,               // expects: `int32_t*`, will point to a location in memory where an i32 is stored.
+	CONF_I64 = 8,               // expects: `int64_t*`, will point to a location in memory where an i64 is stored.
+	CONF_U8 = CONF_I8 | 0x80,   // expects: `uint8_t*`, will point to a location in memory where an u8 is stored.
+	CONF_U16 = CONF_I16 | 0x80, // expects: `uint16_t*`, will point to a location in memory where an u16 is stored.
+	CONF_U32 = CONF_I32 | 0x80, // expects: `uint32_t*`, will point to a location in memory where an u32 is stored.
+	CONF_U64 = CONF_I64 | 0x80, // expects: `uint64_t*`, will point to a location in memory where an u64 is stored.
+	CONF_F32 = CONF_I32 | 0x40, // expects: `float*`, will point to a location in memory where an f32 is stored.
+	CONF_F64 = CONF_I64 | 0x40, // expects: `double*`, will point to a location in memory where an f64 is stored.
+	CONF_FSTR = 0x40,           // expects: `struct conf_fstr*`, which contains the data for a fixed-width string
+};
+
+/* for outputting a fixed string as this config field */
+struct conf_fstr {
+	size_t len; // length in BYTES of the output data
+	char *out;  // where we will output the data
+};
+
+/* defines the structure of a config file entry */
+struct conf_entry {
+	const char *key; // the key of this entry
+	void *out;       // the pointer to which the data is written value is read if the given option is incorrect or missing
+	u8 type;         // the primitive type which we are querying for
+};
+
+/* processes an incoming buffer.
+ * `buf`, `kout` and `vout` mustn't overlap, and must be (at least) `len` bytes long!
+ * `kout` and `vout` will contain a null-terminated string if the function returned successfully.
+ * returns `0` on success, `<0` when no data was found. `>0` when data was invalid but something went wrong.
+ * see `CONF_E*` or `enum conf_err` */
+int conf_procbuf(const char *restrict buf, char *restrict kout, char *restrict vout, size_t len);
+
+/* matches the key with one of the options and returns the pointer. Returns NULL if none could be found. */
+struct conf_entry const *conf_matchopt(struct conf_entry const *opts, size_t optc, const char *restrict key);
+
+/* processes the value belonging to the key and outputs the result to opts.
+ * - `val` points to a null-terminated string which contains the key and value.
+ * returns `0` upon success, non-zero upon failure. For information about specific error codes, see `enum conf_err` */
+int conf_procval(struct conf_entry const *opts, const char *restrict val);
+
+/* acquires the config file path, appending str to the end (you need to handle path separators yourself)
+ * expecting str to be null-terminated
+ * - linux:   reads $XDG_CONFIG_HOME, if empty $HOME/.config is used, if $HOME is empty NULL is returned.
+ * - windows: reads %APPDATA%, if empty %USERPROFILE%\AppData\Roaming is used, if both are empty NULL is returned.
+ * - osx:     reads $HOME, uses $HOME/Library/Application Support, if $HOME is empty NULL is returned.
+ * !! A malloc'd null-terminated string is returned !! */
+char *conf_getpat(const char *) MALLOC NONNULL((1));
--- a/src/util/error.c
+++ b/src/util/error.c
@@ -1,64 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include "error.h"
-
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "../types.h"
-
-static void error_log(FILE *restrict stream, const char *restrict pfx, uint ln, const char *restrict file, const char *restrict fmt, va_list ap)
-{
-	fprintf(stream, "(%s:%u) [%s] '", file, ln, pfx);
-	vfprintf(stream, fmt, ap);
-	fprintf(stream, "'\n");
-}
-
-void error_debug(uint ln, const char *restrict file, const char *restrict fmt, ...)
-{
-#ifndef NDEBUG
-#else
-	char *env = getenv("DEBUG");
-	if (env && env[0] != '1')
-		return;
-#endif
-	va_list ap;
-	va_start(ap, fmt);
-	error_log(stdout, "\033[95mDBG\033[0m", ln, file, fmt, ap);
-	va_end(ap);
-}
-
-void error_info(uint ln, const char *restrict file, const char *restrict fmt, ...)
-{
-	va_list ap;
-	va_start(ap, fmt);
-	error_log(stdout, "\033[94mINF\033[0m", ln, file, fmt, ap);
-	va_end(ap);
-}
-
-void error_warn(uint ln, const char *restrict file, const char *restrict fmt, ...)
-{
-	va_list ap;
-	va_start(ap, fmt);
-	error_log(stdout, "\033[93mWAR\033[0m", ln, file, fmt, ap);
-	va_end(ap);
-}
-
-void error_error(uint ln, const char *restrict file, const char *restrict fmt, ...)
-{
-	va_list ap;
-	va_start(ap, fmt);
-	error_log(stdout, "\033[91mERR\033[0m", ln, file, fmt, ap);
-	va_end(ap);
-}
-
-void error_fatal(uint ln, const char *restrict file, const char *restrict fmt, ...)
-{
-	va_list ap;
-	va_start(ap, fmt);
-	error_log(stdout, "\033[101mFAT\033[0m", ln, file, fmt, ap);
-	va_end(ap);
-
-	exit(EXIT_FAILURE);
-}
--- a/src/util/error.h
+++ b/src/util/error.h
@@ -1,22 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "../types.h"
-#include "atrb.h"
-
-void error_debug(uint ln, const char *restrict file, const char *restrict fmt, ...);
-void error_info(uint ln, const char *restrict file, const char *restrict fmt, ...);
-void error_warn(uint ln, const char *restrict file, const char *restrict fmt, ...);
-void error_error(uint ln, const char *restrict file, const char *restrict fmt, ...);
-void error_fatal(uint ln, const char *restrict file, const char *restrict fmt, ...) NORET;
-
-#define debug(...) error_debug(__LINE__, __FILE__ __VA_OPT__(, ) __VA_ARGS__)
-#define info(...)  error_info(__LINE__, __FILE__ __VA_OPT__(, ) __VA_ARGS__)
-#define warn(...)  error_warn(__LINE__, __FILE__ __VA_OPT__(, ) __VA_ARGS__)
-#define error(...) error_error(__LINE__, __FILE__ __VA_OPT__(, ) __VA_ARGS__)
-#define fatal(...) error_fatal(__LINE__, __FILE__ __VA_OPT__(, ) __VA_ARGS__)
--- a/src/util/intdef.h
+++ b/src/util/intdef.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#pragma once
+
+/* variable-width integer types */
+typedef unsigned int uint;         // ≥16 bit unsigned integer
+typedef unsigned long ulong;       // ≥32 bit unsigned integer
+typedef signed long long llong;    // ≥64 bit signed integer
+typedef unsigned long long ullong; // ≥64 bit unsigned integer
+
+/* fixed-width integer types */
+#include <stdint.h>
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+/* floating point types */
+typedef float f32;  // single-precision floating-point
+typedef double f64; // double-precision floating-point
--- a/src/util/macro.h
+++ b/src/util/macro.h
@@ -1,6 +1,5 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once

 #define WIDTHOF(t)       (sizeof(t) * 8) // gets the bit width of a type
--- a/src/util/util.h
+++ b/src/util/util.h
@@ -1,6 +1,3 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
 #pragma once

 /* Acquires the next power of two of value `x`.
--- a/src/util/vec.h
+++ b/src/util/vec.h
@@ -1,9 +1,6 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
 #pragma once

-#include "../types.h"
+#include "intdef.h"

 #if defined(__has_attribute) && __has_attribute(vector_size)
 typedef float fvec2 __attribute__((vector_size(sizeof(float) * 2))); // SMID vector for 2 `float`
--- a/test/dat.h
+++ b/test/dat.h
@@ -0,0 +1,34 @@
+#include <stdint.h>
+
+#include "../src/util/conf.h"
+#include "../src/util/intdef.h"
+#include "t_arith.h"
+#include "t_conf.h"
+#include "test.h"
+
+testdat tests[] = {
+	{"ensure SAR",  test_sar,                NULL									    },
+	{"k=v",         test_procbuf,            &(struct test_procbuf){"key=val", "key", "val", 0}                              },
+	{"sometxt",     test_procbuf,            &(struct test_procbuf){"sometxt", "sometxt", "", CONF_ESYNTAX}                  },
+	{"comment",     test_procbuf,            &(struct test_procbuf){"# comment", "", "", CONF_ENODAT}                        },
+	{"empty",       test_procbuf,            &(struct test_procbuf){"", "", "", CONF_ENODAT}                                 },
+	{"LF",          test_procbuf,            &(struct test_procbuf){"\n", "", "", CONF_ENODAT}                               },
+	{"CRLF",        test_procbuf,            &(struct test_procbuf){"\r\n", "", "", CONF_ENODAT}                             },
+	{"k=v (LF)",    test_procbuf,            &(struct test_procbuf){"k=v\na", "k", "v", 0}                                   },
+	{"k=v (CRLF)",  test_procbuf,            &(struct test_procbuf){"k=v\r\na", "k", "v", 0}                                 },
+	{"get",         test_matchopt,           &(struct test_matchopt){"key3", 2}                                              },
+	{"invalid",     test_matchopt,           &(struct test_matchopt){"nono", -1}                                             },
+	// NOTE: formatter is fucking with alignment making it use tabs @.@
+	{"i32",         test_procval_int,        &(struct test_procval_int){"42", 42, CONF_I32}                                  },
+	{"i32_neg",     test_procval_int,        &(struct test_procval_int){"-42", (u32)-42, CONF_I32}                           },
+	{"u32_max",     test_procval_int,        &(struct test_procval_int){"4294967295", UINT32_MAX, CONF_U64}                  },
+	{"u64",         test_procval_int,        &(struct test_procval_int){"3141592653589793238", 3141592653589793238, CONF_U64}},
+	{"u8_overflow", test_procval_int,        &(struct test_procval_int){"256", 255, CONF_U8}                                 },
+	{"",            test_procval_f32,        NULL									    },
+	{"",            test_procval_str,        NULL									    },
+	{"",            test_procval_str_predef, NULL									    },
+	{"",            test_procval_fstr,       NULL									    },
+	{"",            test_procval_fstr_trunc, NULL									    },
+	{"",            test_procval_eparse,     NULL									    },
+	{"",            test_getpat,             NULL									    },
+};
--- a/test/main.c
+++ b/test/main.c
@@ -1,55 +1,19 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
+#define GLAD_GL_IMPLEMENTATION
+#include <glad/gl.h>
+#undef GLAD_GL_IMPLEMENTATION
+
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>

+#include "dat.h" // contains the test data
 #include "test.h"
-#include "test_conf.h"

-int main(void)
-{
-	assert_true(-3 >> 5 == -1); // checking for arithmetic shift, rather than logical shift
-	assert_true(sizeof(u8) == 1);
-	assert_true(sizeof(u16) == 2);
-	assert_true(sizeof(u32) == 4);
-	assert_true(sizeof(u64) == 8);
-	assert_true(sizeof(f32) == 4);
-	assert_true(sizeof(f64) == 8);
-	assert_true(sizeof(usize) == sizeof(size_t));
-	test_conf_procbuf("key=val", "key", "val", 0);
-	test_conf_procbuf("sometxt", "sometxt", "", CONF_ESYNTAX);
-	test_conf_procbuf("# comment", "", "", CONF_ENODAT);
-	test_conf_procbuf("", "", "", CONF_ENODAT);
-	test_conf_procbuf("\n", "", "", CONF_ENODAT);
-	test_conf_procbuf("\r\n", "", "", CONF_ENODAT);
-	test_conf_procbuf("k=v\na", "k", "v", 0);
-	test_conf_procbuf("k=v\r\na", "k", "v", 0);
-	test_conf_getpat();
+int main(void) {
+	// get test count
+	size_t n = sizeof(tests) / sizeof(tests[0]);

-	struct conf_entry opts[] = {
-		{"key0", NULL, 0},
-		{"key1", NULL, 0},
-		{"key2", NULL, 0}
-        };
-	test_conf_matchopt(opts, 3, "key0", 0);
-	test_conf_matchopt(opts, 3, "key1", 1);
-	test_conf_matchopt(opts, 3, "key2", 2);
-	test_conf_matchopt(opts, 3, "key3", -1);
-
-	test_conf_procval_int("42", 42, CONF_I32);
-	test_conf_procval_int("-42", (u32)-42, CONF_I32);
-	test_conf_procval_int("4294967295", UINT32_MAX, CONF_U32);
-	test_conf_procval_int("9223372036854775807", INT64_MAX, CONF_I64);
-	test_conf_procval_int("256", 255, CONF_U8);
-
-	// TODO: write more tests for float parsing
-	test_conf_procval_f32("0.0", 0.0f);
-	test_conf_procval_f32("3.14159", 3.14159f);
-	test_conf_procval_f32("3.1428571428", 22.0f / 7.0f);
-	test_conf_procval_f32("-5.0", -5.0f);
-
-	/* return 1 if there were failed tests. */
-	printf("test results: (%u/%u)\n", test_okay, test_okay + test_fail);
-	return !!test_fail;
+	return exec_tests(tests, n);
 }
--- a/test/t_arith.h
+++ b/test/t_arith.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "test.h"
+
+/* tests arithmetic shift for signed integers (rather than logical shift) */
+int test_sar(void *dat) {
+	(void)dat;
+	return assert_true(-3 >> 5 == -1);
+}
--- a/test/t_conf.h
+++ b/test/t_conf.h
@@ -0,0 +1,205 @@
+#pragma once
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../src/util/conf.h"
+#include "../src/util/intdef.h"
+#include "test.h"
+
+// Environment saver structure for conf_getpat tests
+#if defined(__linux__) || defined(__APPLE__) || defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+struct test_getpat_envdat {
+	char *xdg_config_home;
+	char *home;
+	char *appdata;
+	char *userprofile;
+};
+
+/* save the current environment variables */
+static void env_save(struct test_getpat_envdat *s) {
+	const char *tmp;
+
+	tmp = getenv("XDG_CONFIG_HOME");
+	s->xdg_config_home = tmp ? strdup(tmp) : NULL;
+
+	tmp = getenv("HOME");
+	s->home = tmp ? strdup(tmp) : NULL;
+
+	tmp = getenv("APPDATA");
+	s->appdata = tmp ? strdup(tmp) : NULL;
+
+	tmp = getenv("USERPROFILE");
+	s->userprofile = tmp ? strdup(tmp) : NULL;
+}
+
+/* restores the environment variables to what they were before */
+static void env_restore(struct test_getpat_envdat *s) {
+#ifdef _WIN32
+	if (s->xdg_config_home) _putenv_s("XDG_CONFIG_HOME", s->xdg_config_home);
+	else _putenv("XDG_CONFIG_HOME=");
+	if (s->home) _putenv_s("HOME", s->home);
+	else _putenv("HOME=");
+	if (s->appdata) _putenv_s("APPDATA", s->appdata);
+	else _putenv("APPDATA=");
+	if (s->userprofile) _putenv_s("USERPROFILE", s->userprofile);
+	else _putenv("USERPROFILE=");
+#else
+	if (s->xdg_config_home) setenv("XDG_CONFIG_HOME", s->xdg_config_home, 1);
+	else unsetenv("XDG_CONFIG_HOME");
+	if (s->home) setenv("HOME", s->home, 1);
+	else unsetenv("HOME");
+	if (s->appdata) setenv("APPDATA", s->appdata, 1);
+	else unsetenv("APPDATA");
+	if (s->userprofile) setenv("USERPROFILE", s->userprofile, 1);
+	else unsetenv("USERPROFILE");
+#endif
+	free(s->xdg_config_home);
+	free(s->home);
+	free(s->appdata);
+	free(s->userprofile);
+}
+#endif
+
+/* check procbuf's functionality */
+struct test_procbuf {
+	const char *in;   // data in
+	const char *xkey; // expected key
+	const char *xval; // expected value
+	int xret;         // expected return type
+};
+int test_procbuf(void *arg) {
+	struct test_procbuf *dat = arg;
+	size_t len = strlen(dat->in) + 1;
+	char k[len], v[len];
+	*k = '\0', *v = '\0';
+	return assert_true(conf_procbuf(dat->in, k, v, len) == dat->xret) ||
+		assert_true(!strcmp(k, dat->xkey)) ||
+		assert_true(!strcmp(v, dat->xval));
+}
+
+/* check matchopt functionality */
+struct test_matchopt {
+	const char *key; // key to search for (key1, key2, key3)
+	int xidx;        // expect index (<0 is NULL, may not be more than 2)
+};
+int test_matchopt(void *arg) {
+	struct test_matchopt *dat = arg;
+	struct conf_entry opts[] = {
+		{"key1", NULL, 0},
+		{"key2", NULL, 0},
+		{"key3", NULL, 0},
+	};
+	struct conf_entry *xopt = dat->xidx < 0 ? NULL : opts + dat->xidx;
+	return assert_true(conf_matchopt(opts, 3, dat->key) == xopt);
+}
+
+struct test_procval_int {
+	const char *val;
+	u64 xres;
+	u8 type;
+};
+int test_procval_int(void *arg) {
+	struct test_procval_int *dat = arg;
+	u64 out = 0;
+	return assert_true(!conf_procval(&(struct conf_entry){NULL, &out, dat->type}, dat->val)) ||
+		assert_true(out == dat->xres);
+}
+
+int test_procval_f32(void *arg) {
+	(void)arg;
+	f32 out;
+	return assert_true(!conf_procval(&(struct conf_entry){NULL, &out, CONF_F32}, "3.14159265")) ||
+		assert_true(fabsf(out - 3.14159265F) < 1e-6F);
+}
+
+int test_procval_str(void *arg) {
+	(void)arg;
+	char *out = NULL;
+	int ret = assert_true(!conf_procval(&(struct conf_entry){NULL, (void *)&out, CONF_STR}, "here comes the sowon")) ||
+		assert_false(strcmp("here comes the sowon", out));
+	free(out);
+	return ret;
+}
+
+int test_procval_str_predef(void *arg) {
+	(void)arg;
+	char *out = strdup("owo");
+	int ret = assert_true(!conf_procval(&(struct conf_entry){NULL, (void *)&out, CONF_STR}, "i leak if I don't free")) ||
+		assert_true(!strcmp("i leak if I don't free", out));
+	free(out);
+	return ret;
+}
+
+int test_procval_fstr(void *arg) {
+	(void)arg;
+	char buf[16];
+	struct conf_fstr str = {sizeof(buf), buf};
+	return assert_true(!conf_procval(&(struct conf_entry){NULL, &str, CONF_FSTR}, "hewwoo wowld")) ||
+		assert_true(!strcmp(str.out, "hewwoo wowld"));
+}
+
+int test_procval_fstr_trunc(void *arg) {
+	(void)arg;
+	char buf[8];
+	struct conf_fstr str = {sizeof(buf), buf};
+	return assert_true(!conf_procval(&(struct conf_entry){NULL, &str, CONF_FSTR}, "hewwooo wowld")) ||
+		assert_true(!strcmp(str.out, "hewwooo"));
+}
+
+int test_procval_eparse(void *arg) {
+	(void)arg;
+	i32 out;
+	return assert_true(conf_procval(&(struct conf_entry){NULL, &out, CONF_I32}, "owo") == CONF_EPARSE);
+}
+
+/* ensure paths are being set correctly */
+int test_getpat(void *arg) {
+	(void)arg;
+	struct test_getpat_envdat envs;
+	env_save(&envs);
+	int ret = 0;
+	char *path = NULL;
+
+#ifdef __linux__
+	setenv("XDG_CONFIG_HOME", "/test/config", 1);
+	path = conf_getpat("/app");
+	ret |= assert_true(path && !strcmp(path, "/test/config/app"));
+	free(path);
+	unsetenv("XDG_CONFIG_HOME");
+
+	setenv("HOME", "/test/home", 1);
+	path = conf_getpat("/app");
+	ret |= assert_true(path && !strcmp(path, "/test/home/.config/app"));
+	free(path);
+
+	unsetenv("HOME");
+#elif defined(__APPLE__)
+	setenv("HOME", "/test/home", 1);
+	path = conf_getpat("/app");
+	ret |= assert_true(path && !strcmp(path, "/test/home/Library/Application Support/app"));
+	free(path);
+
+	unsetenv("HOME");
+#elif defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
+	_putenv("APPDATA=C:\\test\\appdata");
+	path = conf_getpat("\\app");
+	ret |= assert_true(path && !strcmp(path, "C:\\test\\appdata\\app"));
+	free(path);
+
+	_putenv("APPDATA=");
+	_putenv("USERPROFILE=C:\\test\\user");
+	path = conf_getpat("\\app");
+	ret |= assert_true(path && !strcmp(path, "C:\\test\\user\\AppData\\Roaming\\app"));
+	free(path);
+
+	_putenv("USERPROFILE=");
+#endif
+	void *ptr;
+	ret |= assert_true(!(ptr = conf_getpat("anything")));
+	free(ptr);
+
+	env_restore(&envs);
+	return ret;
+}
--- a/test/test.c
+++ b/test/test.c
@@ -1,21 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include "test.h"
-
-#include "../src/types.h"
-
-uint test_okay = 0;
-uint test_fail = 0;
-
-int test_process(int res, const char *restrict file, uint ln, const char *restrict function, const char *restrict expression)
-{
-	const char *status = res ?
-		"[\033[32;1m  OK  \033[0m]" :
-		"[\033[31;1m FAIL \033[0m]";
-	test_okay += !!res;
-	test_fail += !res;
-
-	printf("%s\t%s:%u-%s\t-> %s\n", status, file, ln, function, expression);
-	return res;
-}
--- a/test/test.h
+++ b/test/test.h
@@ -1,17 +1,48 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
+// Copyright (c) 2025 Quinn
+// Licensed under the MIT Licence. See LICENSE for details
 #pragma once
 #include <stdio.h>

-#include "../src/types.h"
+const char *test_ctest;
+size_t test_runs = 0;

-extern uint test_okay;
-extern uint test_fail;
+// evaluates the test
+// returns 1 upon error
+static inline int assert_helper(int cond, const char *restrict fname, unsigned ln, const char *restrict fnname, const char *restrict expr) {
+	test_runs++;
+	if (cond)
+		printf("[\033[32;1m  OK  \033[0m] %s %s -> %s:%u (%s)\n", test_ctest, fnname, fname, ln, expr);
+	else
+		printf("[\033[31;1m FAIL \033[0m] %s %s -> %s:%u (%s)\n", test_ctest, fnname, fname, ln, expr);
+	return !cond;
+}

-/* Prints the result `res` of a test.
- * Returns `res` back, for ease of chaining. */
-int test_process(int res, const char *restrict file, uint ln, const char *restrict function, const char *restrict expression);
+#define assert_true(expr)  assert_helper(!!(expr), __FILE__, __LINE__, __func__, #expr) // evaluation expected to be true
+#define assert_false(expr) assert_helper(!(expr), __FILE__, __LINE__, __func__, #expr)  // evaluation expected to be false

-#define assert_true(expr)  test_process((expr), __FILE__, __LINE__, __func__, #expr)
-#define assert_false(expr) assert_true(!(expr))
+// contains the data for executing a single test
+struct testdat {
+	const char *name;    // test name
+	int (*test)(void *); // test, returns 0 upon success, non-zero upon failure
+	void *args;          // arguments to the test
+};
+typedef struct testdat testdat;
+
+// executes the tests, returns the amount of failed tests; >0: failure
+static inline size_t exec_tests(testdat *dat, size_t ntests) {
+	size_t i;
+	size_t err = 0;
+
+	// perform tests and count the error state
+	for (i = 0; i < ntests; i++) {
+		test_ctest = dat[i].name;
+		err += !!(dat[i].test(dat[i].args));
+	}
+
+	// give final score
+	if (!err)
+		fprintf(stdout, "tests completed! (%zu/%zu)\n", test_runs - err, test_runs);
+	else
+		fprintf(stderr, " tests failed! (%zu/%zu)\n", test_runs - err, test_runs);
+	return err;
+}
--- a/test/test_conf.c
+++ b/test/test_conf.c
@@ -1,142 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#include "test_conf.h"
-
-#include <math.h>
-#include <string.h>
-
-#include "../src/types.h"
-#include "../src/util/conf.h"
-#include "test.h"
-
-void test_conf_procbuf(const char *restrict buf, const char *restrict expect_key, const char *restrict expect_val, int expect_return)
-{
-	usize len = strlen(buf) + 1;
-	char  k[len], v[len];
-	*k = '\0', *v = '\0';
-	(void)(assert_true(conf_procbuf(buf, k, v, len) == expect_return) &&
-		assert_true(!strcmp(k, expect_key)) &&
-		assert_true(!strcmp(v, expect_val)));
-}
-
-void test_conf_matchopt(struct conf_entry *opts, usize optc, const char *restrict key, int expect_index)
-{
-	usize idx = opts - conf_matchopt(opts, optc, key);
-	idx       = (ssize)idx < 0 ? -idx : idx;
-	int i     = idx < optc ? (int)idx : -1;
-	assert_true(i == expect_index);
-}
-
-void test_conf_procval_int(const char *val, u64 expect_value, int type)
-{
-	u8 out[sizeof(u64)] = {0};
-	assert_true(!conf_procval(&(struct conf_entry){NULL, out, type}, val));
-	assert_true(memcmp(out, &expect_value, sizeof(u64)) == 0);
-}
-
-void test_conf_procval_f32(const char *val, f32 expect_value)
-{
-	u8  out[4];
-	f32 result;
-	conf_procval(&(struct conf_entry){NULL, out, CONF_F32}, val);
-	memcpy(&result, out, 4);
-	assert_true(fabsf(expect_value - result) < 1e-9f);
-}
-
-void test_procval_str(void)
-{
-	char *out = NULL;
-	(void)(assert_true(!conf_procval(&(struct conf_entry){NULL, (void *)&out, CONF_STR}, "here comes the sowon")) &&
-		assert_false(strcmp("here comes the sowon", out)));
-	free(out);
-}
-
-void test_procval_str_predef(void)
-{
-	char *out = strdup("owo");
-	(void)(assert_true(!conf_procval(&(struct conf_entry){NULL, (void *)&out, CONF_STR}, "i leak if I don't free")) &&
-		assert_true(!strcmp("i leak if I don't free", out)));
-	free(out);
-}
-
-void test_procval_fstr(void)
-{
-	char             buf[16];
-	struct conf_fstr str = {sizeof(buf), buf};
-	(void)(assert_true(!conf_procval(&(struct conf_entry){NULL, &str, CONF_FSTR}, "hewwoo wowld")) &&
-		assert_true(!strcmp(str.out, "hewwoo wowld")));
-}
-
-void test_procval_fstr_trunc(void)
-{
-	char             buf[8];
-	struct conf_fstr str = {sizeof(buf), buf};
-	(void)(assert_true(!conf_procval(&(struct conf_entry){NULL, &str, CONF_FSTR}, "hewwooo wowld")) &&
-		assert_true(!strcmp(str.out, "hewwooo")));
-}
-
-void test_procval_eparse(void)
-{
-	i32 out;
-	assert_true(conf_procval(&(struct conf_entry){NULL, &out, CONF_I32}, "owo") == CONF_EPARSE);
-}
-
-void test_conf_getpat(void)
-{
-	char *path;
-#if defined(__linux__)
-	/* test without setting environment variables. */
-	unsetenv("XDG_CONFIG_HOME");
-	unsetenv("HOME");
-	path = conf_getpat("/mypath");
-	assert_true(path == NULL);
-	free(path);
-
-	/* test with setting HOME. */
-	setenv("HOME", "/home/test", 1);
-	path = conf_getpat("/mypath");
-	assert_true(path != NULL && strcmp(path, "/home/test/.config/mypath") == 0);
-	free(path);
-	conf_getpat("/mypath");
-
-	/* test with setting XDG_CONFIG_HOME. */
-	setenv("XDG_CONFIG_HOME", "/etc/xdg", 1);
-	path = conf_getpat("/mypath");
-	assert_true(path != NULL && strcmp(path, "/etc/xdg/mypath") == 0);
-	free(path);
-#elif defined(__APPLE__)
-	/* test without setting environment variables. */
-	unsetenv("HOME");
-	path = conf_getpat("/mypath");
-	assert_true(path == NULL);
-	free(path);
-
-	/* test with setting HOME. */
-	setenv("HOME", "/home/test", 1);
-	path = conf_getpat("/mypath");
-	assert_true(path != NULL && strcmp(path, "/home/test/Library/Application Support/mypath") == 0);
-	free(path);
-#elif defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__)
-	/* test without setting environment variables. */
-	_putenv("APPDATA=");
-	_putenv("USERPROFILE=");
-	path = conf_getpat("\\mypath");
-	assert_true(path == NULL);
-	free(path);
-
-	/* test with setting USERPROFILE */
-	_putenv("USERPROFILE=C:\\Users\\test");
-	path = conf_getpat("\\mypath");
-	assert_true(path != NULL && strcmp(path, "C:\\Users\\test\\AppData\\Roaming\\mypath") == 0);
-	free(path);
-
-	/* test with setting APPDATA */
-	_putenv("APPDATA=C:\\Users\\test\\AppData\\Roaming");
-	path = conf_getpat("\\mypath");
-	assert_true(path != NULL && strcmp(path, "C:\\Users\\test\\AppData\\Roaming\\mypath") == 0);
-	free(path);
-#else
-	assert_fail("unsupported operating system; no tests have been written.");
-#endif
-}
--- a/test/test_conf.h
+++ b/test/test_conf.h
@@ -1,20 +0,0 @@
-/* Copyright (c) 2025 Quinn.
- * This is a file from the project MCA-Selector-Lite and is
- * licensed under the MIT Licence. See the project's LICENSE file for details. */
-#pragma once
-
-#include "../src/types.h"
-#include "../src/util/conf.h"
-
-void test_conf_procbuf(const char *restrict buf, const char *restrict expect_key, const char *restrict expect_val, int expect_return);
-void test_conf_matchopt(struct conf_entry *restrict opts, usize optc, const char *restrict key, int expect_index);
-void test_conf_procval_int(const char *val, u64 expect_value, int type);
-void test_conf_procval_f32(const char *val, f32 expect_value);
-void test_conf_procval_fstr(const char *val, u64 expect_value, int type);
-void test_conf_procval_str(const char *val, u64 expect_value, int type);
-void test_procval_str(void);
-void test_procval_str_predef(void);
-void test_procval_fstr(void);
-void test_procval_fstr_trunc(void);
-void test_procval_eparse(void);
-void test_conf_getpat(void);