refactor: init and destroy, alloc now first ensures cap

its better usability and is better that it ensures capacity in alloc
like that is what is supposed to be like damn, why i did it like that

include/arena.h

@@ -6,11 +6,7 @@
 #include <inttypes.h>
 #include <stdbool.h>
 
-typedef struct {
-    uint8_t *buffer;
-    size_t capacity;
-    size_t offset;
-} Arena;
+typedef struct Arena Arena;
 
 typedef enum {
     ARENA_OK = 0,
@@ -37,7 +33,7 @@ typedef struct {
     bool is_valid;
     union {
         ArenaErr err;
-        Arena arena;
+        Arena *arena;
     };
 } ArenaResult;
 
@@ -49,8 +45,8 @@ typedef struct {
     };
 } ArenaSizeResult;
 
-ArenaResult arena_init(size_t capacity);
-void arena_destroy(Arena *arena);
+ArenaErr arena_init(Arena **arena, size_t capacity);
+ArenaErr arena_destroy(Arena **arena);
 
 ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment);
 ArenaPointer arena_push(Arena *arena, void *data, size_t size, size_t alignment);

src/arena.c

@@ -5,32 +5,56 @@
 #include <stdlib.h>
 #include <string.h>
 
+struct Arena {
+    uint8_t *buffer;
+    size_t capacity;
+    size_t offset;
+};
 
 
-ArenaResult arena_init(size_t capacity) {
+ArenaErr arena_init(Arena **arena, size_t capacity) {
+    if (arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
     if (capacity < 1) {
-        return (ArenaResult) {.is_valid = false, .err = ARENA_INVALID_SIZE};
+        return ARENA_INVALID_SIZE;
+    }
+
+    Arena *new_arena = malloc(sizeof(Arena));
+    if (new_arena == NULL) {
+        return ARENA_BAD_ALLOC;
     }
 
     void *buffer = malloc(capacity);
     if (buffer == NULL) {
-        return (ArenaResult) {.is_valid = false, .err = ARENA_BAD_ALLOC};
+        return ARENA_BAD_ALLOC;
     }
 
-    Arena new_arena = {
+    *new_arena = (Arena) {
         .buffer = buffer,
         .capacity = capacity,
         .offset = 0,
     };
 
-    return (ArenaResult) {.is_valid = true, .arena = new_arena};
+    *arena = new_arena;
+
+    return ARENA_OK;
 }
 
-void arena_destroy(Arena *arena) {
-    free(arena->buffer);
-    arena->buffer = NULL;
-    arena->offset = 0;
-    arena->capacity = 0;
+ArenaErr arena_destroy(Arena **arena) {
+    if (arena == NULL || *arena == NULL) {
+        return ARENA_NULL_ARG;
+    }
+
+    free((*arena)->buffer);
+    (*arena)->buffer = NULL;
+    (*arena)->offset = 0;
+    (*arena)->capacity = 0;
+    free(arena);
+    *arena = NULL;
+
+    return ARENA_OK;
 }
 
 ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment) {
@@ -51,6 +75,11 @@ ArenaPointer arena_alloc(Arena *arena, size_t size, size_t alignment) {
         return (ArenaPointer) {.is_valid = false, .err = padding.err};
     }
 
+    ArenaErr cap_err = arena_ensure_capacity(arena, size, alignment);
+    if(cap_err != ARENA_OK) {
+        return (ArenaPointer) {.is_valid = false, .err = cap_err};
+    }
+
     if (arena->offset + padding.val + size > arena->capacity) {
         return (ArenaPointer) {.is_valid = false, .err = ARENA_OUT_OF_SPACE};
     }