diff --git a/CMakeLists.txt b/CMakeLists.txt
index cfcf403..dc97c29 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -65,6 +65,21 @@ if (TINYGLTF_BUILD_TESTS)
   )
   target_compile_definitions(tester_intensive_customjson PRIVATE TINYGLTF_USE_CUSTOM_JSON)
   add_test(NAME tester_intensive_customjson COMMAND tester_intensive_customjson WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+
+  add_executable(tester_v3_c
+    tests/tester_v3_c.c
+    tiny_gltf_v3.c
+  )
+  target_include_directories(tester_v3_c PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests
+  )
+  set_target_properties(tester_v3_c PROPERTIES
+    C_STANDARD 11
+    C_STANDARD_REQUIRED ON
+    C_EXTENSIONS OFF
+  )
+  add_test(NAME tester_v3_c COMMAND tester_v3_c WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/tests)
 endif (TINYGLTF_BUILD_TESTS)
 
 #
@@ -107,7 +122,10 @@ if (TINYGLTF_INSTALL)
 
   INSTALL ( FILES
     tiny_gltf.h
+    tiny_gltf_v3.h
+    tiny_gltf_v3.c
     tinygltf_json.h
+    tinygltf_json_c.h
     ${TINYGLTF_EXTRA_SOUECES}
     DESTINATION
     include
diff --git a/README.md b/README.md
index ff347e0..b253f03 100644
--- a/README.md
+++ b/README.md
@@ -21,28 +21,36 @@ v3 is a ground-up rewrite with a C-centric, low-overhead design:
 
 ### Quick start (v3)
 
-Copy `tiny_gltf_v3.h` and `tinygltf_json.h` to your project. In **one** `.cpp` file:
+Copy `tiny_gltf_v3.h`, `tiny_gltf_v3.c`, and `tinygltf_json_c.h` to your project.
+Compile `tiny_gltf_v3.c` as C11 or newer. Define `TINYGLTF3_ENABLE_FS` when
+building `tiny_gltf_v3.c` if you want `tg3_parse_file()` to use stdio-backed
+filesystem helpers. The legacy `TINYGLTF3_IMPLEMENTATION` include path remains
+available for compatibility.
 
-```cpp
-#define TINYGLTF3_IMPLEMENTATION
-#define TINYGLTF3_ENABLE_FS          // enable file I/O
-#define TINYGLTF3_ENABLE_STB_IMAGE   // enable image decoding
+```c
 #include "tiny_gltf_v3.h"
 ```
 
 Loading a glTF file:
 
 ```c
-tg3_load_options_t opts = tg3_load_options_default();
-tg3_error_stack_t errors = {0};
-tg3_model_t *model = tg3_load_from_file("scene.gltf", &opts, &errors);
-if (!model) {
-    for (int i = 0; i < errors.count; i++)
-        fprintf(stderr, "[%s] %s\n", tg3_severity_str(errors.items[i].severity),
-                errors.items[i].message);
+tg3_parse_options opts;
+tg3_error_stack errors;
+tg3_model model;
+
+tg3_parse_options_init(&opts);
+tg3_error_stack_init(&errors);
+
+tg3_error_code err = tg3_parse_file(&model, &errors, "scene.gltf", 10, &opts);
+if (err != TG3_OK) {
+    for (uint32_t i = 0; i < errors.count; i++) {
+        fprintf(stderr, "[%d] %s\n", (int)errors.entries[i].severity,
+                errors.entries[i].message ? errors.entries[i].message : "(null)");
+    }
 }
 // ... use model ...
-tg3_model_free(model);
+tg3_model_free(&model);
+tg3_error_stack_free(&errors);
 ```
 
 ## Status
diff --git a/benchmark/Makefile b/benchmark/Makefile
index 928cdc9..e4b8fc4 100644
--- a/benchmark/Makefile
+++ b/benchmark/Makefile
@@ -28,7 +28,7 @@ all: $(GEN) $(BENCH_V3)
 $(GEN): gen_synthetic.cpp
 	$(CXX) $(CXXFLAGS) -o $@ $<
 
-$(BENCH_V3): bench_v3.cpp ../tiny_gltf_v3.h ../tinygltf_json.h
+$(BENCH_V3): bench_v3.cpp ../tiny_gltf_v3.h ../tiny_gltf_v3.c ../tinygltf_json_c.h
 	$(CXX) $(CXXFLAGS) $(INCLUDES) -o $@ $<
 
 # Generate synthetic scenes of varying sizes
diff --git a/tests/tester_v3_c.c b/tests/tester_v3_c.c
new file mode 100644
index 0000000..cf58227
--- /dev/null
+++ b/tests/tester_v3_c.c
@@ -0,0 +1,140 @@
+#include "tiny_gltf_v3.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static int mem_contains(const uint8_t *data, uint64_t size, const char *needle) {
+  size_t needle_len = strlen(needle);
+  uint64_t i;
+  if (needle_len == 0 || size < (uint64_t)needle_len) {
+    return 0;
+  }
+  for (i = 0; i + (uint64_t)needle_len <= size; ++i) {
+    if (memcmp(data + i, needle, needle_len) == 0) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static int check_minimal_parse(void) {
+  static const uint8_t json[] =
+      "{\"asset\":{\"version\":\"2.0\"},"
+      "\"scene\":0,"
+      "\"scenes\":[{\"nodes\":[0]}],"
+      "\"nodes\":[{\"name\":\"root\"}]}";
+  tg3_model model;
+  tg3_error_stack errors;
+  tg3_parse_options opts;
+  tg3_error_code err;
+
+  tg3_error_stack_init(&errors);
+  tg3_parse_options_init(&opts);
+
+  err = tg3_parse_auto(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
+                       &opts);
+  if (err != TG3_OK) {
+    fprintf(stderr, "tg3_parse_auto failed: %d\n", (int)err);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  if (model.default_scene != 0 || model.scenes_count != 1 || model.nodes_count != 1) {
+    fprintf(stderr, "unexpected parsed model shape\n");
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  if (!model.nodes || !model.nodes[0].name.data ||
+      !tg3_str_equals_cstr(model.nodes[0].name, "root")) {
+    fprintf(stderr, "node name mismatch\n");
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  tg3_model_free(&model);
+  tg3_error_stack_free(&errors);
+  return 1;
+}
+
+static int check_minimal_write_roundtrip(void) {
+  static const uint8_t json[] =
+      "{\"asset\":{\"version\":\"2.0\"},"
+      "\"scene\":0,"
+      "\"scenes\":[{\"nodes\":[0]}],"
+      "\"nodes\":[{\"name\":\"root\"}]}";
+  tg3_model model;
+  tg3_model roundtrip;
+  tg3_error_stack errors;
+  tg3_parse_options parse_opts;
+  tg3_write_options write_opts;
+  tg3_error_code err;
+  uint8_t *out = NULL;
+  uint64_t out_size = 0;
+
+  tg3_error_stack_init(&errors);
+  tg3_parse_options_init(&parse_opts);
+  tg3_write_options_init(&write_opts);
+
+  err = tg3_parse_auto(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
+                       &parse_opts);
+  if (err != TG3_OK) {
+    fprintf(stderr, "initial parse failed: %d\n", (int)err);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  err = tg3_write_to_memory(&model, &errors, &out, &out_size, &write_opts);
+  if (err != TG3_OK || !out || out_size == 0) {
+    fprintf(stderr, "tg3_write_to_memory failed: %d\n", (int)err);
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  if (!mem_contains(out, out_size, "\"asset\"") ||
+      !mem_contains(out, out_size, "\"root\"")) {
+    fprintf(stderr, "serialized JSON missing expected fields\n");
+    tg3_write_free(out, &write_opts);
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  err = tg3_parse_auto(&roundtrip, &errors, out, out_size, "", 0, &parse_opts);
+  tg3_write_free(out, &write_opts);
+  if (err != TG3_OK) {
+    fprintf(stderr, "roundtrip parse failed: %d\n", (int)err);
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  if (roundtrip.default_scene != 0 || roundtrip.nodes_count != 1 ||
+      !roundtrip.nodes || !roundtrip.nodes[0].name.data ||
+      !tg3_str_equals_cstr(roundtrip.nodes[0].name, "root")) {
+    fprintf(stderr, "roundtrip model mismatch\n");
+    tg3_model_free(&roundtrip);
+    tg3_model_free(&model);
+    tg3_error_stack_free(&errors);
+    return 0;
+  }
+
+  tg3_model_free(&roundtrip);
+  tg3_model_free(&model);
+  tg3_error_stack_free(&errors);
+  return 1;
+}
+
+int main(void) {
+  if (!check_minimal_parse()) {
+    return 1;
+  }
+  if (!check_minimal_write_roundtrip()) {
+    return 1;
+  }
+  return 0;
+}
diff --git a/tests/v3/fuzzer/Makefile b/tests/v3/fuzzer/Makefile
index 086b428..33ae7d7 100644
--- a/tests/v3/fuzzer/Makefile
+++ b/tests/v3/fuzzer/Makefile
@@ -26,7 +26,7 @@ MAX_TIME  ?= 0
 
 all: $(FUZZER)
 
-$(FUZZER): fuzz_gltf_v3.cc ../../../tiny_gltf_v3.h ../../../tinygltf_json.h
+$(FUZZER): fuzz_gltf_v3.cc ../../../tiny_gltf_v3.h ../../../tiny_gltf_v3.c ../../../tinygltf_json_c.h
 	$(CXX) $(CXXFLAGS) $(SANITIZE) $(INCLUDES) -o $@ $<
 
 run: $(FUZZER) | $(CORPUS) $(ARTIFACTS)
diff --git a/tiny_gltf_v3.c b/tiny_gltf_v3.c
new file mode 100644
index 0000000..4c97144
--- /dev/null
+++ b/tiny_gltf_v3.c
@@ -0,0 +1,2939 @@
+#ifndef TINYGLTF3_SOURCE_INCLUDED_FROM_HEADER
+#include "tiny_gltf_v3.h"
+#endif
+#define TINYGLTF_JSON_C_IMPLEMENTATION
+#include "tinygltf_json_c.h"
+
+#include <inttypes.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TG3__ARENA_DEFAULT_BLOCK_SIZE (256u * 1024u)
+#define TG3__ARENA_ALIGNMENT 8u
+
+typedef struct tg3__arena_block {
+    struct tg3__arena_block *next;
+    uint8_t *base;
+    size_t used;
+    size_t capacity;
+} tg3__arena_block;
+
+typedef struct tg3_arena tg3_arena;
+
+struct tg3_arena {
+    tg3__arena_block *head;
+    tg3__arena_block *current;
+    size_t total_allocated;
+    size_t memory_budget;
+    size_t max_single_alloc;
+    size_t block_size;
+    tg3_allocator alloc;
+};
+
+typedef struct tg3__parse_ctx {
+    tg3_arena *arena;
+    tg3_error_stack *errors;
+    tg3_parse_options opts;
+    const char *base_dir;
+    uint32_t base_dir_len;
+    const uint8_t *bin_data;
+    uint64_t bin_size;
+    int32_t is_binary;
+} tg3__parse_ctx;
+
+struct tg3_writer {
+    tg3_write_chunk_fn chunk_fn;
+    void *user_data;
+    tg3_write_options options;
+    tg3json_value root;
+    int begun;
+};
+
+static void *tg3__default_alloc(size_t size, void *ud) {
+    (void)ud;
+    return malloc(size);
+}
+
+static void *tg3__default_realloc(void *ptr, size_t old_size, size_t new_size, void *ud) {
+    (void)old_size;
+    (void)ud;
+    return realloc(ptr, new_size);
+}
+
+static void tg3__default_free(void *ptr, size_t size, void *ud) {
+    (void)size;
+    (void)ud;
+    free(ptr);
+}
+
+static tg3_arena *tg3__arena_create(const tg3_memory_config *config) {
+    tg3_allocator alloc;
+    tg3_arena *arena;
+    if (config && config->allocator.alloc) {
+        alloc = config->allocator;
+    } else {
+        alloc.alloc = tg3__default_alloc;
+        alloc.realloc = tg3__default_realloc;
+        alloc.free = tg3__default_free;
+        alloc.user_data = NULL;
+    }
+
+    arena = (tg3_arena *)alloc.alloc(sizeof(tg3_arena), alloc.user_data);
+    if (!arena) return NULL;
+    memset(arena, 0, sizeof(*arena));
+    arena->alloc = alloc;
+    arena->block_size = (config && config->arena_block_size > 0)
+                            ? (size_t)config->arena_block_size
+                            : (size_t)TG3__ARENA_DEFAULT_BLOCK_SIZE;
+    arena->memory_budget = (config && config->memory_budget > 0)
+                               ? (size_t)config->memory_budget
+                               : (size_t)TINYGLTF3_MAX_MEMORY_BYTES;
+    arena->max_single_alloc = (config && config->max_single_alloc > 0)
+                                  ? (size_t)config->max_single_alloc
+                                  : 0;
+    return arena;
+}
+
+static tg3__arena_block *tg3__arena_new_block(tg3_arena *arena, size_t min_size) {
+    size_t cap = arena->block_size;
+    uint8_t *raw;
+    tg3__arena_block *block;
+    if (cap < min_size) cap = min_size;
+    if (arena->max_single_alloc && cap > arena->max_single_alloc) return NULL;
+    if (arena->total_allocated + sizeof(tg3__arena_block) + cap > arena->memory_budget) return NULL;
+
+    raw = (uint8_t *)arena->alloc.alloc(sizeof(tg3__arena_block) + cap, arena->alloc.user_data);
+    if (!raw) return NULL;
+    block = (tg3__arena_block *)raw;
+    block->next = NULL;
+    block->base = raw + sizeof(tg3__arena_block);
+    block->used = 0;
+    block->capacity = cap;
+    arena->total_allocated += sizeof(tg3__arena_block) + cap;
+
+    if (arena->current) arena->current->next = block;
+    else arena->head = block;
+    arena->current = block;
+    return block;
+}
+
+static void *tg3__arena_alloc(tg3_arena *arena, size_t size) {
+    tg3__arena_block *block;
+    void *ptr;
+    if (!arena || size == 0) return NULL;
+    if (arena->max_single_alloc && size > arena->max_single_alloc) return NULL;
+    size = (size + (TG3__ARENA_ALIGNMENT - 1u)) & ~(size_t)(TG3__ARENA_ALIGNMENT - 1u);
+    block = arena->current;
+    if (!block || (block->used + size > block->capacity)) {
+        block = tg3__arena_new_block(arena, size);
+        if (!block) return NULL;
+    }
+    ptr = block->base + block->used;
+    block->used += size;
+    return ptr;
+}
+
+static char *tg3__arena_strdup(tg3_arena *arena, const char *s, size_t len) {
+    char *dst;
+    if (!s) return NULL;
+    dst = (char *)tg3__arena_alloc(arena, len + 1);
+    if (!dst) return NULL;
+    if (len > 0) memcpy(dst, s, len);
+    dst[len] = '\0';
+    return dst;
+}
+
+static tg3_str tg3__arena_str(tg3_arena *arena, const char *s, uint32_t len) {
+    tg3_str out;
+    out.data = tg3__arena_strdup(arena, s, len);
+    out.len = out.data ? len : 0;
+    return out;
+}
+
+static void tg3__arena_destroy(tg3_arena *arena) {
+    tg3_allocator alloc;
+    tg3__arena_block *block;
+    if (!arena) return;
+    alloc = arena->alloc;
+    block = arena->head;
+    while (block) {
+        tg3__arena_block *next = block->next;
+        alloc.free(block, sizeof(tg3__arena_block) + block->capacity, alloc.user_data);
+        block = next;
+    }
+    alloc.free(arena, sizeof(*arena), alloc.user_data);
+}
+
+static void tg3__error_push(tg3_error_stack *es, tg3_severity sev,
+                            tg3_error_code code, const char *msg,
+                            const char *json_path, int64_t byte_offset) {
+    tg3_error_entry *entry;
+    tg3_error_entry *new_entries;
+    uint32_t new_cap;
+    if (!es) return;
+    if (es->count >= es->capacity) {
+        new_cap = es->capacity ? es->capacity * 2u : 16u;
+        new_entries = (tg3_error_entry *)realloc(es->entries, new_cap * sizeof(tg3_error_entry));
+        if (!new_entries) return;
+        es->entries = new_entries;
+        es->capacity = new_cap;
+    }
+    entry = &es->entries[es->count++];
+    entry->severity = sev;
+    entry->code = code;
+    entry->message = msg;
+    entry->json_path = json_path;
+    entry->byte_offset = byte_offset;
+    if (sev == TG3_SEVERITY_ERROR) es->has_error = 1;
+}
+
+static void tg3__error_pushf(tg3_error_stack *es, tg3_arena *arena,
+                             tg3_severity sev, tg3_error_code code,
+                             const char *json_path, const char *fmt, ...) {
+    char buf[1024];
+    int n;
+    va_list ap;
+    const char *msg = buf;
+    if (!es) return;
+    va_start(ap, fmt);
+    n = vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    if (n < 0) n = 0;
+    if ((size_t)n >= sizeof(buf)) n = (int)(sizeof(buf) - 1u);
+    if (arena) {
+        char *dup = tg3__arena_strdup(arena, buf, (size_t)n);
+        if (dup) msg = dup;
+    }
+    tg3__error_push(es, sev, code, msg, json_path, -1);
+}
+
+TINYGLTF3_API int32_t tg3_errors_has_error(const tg3_error_stack *es) { return es ? es->has_error : 0; }
+TINYGLTF3_API uint32_t tg3_errors_count(const tg3_error_stack *es) { return es ? es->count : 0; }
+TINYGLTF3_API const tg3_error_entry *tg3_errors_get(const tg3_error_stack *es, uint32_t index) {
+    if (!es || index >= es->count) return NULL;
+    return &es->entries[index];
+}
+TINYGLTF3_API void tg3_error_stack_init(tg3_error_stack *es) { if (es) memset(es, 0, sizeof(*es)); }
+TINYGLTF3_API void tg3_error_stack_free(tg3_error_stack *es) {
+    if (!es) return;
+    free(es->entries);
+    memset(es, 0, sizeof(*es));
+}
+
+TINYGLTF3_API void tg3_parse_options_init(tg3_parse_options *options) {
+    if (!options) return;
+    memset(options, 0, sizeof(*options));
+    options->required_sections = TG3_REQUIRE_VERSION;
+    options->strictness = TG3_PERMISSIVE;
+    options->memory.memory_budget = TINYGLTF3_MAX_MEMORY_BYTES;
+    options->memory.arena_block_size = TG3__ARENA_DEFAULT_BLOCK_SIZE;
+    options->max_external_file_size = 0;
+}
+
+TINYGLTF3_API void tg3_write_options_init(tg3_write_options *options) {
+    if (!options) return;
+    memset(options, 0, sizeof(*options));
+    options->pretty_print = 1;
+    options->memory.memory_budget = TINYGLTF3_MAX_MEMORY_BYTES;
+    options->memory.arena_block_size = TG3__ARENA_DEFAULT_BLOCK_SIZE;
+}
+
+TINYGLTF3_API int32_t tg3_component_size(int32_t component_type) {
+    switch (component_type) {
+        case TG3_COMPONENT_TYPE_BYTE:
+        case TG3_COMPONENT_TYPE_UNSIGNED_BYTE: return 1;
+        case TG3_COMPONENT_TYPE_SHORT:
+        case TG3_COMPONENT_TYPE_UNSIGNED_SHORT: return 2;
+        case TG3_COMPONENT_TYPE_INT:
+        case TG3_COMPONENT_TYPE_UNSIGNED_INT:
+        case TG3_COMPONENT_TYPE_FLOAT: return 4;
+        case TG3_COMPONENT_TYPE_DOUBLE: return 8;
+        default: return -1;
+    }
+}
+
+TINYGLTF3_API int32_t tg3_num_components(int32_t type) {
+    switch (type) {
+        case TG3_TYPE_SCALAR: return 1;
+        case TG3_TYPE_VEC2: return 2;
+        case TG3_TYPE_VEC3: return 3;
+        case TG3_TYPE_VEC4: return 4;
+        case TG3_TYPE_MAT2: return 4;
+        case TG3_TYPE_MAT3: return 9;
+        case TG3_TYPE_MAT4: return 16;
+        default: return -1;
+    }
+}
+
+TINYGLTF3_API int32_t tg3_accessor_byte_stride(const tg3_accessor *accessor, const tg3_buffer_view *bv) {
+    int32_t comp;
+    int32_t num;
+    if (bv && bv->byte_stride > 0) return (int32_t)bv->byte_stride;
+    comp = tg3_component_size(accessor->component_type);
+    num = tg3_num_components(accessor->type);
+    if (comp < 0 || num < 0) return -1;
+    return comp * num;
+}
+
+TINYGLTF3_API int32_t tg3_str_equals(tg3_str a, tg3_str b) {
+    if (a.len != b.len) return 0;
+    if (a.len == 0) return 1;
+    return memcmp(a.data, b.data, a.len) == 0 ? 1 : 0;
+}
+
+TINYGLTF3_API int32_t tg3_str_equals_cstr(tg3_str a, const char *b) {
+    uint32_t blen;
+    if (!b) return a.len == 0 ? 1 : 0;
+    blen = (uint32_t)strlen(b);
+    if (a.len != blen) return 0;
+    if (a.len == 0) return 1;
+    return memcmp(a.data, b, a.len) == 0 ? 1 : 0;
+}
+
+static int tg3__b64_decode_char(unsigned char c) {
+    if (c >= 'A' && c <= 'Z') return c - 'A';
+    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+    if (c >= '0' && c <= '9') return c - '0' + 52;
+    if (c == '+') return 62;
+    if (c == '/') return 63;
+    return -1;
+}
+
+static uint8_t *tg3__b64_decode(const char *input, size_t input_len, size_t *out_len, tg3_arena *arena) {
+    uint8_t *out;
+    size_t decoded_len;
+    size_t i;
+    size_t j = 0;
+    uint32_t accum = 0;
+    int bits = 0;
+    if (input_len == 0) {
+        *out_len = 0;
+        return NULL;
+    }
+    while (input_len > 0 && input[input_len - 1] == '=') --input_len;
+    decoded_len = (input_len * 3u) / 4u;
+    out = (uint8_t *)tg3__arena_alloc(arena, decoded_len + 1u);
+    if (!out) {
+        *out_len = 0;
+        return NULL;
+    }
+    for (i = 0; i < input_len; ++i) {
+        int val = tg3__b64_decode_char((unsigned char)input[i]);
+        if (val < 0) continue;
+        accum = (accum << 6) | (uint32_t)val;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[j++] = (uint8_t)((accum >> bits) & 0xFFu);
+        }
+    }
+    *out_len = j;
+    return out;
+}
+
+TINYGLTF3_API int32_t tg3_is_data_uri(const char *uri, uint32_t len) {
+    return (uri && len >= 5u && memcmp(uri, "data:", 5) == 0) ? 1 : 0;
+}
+
+typedef struct tg3__data_uri_result {
+    const char *data_start;
+    size_t data_len;
+    char mime_type[64];
+} tg3__data_uri_result;
+
+static int tg3__parse_data_uri(const char *uri, uint32_t uri_len, tg3__data_uri_result *result) {
+    const char *p;
+    const char *end;
+    const char *semi;
+    size_t mime_len;
+    if (!uri || uri_len < 5u || memcmp(uri, "data:", 5) != 0) return 0;
+    p = uri + 5;
+    end = uri + uri_len;
+    semi = p;
+    while (semi < end && *semi != ';') ++semi;
+    if (semi >= end) return 0;
+    mime_len = (size_t)(semi - p);
+    if (mime_len >= sizeof(result->mime_type)) mime_len = sizeof(result->mime_type) - 1u;
+    memcpy(result->mime_type, p, mime_len);
+    result->mime_type[mime_len] = '\0';
+    p = semi + 1;
+    if ((size_t)(end - p) < 7u || memcmp(p, "base64,", 7) != 0) return 0;
+    p += 7;
+    result->data_start = p;
+    result->data_len = (size_t)(end - p);
+    return 1;
+}
+
+static uint8_t *tg3__decode_data_uri(tg3_arena *arena, const char *uri, uint32_t uri_len,
+                                     size_t *out_len, char *out_mime, size_t out_mime_cap) {
+    tg3__data_uri_result dr;
+    size_t mlen;
+    if (!tg3__parse_data_uri(uri, uri_len, &dr)) {
+        *out_len = 0;
+        return NULL;
+    }
+    if (out_mime && out_mime_cap > 0) {
+        mlen = strlen(dr.mime_type);
+        if (mlen >= out_mime_cap) mlen = out_mime_cap - 1u;
+        memcpy(out_mime, dr.mime_type, mlen);
+        out_mime[mlen] = '\0';
+    }
+    return tg3__b64_decode(dr.data_start, dr.data_len, out_len, arena);
+}
+
+#ifdef TINYGLTF3_ENABLE_FS
+static int32_t tg3__fs_file_exists(const char *path, uint32_t path_len, void *ud) {
+    FILE *fp;
+    (void)path_len; (void)ud;
+    fp = fopen(path, "rb");
+    if (!fp) return 0;
+    fclose(fp);
+    return 1;
+}
+
+static int32_t tg3__fs_read_file(uint8_t **out_data, uint64_t *out_size,
+                                 const char *path, uint32_t path_len, void *ud) {
+    FILE *fp;
+    long size;
+    uint8_t *data;
+    size_t nread;
+    (void)path_len; (void)ud;
+    *out_data = NULL;
+    *out_size = 0;
+    fp = fopen(path, "rb");
+    if (!fp) return 0;
+    if (fseek(fp, 0, SEEK_END) != 0) { fclose(fp); return 0; }
+    size = ftell(fp);
+    if (size < 0) { fclose(fp); return 0; }
+    if (fseek(fp, 0, SEEK_SET) != 0) { fclose(fp); return 0; }
+    data = (uint8_t *)malloc((size_t)size);
+    if (!data) { fclose(fp); return 0; }
+    nread = fread(data, 1, (size_t)size, fp);
+    fclose(fp);
+    if (nread != (size_t)size) { free(data); return 0; }
+    *out_data = data;
+    *out_size = (uint64_t)size;
+    return 1;
+}
+
+static void tg3__fs_free_file(uint8_t *data, uint64_t size, void *ud) {
+    (void)size; (void)ud; free(data);
+}
+
+static int32_t tg3__fs_write_file(const char *path, uint32_t path_len,
+                                  const uint8_t *data, uint64_t size, void *ud) {
+    FILE *fp;
+    size_t nwritten;
+    (void)path_len; (void)ud;
+    fp = fopen(path, "wb");
+    if (!fp) return 0;
+    nwritten = fwrite(data, 1, (size_t)size, fp);
+    fclose(fp);
+    return nwritten == (size_t)size ? 1 : 0;
+}
+
+static void tg3__set_default_fs(tg3_fs_callbacks *fs) {
+    if (!fs->read_file) fs->read_file = tg3__fs_read_file;
+    if (!fs->free_file) fs->free_file = tg3__fs_free_file;
+    if (!fs->file_exists) fs->file_exists = tg3__fs_file_exists;
+    if (!fs->write_file) fs->write_file = tg3__fs_write_file;
+}
+#endif
+
+static void tg3__model_init(tg3_model *model) {
+    memset(model, 0, sizeof(*model));
+    model->default_scene = -1;
+}
+
+static int tg3__json_is_number(const tg3json_value *v) {
+    return v && (v->type == TG3JSON_INT || v->type == TG3JSON_REAL);
+}
+
+static int tg3__json_is_object(const tg3json_value *v) { return v && v->type == TG3JSON_OBJECT; }
+static int tg3__json_is_array(const tg3json_value *v) { return v && v->type == TG3JSON_ARRAY; }
+
+static int tg3__json_has(const tg3json_value *o, const char *key) {
+    return tg3json_object_get(o, key) ? 1 : 0;
+}
+
+static const tg3json_value *tg3__json_get(const tg3json_value *o, const char *key) {
+    return tg3json_object_get(o, key);
+}
+
+static int tg3__parse_string(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                             tg3_str *out, int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        out->data = NULL;
+        out->len = 0;
+        return 1;
+    }
+    if (it->type != TG3JSON_STRING) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be a string", key);
+        return 0;
+    }
+    *out = tg3__arena_str(ctx->arena, it->u.string.ptr, (uint32_t)it->u.string.len);
+    return out->data != NULL || it->u.string.len == 0;
+}
+
+static int tg3__parse_int(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                          int32_t *out, int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    int64_t v;
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        return 1;
+    }
+    if (!tg3__json_is_number(it)) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be a number", key);
+        return 0;
+    }
+    v = (it->type == TG3JSON_INT) ? it->u.integer : (int64_t)it->u.real;
+    if (v < INT32_MIN || v > INT32_MAX) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' value %" PRId64 " is out of range for int32", key, v);
+        return 0;
+    }
+    *out = (int32_t)v;
+    return 1;
+}
+
+static int tg3__parse_uint64(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                             uint64_t *out, int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        return 1;
+    }
+    if (!tg3__json_is_number(it)) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be a number", key);
+        return 0;
+    }
+    if (it->type == TG3JSON_INT) *out = it->u.integer >= 0 ? (uint64_t)it->u.integer : 0u;
+    else *out = it->u.real >= 0.0 ? (uint64_t)it->u.real : 0u;
+    return 1;
+}
+
+static int tg3__parse_double(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                             double *out, int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        return 1;
+    }
+    if (!tg3__json_is_number(it)) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be a number", key);
+        return 0;
+    }
+    *out = (it->type == TG3JSON_INT) ? (double)it->u.integer : it->u.real;
+    return 1;
+}
+
+static int tg3__parse_bool(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                           int32_t *out, int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        return 1;
+    }
+    if (it->type != TG3JSON_BOOL) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be a boolean", key);
+        return 0;
+    }
+    *out = it->u.boolean ? 1 : 0;
+    return 1;
+}
+
+static int tg3__parse_number_array(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                                   const double **out, uint32_t *out_count,
+                                   int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    size_t count;
+    size_t i;
+    double *arr;
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    if (!tg3__json_is_array(it)) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be an array", key);
+        return 0;
+    }
+    count = tg3json_array_size(it);
+    if (count == 0) {
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    arr = (double *)tg3__arena_alloc(ctx->arena, count * sizeof(double));
+    if (!arr) {
+        tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                        "OOM allocating number array", parent, -1);
+        return 0;
+    }
+    for (i = 0; i < count; ++i) {
+        const tg3json_value *item = tg3json_array_get(it, i);
+        arr[i] = (item && item->type == TG3JSON_REAL) ? item->u.real : (item ? (double)item->u.integer : 0.0);
+    }
+    *out = arr;
+    *out_count = (uint32_t)count;
+    return 1;
+}
+
+static int tg3__parse_int_array(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                                const int32_t **out, uint32_t *out_count,
+                                int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    size_t count;
+    size_t i;
+    int32_t *arr;
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    if (!tg3__json_is_array(it)) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH,
+                         parent, "Field '%s' must be an array", key);
+        return 0;
+    }
+    count = tg3json_array_size(it);
+    if (count == 0) {
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    arr = (int32_t *)tg3__arena_alloc(ctx->arena, count * sizeof(int32_t));
+    if (!arr) {
+        tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                        "OOM allocating int array", parent, -1);
+        return 0;
+    }
+    for (i = 0; i < count; ++i) {
+        const tg3json_value *item = tg3json_array_get(it, i);
+        arr[i] = item ? (int32_t)((item->type == TG3JSON_REAL) ? item->u.real : item->u.integer) : 0;
+    }
+    *out = arr;
+    *out_count = (uint32_t)count;
+    return 1;
+}
+
+static void tg3__parse_number_to_fixed(const tg3json_value *o, const char *key,
+                                       double *out, uint32_t max_count) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    size_t count;
+    size_t i;
+    if (!tg3__json_is_array(it)) return;
+    count = tg3json_array_size(it);
+    if (count > max_count) count = max_count;
+    for (i = 0; i < count; ++i) {
+        const tg3json_value *item = tg3json_array_get(it, i);
+        if (!item) continue;
+        out[i] = (item->type == TG3JSON_REAL) ? item->u.real : (double)item->u.integer;
+    }
+}
+
+static int tg3__parse_string_array(tg3__parse_ctx *ctx, const tg3json_value *o, const char *key,
+                                   const tg3_str **out, uint32_t *out_count,
+                                   int required, const char *parent) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    size_t count;
+    size_t i;
+    tg3_str *arr;
+    if (!it) {
+        if (required) {
+            tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_MISSING_FIELD,
+                             parent, "Missing required field '%s'", key);
+            return 0;
+        }
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    if (!tg3__json_is_array(it)) return 0;
+    count = tg3json_array_size(it);
+    if (count == 0) {
+        *out = NULL;
+        *out_count = 0;
+        return 1;
+    }
+    arr = (tg3_str *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_str));
+    if (!arr) return 0;
+    for (i = 0; i < count; ++i) {
+        const tg3json_value *item = tg3json_array_get(it, i);
+        if (!item || item->type != TG3JSON_STRING) {
+            arr[i].data = NULL;
+            arr[i].len = 0;
+            continue;
+        }
+        arr[i] = tg3__arena_str(ctx->arena, item->u.string.ptr, (uint32_t)item->u.string.len);
+    }
+    *out = arr;
+    *out_count = (uint32_t)count;
+    return 1;
+}
+
+static tg3_value tg3__json_to_value(tg3__parse_ctx *ctx, const tg3json_value *j) {
+    tg3_value v;
+    size_t i;
+    memset(&v, 0, sizeof(v));
+    if (!j) return v;
+    switch (j->type) {
+        case TG3JSON_NULL:
+            v.type = TG3_VALUE_NULL;
+            break;
+        case TG3JSON_BOOL:
+            v.type = TG3_VALUE_BOOL;
+            v.bool_val = j->u.boolean ? 1 : 0;
+            break;
+        case TG3JSON_INT:
+            v.type = TG3_VALUE_INT;
+            v.int_val = j->u.integer;
+            break;
+        case TG3JSON_REAL:
+            v.type = TG3_VALUE_REAL;
+            v.real_val = j->u.real;
+            break;
+        case TG3JSON_STRING:
+            v.type = TG3_VALUE_STRING;
+            v.string_val = tg3__arena_str(ctx->arena, j->u.string.ptr, (uint32_t)j->u.string.len);
+            break;
+        case TG3JSON_ARRAY:
+            v.type = TG3_VALUE_ARRAY;
+            if (j->u.array.count > 0) {
+                tg3_value *arr = (tg3_value *)tg3__arena_alloc(ctx->arena, j->u.array.count * sizeof(tg3_value));
+                if (arr) {
+                    for (i = 0; i < j->u.array.count; ++i) arr[i] = tg3__json_to_value(ctx, &j->u.array.items[i]);
+                    v.array_data = arr;
+                    v.array_count = (uint32_t)j->u.array.count;
+                }
+            }
+            break;
+        case TG3JSON_OBJECT:
+            v.type = TG3_VALUE_OBJECT;
+            if (j->u.object.count > 0) {
+                tg3_kv_pair *pairs = (tg3_kv_pair *)tg3__arena_alloc(ctx->arena, j->u.object.count * sizeof(tg3_kv_pair));
+                if (pairs) {
+                    for (i = 0; i < j->u.object.count; ++i) {
+                        pairs[i].key = tg3__arena_str(ctx->arena, j->u.object.items[i].key,
+                                                      (uint32_t)j->u.object.items[i].key_len);
+                        pairs[i].value = tg3__json_to_value(ctx, j->u.object.items[i].value);
+                    }
+                    v.object_data = pairs;
+                    v.object_count = (uint32_t)j->u.object.count;
+                }
+            }
+            break;
+    }
+    return v;
+}
+
+static void tg3__parse_extras_and_extensions(tg3__parse_ctx *ctx, const tg3json_value *o,
+                                             tg3_extras_ext *ee) {
+    const tg3json_value *extras_it;
+    const tg3json_value *ext_it;
+    memset(ee, 0, sizeof(*ee));
+    extras_it = tg3__json_get(o, "extras");
+    if (extras_it) {
+        tg3_value *ev = (tg3_value *)tg3__arena_alloc(ctx->arena, sizeof(tg3_value));
+        if (ev) {
+            *ev = tg3__json_to_value(ctx, extras_it);
+            ee->extras = ev;
+        }
+        if (ctx->opts.store_original_json) {
+            size_t raw_len = 0;
+            char *raw = tg3json_stringify(extras_it, &raw_len);
+            if (raw) {
+                ee->extras_json = tg3__arena_str(ctx->arena, raw, (uint32_t)raw_len);
+                free(raw);
+            }
+        }
+    }
+    ext_it = tg3__json_get(o, "extensions");
+    if (tg3__json_is_object(ext_it)) {
+        size_t count = tg3json_object_size(ext_it);
+        size_t i;
+        if (count > 0) {
+            tg3_extension *exts = (tg3_extension *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_extension));
+            if (exts) {
+                for (i = 0; i < count; ++i) {
+                    const tg3json_object_entry *entry = tg3json_object_at(ext_it, i);
+                    exts[i].name = tg3__arena_str(ctx->arena, entry->key, (uint32_t)entry->key_len);
+                    exts[i].value = tg3__json_to_value(ctx, entry->value);
+                }
+                ee->extensions = exts;
+                ee->extensions_count = (uint32_t)count;
+            }
+        }
+        if (ctx->opts.store_original_json) {
+            size_t raw_len = 0;
+            char *raw = tg3json_stringify(ext_it, &raw_len);
+            if (raw) {
+                ee->extensions_json = tg3__arena_str(ctx->arena, raw, (uint32_t)raw_len);
+                free(raw);
+            }
+        }
+    }
+}
+
+static void tg3__init_texture_info(tg3_texture_info *ti) { memset(ti, 0, sizeof(*ti)); ti->index = -1; }
+static void tg3__init_normal_texture_info(tg3_normal_texture_info *ti) { memset(ti, 0, sizeof(*ti)); ti->index = -1; ti->scale = 1.0; }
+static void tg3__init_occlusion_texture_info(tg3_occlusion_texture_info *ti) { memset(ti, 0, sizeof(*ti)); ti->index = -1; ti->strength = 1.0; }
+static void tg3__init_pbr(tg3_pbr_metallic_roughness *pbr) {
+    memset(pbr, 0, sizeof(*pbr));
+    pbr->base_color_factor[0] = 1.0; pbr->base_color_factor[1] = 1.0;
+    pbr->base_color_factor[2] = 1.0; pbr->base_color_factor[3] = 1.0;
+    pbr->metallic_factor = 1.0; pbr->roughness_factor = 1.0;
+    tg3__init_texture_info(&pbr->base_color_texture);
+    tg3__init_texture_info(&pbr->metallic_roughness_texture);
+}
+static void tg3__init_node(tg3_node *n) {
+    memset(n, 0, sizeof(*n));
+    n->camera = -1; n->skin = -1; n->mesh = -1; n->light = -1; n->emitter = -1;
+    n->rotation[3] = 1.0; n->scale[0] = 1.0; n->scale[1] = 1.0; n->scale[2] = 1.0;
+    n->matrix[0] = 1.0; n->matrix[5] = 1.0; n->matrix[10] = 1.0; n->matrix[15] = 1.0;
+}
+
+static int tg3__parse_asset(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_asset *asset) {
+    memset(asset, 0, sizeof(*asset));
+    tg3__parse_string(ctx, o, "version", &asset->version, 0, "/asset");
+    tg3__parse_string(ctx, o, "generator", &asset->generator, 0, "/asset");
+    tg3__parse_string(ctx, o, "minVersion", &asset->min_version, 0, "/asset");
+    tg3__parse_string(ctx, o, "copyright", &asset->copyright, 0, "/asset");
+    tg3__parse_extras_and_extensions(ctx, o, &asset->ext);
+    return 1;
+}
+
+static int tg3__parse_texture_info(tg3__parse_ctx *ctx, const tg3json_value *o,
+                                   const char *key, tg3_texture_info *ti) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    tg3__init_texture_info(ti);
+    if (!it) return 1;
+    if (!tg3__json_is_object(it)) return 0;
+    tg3__parse_int(ctx, it, "index", &ti->index, 0, key);
+    tg3__parse_int(ctx, it, "texCoord", &ti->tex_coord, 0, key);
+    tg3__parse_extras_and_extensions(ctx, it, &ti->ext);
+    return 1;
+}
+
+static int tg3__parse_normal_texture_info(tg3__parse_ctx *ctx, const tg3json_value *o,
+                                          const char *key, tg3_normal_texture_info *ti) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    tg3__init_normal_texture_info(ti);
+    if (!it) return 1;
+    if (!tg3__json_is_object(it)) return 0;
+    tg3__parse_int(ctx, it, "index", &ti->index, 0, key);
+    tg3__parse_int(ctx, it, "texCoord", &ti->tex_coord, 0, key);
+    tg3__parse_double(ctx, it, "scale", &ti->scale, 0, key);
+    tg3__parse_extras_and_extensions(ctx, it, &ti->ext);
+    return 1;
+}
+
+static int tg3__parse_occlusion_texture_info(tg3__parse_ctx *ctx, const tg3json_value *o,
+                                             const char *key, tg3_occlusion_texture_info *ti) {
+    const tg3json_value *it = tg3__json_get(o, key);
+    tg3__init_occlusion_texture_info(ti);
+    if (!it) return 1;
+    if (!tg3__json_is_object(it)) return 0;
+    tg3__parse_int(ctx, it, "index", &ti->index, 0, key);
+    tg3__parse_int(ctx, it, "texCoord", &ti->tex_coord, 0, key);
+    tg3__parse_double(ctx, it, "strength", &ti->strength, 0, key);
+    tg3__parse_extras_and_extensions(ctx, it, &ti->ext);
+    return 1;
+}
+
+static int tg3__accessor_type_from_string(const char *s, size_t len) {
+    if (len == 6 && memcmp(s, "SCALAR", 6) == 0) return TG3_TYPE_SCALAR;
+    if (len == 4 && memcmp(s, "VEC2", 4) == 0) return TG3_TYPE_VEC2;
+    if (len == 4 && memcmp(s, "VEC3", 4) == 0) return TG3_TYPE_VEC3;
+    if (len == 4 && memcmp(s, "VEC4", 4) == 0) return TG3_TYPE_VEC4;
+    if (len == 4 && memcmp(s, "MAT2", 4) == 0) return TG3_TYPE_MAT2;
+    if (len == 4 && memcmp(s, "MAT3", 4) == 0) return TG3_TYPE_MAT3;
+    if (len == 4 && memcmp(s, "MAT4", 4) == 0) return TG3_TYPE_MAT4;
+    return -1;
+}
+
+static int tg3__parse_accessor_sparse(tg3__parse_ctx *ctx, const tg3json_value *o,
+                                      tg3_accessor_sparse *sparse) {
+    const tg3json_value *it = tg3__json_get(o, "sparse");
+    memset(sparse, 0, sizeof(*sparse));
+    sparse->indices.buffer_view = -1;
+    sparse->values.buffer_view = -1;
+    if (!it) return 1;
+    if (!tg3__json_is_object(it)) return 0;
+    sparse->is_sparse = 1;
+    tg3__parse_int(ctx, it, "count", &sparse->count, 1, "/sparse");
+    {
+        const tg3json_value *idx_it = tg3__json_get(it, "indices");
+        if (tg3__json_is_object(idx_it)) {
+            uint64_t bo = 0;
+            tg3__parse_int(ctx, idx_it, "bufferView", &sparse->indices.buffer_view, 1, "/sparse/indices");
+            tg3__parse_int(ctx, idx_it, "componentType", &sparse->indices.component_type, 1, "/sparse/indices");
+            tg3__parse_uint64(ctx, idx_it, "byteOffset", &bo, 0, "/sparse/indices");
+            sparse->indices.byte_offset = bo;
+            tg3__parse_extras_and_extensions(ctx, idx_it, &sparse->indices.ext);
+        }
+    }
+    {
+        const tg3json_value *val_it = tg3__json_get(it, "values");
+        if (tg3__json_is_object(val_it)) {
+            uint64_t bo = 0;
+            tg3__parse_int(ctx, val_it, "bufferView", &sparse->values.buffer_view, 1, "/sparse/values");
+            tg3__parse_uint64(ctx, val_it, "byteOffset", &bo, 0, "/sparse/values");
+            sparse->values.byte_offset = bo;
+            tg3__parse_extras_and_extensions(ctx, val_it, &sparse->values.ext);
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, it, &sparse->ext);
+    return 1;
+}
+
+static int tg3__parse_accessor(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_accessor *acc) {
+    tg3_str type_str;
+    uint64_t bo = 0;
+    uint64_t cnt = 0;
+    memset(acc, 0, sizeof(*acc));
+    acc->buffer_view = -1;
+    acc->component_type = -1;
+    acc->type = -1;
+    tg3__parse_string(ctx, o, "name", &acc->name, 0, "/accessor");
+    tg3__parse_int(ctx, o, "bufferView", &acc->buffer_view, 0, "/accessor");
+    tg3__parse_uint64(ctx, o, "byteOffset", &bo, 0, "/accessor");
+    acc->byte_offset = bo;
+    tg3__parse_bool(ctx, o, "normalized", &acc->normalized, 0, "/accessor");
+    tg3__parse_int(ctx, o, "componentType", &acc->component_type, 1, "/accessor");
+    tg3__parse_uint64(ctx, o, "count", &cnt, 1, "/accessor");
+    acc->count = cnt;
+    type_str.data = NULL; type_str.len = 0;
+    tg3__parse_string(ctx, o, "type", &type_str, 1, "/accessor");
+    if (type_str.data) acc->type = tg3__accessor_type_from_string(type_str.data, type_str.len);
+    tg3__parse_number_array(ctx, o, "min", &acc->min_values, &acc->min_values_count, 0, "/accessor");
+    tg3__parse_number_array(ctx, o, "max", &acc->max_values, &acc->max_values_count, 0, "/accessor");
+    tg3__parse_accessor_sparse(ctx, o, &acc->sparse);
+    tg3__parse_extras_and_extensions(ctx, o, &acc->ext);
+    return 1;
+}
+
+static int tg3__load_external_file(tg3__parse_ctx *ctx, uint8_t **out_data, uint64_t *out_size,
+                                   const char *uri, uint32_t uri_len) {
+    char path_buf[4096];
+    uint32_t path_len = 0;
+    int32_t ok;
+    if (!ctx->opts.fs.read_file) {
+        tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_FS_NOT_AVAILABLE,
+                        "No filesystem callbacks available", NULL, -1);
+        return 0;
+    }
+    if (ctx->base_dir_len > 0) {
+        if (ctx->base_dir_len + 1u + uri_len >= sizeof(path_buf)) return 0;
+        memcpy(path_buf, ctx->base_dir, ctx->base_dir_len);
+        path_len = ctx->base_dir_len;
+        if (path_len > 0 && path_buf[path_len - 1u] != '/' && path_buf[path_len - 1u] != '\\') {
+            path_buf[path_len++] = '/';
+        }
+    }
+    if (path_len + uri_len >= sizeof(path_buf)) return 0;
+    memcpy(path_buf + path_len, uri, uri_len);
+    path_len += uri_len;
+    path_buf[path_len] = '\0';
+    ok = ctx->opts.fs.read_file(out_data, out_size, path_buf, path_len, ctx->opts.fs.user_data);
+    if (!ok) {
+        tg3__error_pushf(ctx->errors, ctx->arena, TG3_SEVERITY_ERROR, TG3_ERR_FILE_READ,
+                         NULL, "Failed to read file: %s", path_buf);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__parse_buffer(tg3__parse_ctx *ctx, const tg3json_value *o,
+                             tg3_buffer *buf, int32_t buf_idx) {
+    uint64_t byte_length = 0;
+    memset(buf, 0, sizeof(*buf));
+    tg3__parse_string(ctx, o, "name", &buf->name, 0, "/buffer");
+    tg3__parse_string(ctx, o, "uri", &buf->uri, 0, "/buffer");
+    tg3__parse_uint64(ctx, o, "byteLength", &byte_length, 1, "/buffer");
+    if (ctx->is_binary && buf_idx == 0 && buf->uri.len == 0) {
+        uint8_t *data;
+        if (!ctx->bin_data || ctx->bin_size < byte_length) {
+            tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_BUFFER_SIZE_MISMATCH,
+                            "GLB BIN chunk missing or smaller than buffer.byteLength", NULL, -1);
+            return 0;
+        }
+        data = (uint8_t *)tg3__arena_alloc(ctx->arena, (size_t)byte_length);
+        if (!data) {
+            tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                            "OOM for buffer data", NULL, -1);
+            return 0;
+        }
+        memcpy(data, ctx->bin_data, (size_t)byte_length);
+        buf->data.data = data;
+        buf->data.count = byte_length;
+    } else if (buf->uri.len > 0) {
+        if (tg3_is_data_uri(buf->uri.data, buf->uri.len)) {
+            size_t decoded_len = 0;
+            char mime[64];
+            uint8_t *decoded;
+            memset(mime, 0, sizeof(mime));
+            decoded = tg3__decode_data_uri(ctx->arena, buf->uri.data, buf->uri.len, &decoded_len, mime, sizeof(mime));
+            if (!decoded && byte_length > 0) {
+                tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_DATA_URI_DECODE,
+                                "Failed to decode buffer data URI", NULL, -1);
+                return 0;
+            }
+            buf->data.data = decoded;
+            buf->data.count = decoded_len;
+        } else {
+            uint8_t *file_data = NULL;
+            uint64_t file_size = 0;
+            if (tg3__load_external_file(ctx, &file_data, &file_size, buf->uri.data, buf->uri.len)) {
+                uint8_t *data = (uint8_t *)tg3__arena_alloc(ctx->arena, (size_t)file_size);
+                if (data) {
+                    memcpy(data, file_data, (size_t)file_size);
+                    buf->data.data = data;
+                    buf->data.count = file_size;
+                }
+                if (ctx->opts.fs.free_file) ctx->opts.fs.free_file(file_data, file_size, ctx->opts.fs.user_data);
+            }
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &buf->ext);
+    return 1;
+}
+
+static int tg3__parse_buffer_view(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_buffer_view *bv) {
+    uint64_t val = 0;
+    int32_t stride = 0;
+    memset(bv, 0, sizeof(*bv));
+    bv->buffer = -1;
+    tg3__parse_string(ctx, o, "name", &bv->name, 0, "/bufferView");
+    tg3__parse_int(ctx, o, "buffer", &bv->buffer, 1, "/bufferView");
+    tg3__parse_uint64(ctx, o, "byteOffset", &val, 0, "/bufferView");
+    bv->byte_offset = val;
+    val = 0;
+    tg3__parse_uint64(ctx, o, "byteLength", &val, 1, "/bufferView");
+    bv->byte_length = val;
+    tg3__parse_int(ctx, o, "byteStride", &stride, 0, "/bufferView");
+    bv->byte_stride = (uint32_t)stride;
+    tg3__parse_int(ctx, o, "target", &bv->target, 0, "/bufferView");
+    tg3__parse_extras_and_extensions(ctx, o, &bv->ext);
+    return 1;
+}
+
+static int tg3__parse_image(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_image *img, int32_t img_idx) {
+    (void)img_idx;
+    memset(img, 0, sizeof(*img));
+    img->width = -1; img->height = -1; img->component = -1; img->bits = -1; img->pixel_type = -1; img->buffer_view = -1;
+    tg3__parse_string(ctx, o, "name", &img->name, 0, "/image");
+    tg3__parse_string(ctx, o, "uri", &img->uri, 0, "/image");
+    tg3__parse_string(ctx, o, "mimeType", &img->mime_type, 0, "/image");
+    tg3__parse_int(ctx, o, "bufferView", &img->buffer_view, 0, "/image");
+    if (ctx->opts.images_as_is) img->as_is = 1;
+    tg3__parse_extras_and_extensions(ctx, o, &img->ext);
+    return 1;
+}
+
+static int tg3__parse_sampler(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_sampler *samp) {
+    memset(samp, 0, sizeof(*samp));
+    samp->min_filter = -1; samp->mag_filter = -1;
+    samp->wrap_s = TG3_TEXTURE_WRAP_REPEAT; samp->wrap_t = TG3_TEXTURE_WRAP_REPEAT;
+    tg3__parse_string(ctx, o, "name", &samp->name, 0, "/sampler");
+    tg3__parse_int(ctx, o, "minFilter", &samp->min_filter, 0, "/sampler");
+    tg3__parse_int(ctx, o, "magFilter", &samp->mag_filter, 0, "/sampler");
+    tg3__parse_int(ctx, o, "wrapS", &samp->wrap_s, 0, "/sampler");
+    tg3__parse_int(ctx, o, "wrapT", &samp->wrap_t, 0, "/sampler");
+    tg3__parse_extras_and_extensions(ctx, o, &samp->ext);
+    return 1;
+}
+
+static int tg3__parse_texture(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_texture *tex) {
+    memset(tex, 0, sizeof(*tex));
+    tex->sampler = -1; tex->source = -1;
+    tg3__parse_string(ctx, o, "name", &tex->name, 0, "/texture");
+    tg3__parse_int(ctx, o, "sampler", &tex->sampler, 0, "/texture");
+    tg3__parse_int(ctx, o, "source", &tex->source, 0, "/texture");
+    tg3__parse_extras_and_extensions(ctx, o, &tex->ext);
+    return 1;
+}
+
+static int tg3__parse_material(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_material *mat) {
+    const tg3json_value *pbr_it;
+    const tg3json_value *ext_it;
+    memset(mat, 0, sizeof(*mat));
+    tg3__init_pbr(&mat->pbr_metallic_roughness);
+    tg3__init_normal_texture_info(&mat->normal_texture);
+    tg3__init_occlusion_texture_info(&mat->occlusion_texture);
+    tg3__init_texture_info(&mat->emissive_texture);
+    mat->alpha_cutoff = 0.5;
+    tg3__parse_string(ctx, o, "name", &mat->name, 0, "/material");
+    tg3__parse_number_to_fixed(o, "emissiveFactor", mat->emissive_factor, 3);
+    {
+        tg3_str alpha_mode;
+        alpha_mode.data = NULL; alpha_mode.len = 0;
+        tg3__parse_string(ctx, o, "alphaMode", &alpha_mode, 0, "/material");
+        mat->alpha_mode = alpha_mode.len > 0 ? alpha_mode : tg3__arena_str(ctx->arena, "OPAQUE", 6);
+    }
+    tg3__parse_double(ctx, o, "alphaCutoff", &mat->alpha_cutoff, 0, "/material");
+    tg3__parse_bool(ctx, o, "doubleSided", &mat->double_sided, 0, "/material");
+    pbr_it = tg3__json_get(o, "pbrMetallicRoughness");
+    if (tg3__json_is_object(pbr_it)) {
+        tg3__parse_number_to_fixed(pbr_it, "baseColorFactor", mat->pbr_metallic_roughness.base_color_factor, 4);
+        tg3__parse_double(ctx, pbr_it, "metallicFactor", &mat->pbr_metallic_roughness.metallic_factor, 0, "/material/pbrMetallicRoughness");
+        tg3__parse_double(ctx, pbr_it, "roughnessFactor", &mat->pbr_metallic_roughness.roughness_factor, 0, "/material/pbrMetallicRoughness");
+        tg3__parse_texture_info(ctx, pbr_it, "baseColorTexture", &mat->pbr_metallic_roughness.base_color_texture);
+        tg3__parse_texture_info(ctx, pbr_it, "metallicRoughnessTexture", &mat->pbr_metallic_roughness.metallic_roughness_texture);
+        tg3__parse_extras_and_extensions(ctx, pbr_it, &mat->pbr_metallic_roughness.ext);
+    }
+    tg3__parse_normal_texture_info(ctx, o, "normalTexture", &mat->normal_texture);
+    tg3__parse_occlusion_texture_info(ctx, o, "occlusionTexture", &mat->occlusion_texture);
+    tg3__parse_texture_info(ctx, o, "emissiveTexture", &mat->emissive_texture);
+    ext_it = tg3__json_get(o, "extensions");
+    if (tg3__json_is_object(ext_it)) {
+        const tg3json_value *lod_it = tg3json_object_get(ext_it, "MSFT_lod");
+        if (tg3__json_is_object(lod_it)) {
+            tg3__parse_int_array(ctx, lod_it, "ids", &mat->lods, &mat->lods_count, 0, "/material/extensions/MSFT_lod");
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &mat->ext);
+    return 1;
+}
+
+static int tg3__parse_primitive(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_primitive *prim) {
+    const tg3json_value *attr_it;
+    const tg3json_value *targets_it;
+    memset(prim, 0, sizeof(*prim));
+    prim->material = -1; prim->indices = -1; prim->mode = TG3_MODE_TRIANGLES;
+    tg3__parse_int(ctx, o, "material", &prim->material, 0, "/primitive");
+    tg3__parse_int(ctx, o, "indices", &prim->indices, 0, "/primitive");
+    tg3__parse_int(ctx, o, "mode", &prim->mode, 0, "/primitive");
+    attr_it = tg3__json_get(o, "attributes");
+    if (tg3__json_is_object(attr_it)) {
+        size_t count = tg3json_object_size(attr_it);
+        if (count > 0) {
+            size_t i;
+            tg3_str_int_pair *attrs = (tg3_str_int_pair *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_str_int_pair));
+            if (attrs) {
+                for (i = 0; i < count; ++i) {
+                    const tg3json_object_entry *entry = tg3json_object_at(attr_it, i);
+                    attrs[i].key = tg3__arena_str(ctx->arena, entry->key, (uint32_t)entry->key_len);
+                    attrs[i].value = (int32_t)((entry->value->type == TG3JSON_REAL) ? entry->value->u.real : entry->value->u.integer);
+                }
+                prim->attributes = attrs;
+                prim->attributes_count = (uint32_t)count;
+            }
+        }
+    }
+    targets_it = tg3__json_get(o, "targets");
+    if (tg3__json_is_array(targets_it)) {
+        size_t tcount = tg3json_array_size(targets_it);
+        if (tcount > 0) {
+            size_t ti;
+            const tg3_str_int_pair **target_arrays = (const tg3_str_int_pair **)tg3__arena_alloc(ctx->arena, tcount * sizeof(tg3_str_int_pair *));
+            uint32_t *target_counts = (uint32_t *)tg3__arena_alloc(ctx->arena, tcount * sizeof(uint32_t));
+            if (target_arrays && target_counts) {
+                for (ti = 0; ti < tcount; ++ti) {
+                    const tg3json_value *target_obj = tg3json_array_get(targets_it, ti);
+                    size_t acount;
+                    size_t ai;
+                    tg3_str_int_pair *tattrs;
+                    if (!tg3__json_is_object(target_obj)) {
+                        target_arrays[ti] = NULL;
+                        target_counts[ti] = 0;
+                        continue;
+                    }
+                    acount = tg3json_object_size(target_obj);
+                    tattrs = (tg3_str_int_pair *)tg3__arena_alloc(ctx->arena, acount * sizeof(tg3_str_int_pair));
+                    if (tattrs) {
+                        for (ai = 0; ai < acount; ++ai) {
+                            const tg3json_object_entry *entry = tg3json_object_at(target_obj, ai);
+                            tattrs[ai].key = tg3__arena_str(ctx->arena, entry->key, (uint32_t)entry->key_len);
+                            tattrs[ai].value = (int32_t)((entry->value->type == TG3JSON_REAL) ? entry->value->u.real : entry->value->u.integer);
+                        }
+                    }
+                    target_arrays[ti] = tattrs;
+                    target_counts[ti] = (uint32_t)acount;
+                }
+                prim->targets = target_arrays;
+                prim->target_attribute_counts = target_counts;
+                prim->targets_count = (uint32_t)tcount;
+            }
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &prim->ext);
+    return 1;
+}
+
+static int tg3__parse_mesh(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_mesh *mesh) {
+    const tg3json_value *prim_it = tg3__json_get(o, "primitives");
+    memset(mesh, 0, sizeof(*mesh));
+    tg3__parse_string(ctx, o, "name", &mesh->name, 0, "/mesh");
+    if (tg3__json_is_array(prim_it)) {
+        size_t count = tg3json_array_size(prim_it);
+        if (count > 0) {
+            size_t i;
+            tg3_primitive *prims = (tg3_primitive *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_primitive));
+            if (prims) {
+                for (i = 0; i < count; ++i) tg3__parse_primitive(ctx, tg3json_array_get(prim_it, i), &prims[i]);
+                mesh->primitives = prims;
+                mesh->primitives_count = (uint32_t)count;
+            }
+        }
+    }
+    tg3__parse_number_array(ctx, o, "weights", &mesh->weights, &mesh->weights_count, 0, "/mesh");
+    tg3__parse_extras_and_extensions(ctx, o, &mesh->ext);
+    return 1;
+}
+
+static int tg3__parse_node(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_node *node) {
+    const tg3json_value *ext_it;
+    tg3__init_node(node);
+    tg3__parse_string(ctx, o, "name", &node->name, 0, "/node");
+    tg3__parse_int(ctx, o, "camera", &node->camera, 0, "/node");
+    tg3__parse_int(ctx, o, "skin", &node->skin, 0, "/node");
+    tg3__parse_int(ctx, o, "mesh", &node->mesh, 0, "/node");
+    tg3__parse_int_array(ctx, o, "children", &node->children, &node->children_count, 0, "/node");
+    if (tg3__json_has(o, "matrix")) { tg3__parse_number_to_fixed(o, "matrix", node->matrix, 16); node->has_matrix = 1; }
+    if (tg3__json_has(o, "translation")) tg3__parse_number_to_fixed(o, "translation", node->translation, 3);
+    if (tg3__json_has(o, "rotation")) tg3__parse_number_to_fixed(o, "rotation", node->rotation, 4);
+    if (tg3__json_has(o, "scale")) tg3__parse_number_to_fixed(o, "scale", node->scale, 3);
+    tg3__parse_number_array(ctx, o, "weights", &node->weights, &node->weights_count, 0, "/node");
+    ext_it = tg3__json_get(o, "extensions");
+    if (tg3__json_is_object(ext_it)) {
+        const tg3json_value *khr_lights = tg3json_object_get(ext_it, "KHR_lights_punctual");
+        const tg3json_value *khr_audio = tg3json_object_get(ext_it, "KHR_audio");
+        const tg3json_value *msft_lod = tg3json_object_get(ext_it, "MSFT_lod");
+        if (tg3__json_is_object(khr_lights)) tg3__parse_int(ctx, khr_lights, "light", &node->light, 0, "/node/extensions/KHR_lights_punctual");
+        if (tg3__json_is_object(khr_audio)) tg3__parse_int(ctx, khr_audio, "emitter", &node->emitter, 0, "/node/extensions/KHR_audio");
+        if (tg3__json_is_object(msft_lod)) tg3__parse_int_array(ctx, msft_lod, "ids", &node->lods, &node->lods_count, 0, "/node/extensions/MSFT_lod");
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &node->ext);
+    return 1;
+}
+
+static int tg3__parse_skin(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_skin *skin) {
+    memset(skin, 0, sizeof(*skin));
+    skin->inverse_bind_matrices = -1; skin->skeleton = -1;
+    tg3__parse_string(ctx, o, "name", &skin->name, 0, "/skin");
+    tg3__parse_int(ctx, o, "inverseBindMatrices", &skin->inverse_bind_matrices, 0, "/skin");
+    tg3__parse_int(ctx, o, "skeleton", &skin->skeleton, 0, "/skin");
+    tg3__parse_int_array(ctx, o, "joints", &skin->joints, &skin->joints_count, 1, "/skin");
+    tg3__parse_extras_and_extensions(ctx, o, &skin->ext);
+    return 1;
+}
+
+static int tg3__parse_animation(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_animation *anim) {
+    const tg3json_value *ch_it = tg3__json_get(o, "channels");
+    const tg3json_value *samp_it = tg3__json_get(o, "samplers");
+    memset(anim, 0, sizeof(*anim));
+    tg3__parse_string(ctx, o, "name", &anim->name, 0, "/animation");
+    if (tg3__json_is_array(ch_it)) {
+        size_t count = tg3json_array_size(ch_it);
+        if (count > 0) {
+            size_t i;
+            tg3_animation_channel *channels = (tg3_animation_channel *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_animation_channel));
+            if (channels) {
+                for (i = 0; i < count; ++i) {
+                    const tg3json_value *item = tg3json_array_get(ch_it, i);
+                    const tg3json_value *tgt_it;
+                    memset(&channels[i], 0, sizeof(channels[i]));
+                    channels[i].sampler = -1;
+                    channels[i].target.node = -1;
+                    tg3__parse_int(ctx, item, "sampler", &channels[i].sampler, 1, "/animation/channel");
+                    tgt_it = tg3__json_get(item, "target");
+                    if (tg3__json_is_object(tgt_it)) {
+                        tg3__parse_int(ctx, tgt_it, "node", &channels[i].target.node, 0, "/animation/channel/target");
+                        tg3__parse_string(ctx, tgt_it, "path", &channels[i].target.path, 1, "/animation/channel/target");
+                        tg3__parse_extras_and_extensions(ctx, tgt_it, &channels[i].target.ext);
+                    }
+                    tg3__parse_extras_and_extensions(ctx, item, &channels[i].ext);
+                }
+                anim->channels = channels;
+                anim->channels_count = (uint32_t)count;
+            }
+        }
+    }
+    if (tg3__json_is_array(samp_it)) {
+        size_t count = tg3json_array_size(samp_it);
+        if (count > 0) {
+            size_t i;
+            tg3_animation_sampler *samplers = (tg3_animation_sampler *)tg3__arena_alloc(ctx->arena, count * sizeof(tg3_animation_sampler));
+            if (samplers) {
+                for (i = 0; i < count; ++i) {
+                    const tg3json_value *item = tg3json_array_get(samp_it, i);
+                    tg3_str interp;
+                    memset(&samplers[i], 0, sizeof(samplers[i]));
+                    samplers[i].input = -1; samplers[i].output = -1;
+                    tg3__parse_int(ctx, item, "input", &samplers[i].input, 1, "/animation/sampler");
+                    tg3__parse_int(ctx, item, "output", &samplers[i].output, 1, "/animation/sampler");
+                    interp.data = NULL; interp.len = 0;
+                    tg3__parse_string(ctx, item, "interpolation", &interp, 0, "/animation/sampler");
+                    samplers[i].interpolation = interp.len > 0 ? interp : tg3__arena_str(ctx->arena, "LINEAR", 6);
+                    tg3__parse_extras_and_extensions(ctx, item, &samplers[i].ext);
+                }
+                anim->samplers = samplers;
+                anim->samplers_count = (uint32_t)count;
+            }
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &anim->ext);
+    return 1;
+}
+
+static int tg3__parse_camera(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_camera *cam) {
+    const tg3json_value *it;
+    memset(cam, 0, sizeof(*cam));
+    tg3__parse_string(ctx, o, "name", &cam->name, 0, "/camera");
+    tg3__parse_string(ctx, o, "type", &cam->type, 1, "/camera");
+    if (cam->type.data && tg3_str_equals_cstr(cam->type, "perspective")) {
+        it = tg3__json_get(o, "perspective");
+        if (tg3__json_is_object(it)) {
+            tg3__parse_double(ctx, it, "aspectRatio", &cam->perspective.aspect_ratio, 0, "/camera/perspective");
+            tg3__parse_double(ctx, it, "yfov", &cam->perspective.yfov, 1, "/camera/perspective");
+            tg3__parse_double(ctx, it, "zfar", &cam->perspective.zfar, 0, "/camera/perspective");
+            tg3__parse_double(ctx, it, "znear", &cam->perspective.znear, 1, "/camera/perspective");
+            tg3__parse_extras_and_extensions(ctx, it, &cam->perspective.ext);
+        }
+    } else if (cam->type.data && tg3_str_equals_cstr(cam->type, "orthographic")) {
+        it = tg3__json_get(o, "orthographic");
+        if (tg3__json_is_object(it)) {
+            tg3__parse_double(ctx, it, "xmag", &cam->orthographic.xmag, 1, "/camera/orthographic");
+            tg3__parse_double(ctx, it, "ymag", &cam->orthographic.ymag, 1, "/camera/orthographic");
+            tg3__parse_double(ctx, it, "zfar", &cam->orthographic.zfar, 1, "/camera/orthographic");
+            tg3__parse_double(ctx, it, "znear", &cam->orthographic.znear, 1, "/camera/orthographic");
+            tg3__parse_extras_and_extensions(ctx, it, &cam->orthographic.ext);
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &cam->ext);
+    return 1;
+}
+
+static int tg3__parse_scene(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_scene *scene) {
+    const tg3json_value *ext_it;
+    memset(scene, 0, sizeof(*scene));
+    tg3__parse_string(ctx, o, "name", &scene->name, 0, "/scene");
+    tg3__parse_int_array(ctx, o, "nodes", &scene->nodes, &scene->nodes_count, 0, "/scene");
+    ext_it = tg3__json_get(o, "extensions");
+    if (tg3__json_is_object(ext_it)) {
+        const tg3json_value *audio_it = tg3json_object_get(ext_it, "KHR_audio");
+        if (tg3__json_is_object(audio_it)) {
+            tg3__parse_int_array(ctx, audio_it, "emitters", &scene->audio_emitters, &scene->audio_emitters_count, 0, "/scene/extensions/KHR_audio");
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &scene->ext);
+    return 1;
+}
+
+static int tg3__parse_light(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_light *light) {
+    const tg3json_value *spot_it;
+    memset(light, 0, sizeof(*light));
+    light->color[0] = 1.0; light->color[1] = 1.0; light->color[2] = 1.0;
+    light->intensity = 1.0; light->spot.outer_cone_angle = 0.7853981634;
+    tg3__parse_string(ctx, o, "name", &light->name, 0, "/light");
+    tg3__parse_string(ctx, o, "type", &light->type, 1, "/light");
+    tg3__parse_double(ctx, o, "intensity", &light->intensity, 0, "/light");
+    tg3__parse_double(ctx, o, "range", &light->range, 0, "/light");
+    tg3__parse_number_to_fixed(o, "color", light->color, 3);
+    spot_it = tg3__json_get(o, "spot");
+    if (tg3__json_is_object(spot_it)) {
+        tg3__parse_double(ctx, spot_it, "innerConeAngle", &light->spot.inner_cone_angle, 0, "/light/spot");
+        tg3__parse_double(ctx, spot_it, "outerConeAngle", &light->spot.outer_cone_angle, 0, "/light/spot");
+        tg3__parse_extras_and_extensions(ctx, spot_it, &light->spot.ext);
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &light->ext);
+    return 1;
+}
+
+static int tg3__parse_audio_source(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_audio_source *src) {
+    memset(src, 0, sizeof(*src));
+    src->buffer_view = -1;
+    tg3__parse_string(ctx, o, "name", &src->name, 0, "/audioSource");
+    tg3__parse_string(ctx, o, "uri", &src->uri, 0, "/audioSource");
+    tg3__parse_int(ctx, o, "bufferView", &src->buffer_view, 0, "/audioSource");
+    tg3__parse_string(ctx, o, "mimeType", &src->mime_type, 0, "/audioSource");
+    tg3__parse_extras_and_extensions(ctx, o, &src->ext);
+    return 1;
+}
+
+static int tg3__parse_audio_emitter(tg3__parse_ctx *ctx, const tg3json_value *o, tg3_audio_emitter *emitter) {
+    const tg3json_value *pos_it;
+    memset(emitter, 0, sizeof(*emitter));
+    emitter->gain = 1.0; emitter->source = -1;
+    emitter->positional.cone_inner_angle = 6.283185307179586;
+    emitter->positional.cone_outer_angle = 6.283185307179586;
+    emitter->positional.max_distance = 100.0; emitter->positional.ref_distance = 1.0; emitter->positional.rolloff_factor = 1.0;
+    tg3__parse_string(ctx, o, "name", &emitter->name, 0, "/audioEmitter");
+    tg3__parse_double(ctx, o, "gain", &emitter->gain, 0, "/audioEmitter");
+    tg3__parse_bool(ctx, o, "loop", &emitter->loop, 0, "/audioEmitter");
+    tg3__parse_bool(ctx, o, "playing", &emitter->playing, 0, "/audioEmitter");
+    tg3__parse_string(ctx, o, "type", &emitter->type, 0, "/audioEmitter");
+    tg3__parse_string(ctx, o, "distanceModel", &emitter->distance_model, 0, "/audioEmitter");
+    tg3__parse_int(ctx, o, "source", &emitter->source, 0, "/audioEmitter");
+    pos_it = tg3__json_get(o, "positional");
+    if (tg3__json_is_object(pos_it)) {
+        tg3__parse_double(ctx, pos_it, "coneInnerAngle", &emitter->positional.cone_inner_angle, 0, "/positional");
+        tg3__parse_double(ctx, pos_it, "coneOuterAngle", &emitter->positional.cone_outer_angle, 0, "/positional");
+        tg3__parse_double(ctx, pos_it, "coneOuterGain", &emitter->positional.cone_outer_gain, 0, "/positional");
+        tg3__parse_double(ctx, pos_it, "maxDistance", &emitter->positional.max_distance, 0, "/positional");
+        tg3__parse_double(ctx, pos_it, "refDistance", &emitter->positional.ref_distance, 0, "/positional");
+        tg3__parse_double(ctx, pos_it, "rolloffFactor", &emitter->positional.rolloff_factor, 0, "/positional");
+        tg3__parse_extras_and_extensions(ctx, pos_it, &emitter->positional.ext);
+    }
+    tg3__parse_extras_and_extensions(ctx, o, &emitter->ext);
+    return 1;
+}
+
+#define TG3__STREAM_CB(cb_name, model_arr, model_cnt) \
+    do { \
+        if ((ctx)->opts.stream && (ctx)->opts.stream->cb_name) { \
+            uint32_t _si; \
+            for (_si = 0; _si < (model_cnt); ++_si) { \
+                tg3_stream_action _sa = (ctx)->opts.stream->cb_name(&(model_arr)[_si], (int32_t)_si, (ctx)->opts.stream->user_data); \
+                if (_sa == TG3_STREAM_ABORT) return TG3_ERR_STREAM_ABORTED; \
+            } \
+        } \
+    } while (0)
+
+#define TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, json_key, Type, model_field, count_field, parse_fn) \
+    do { \
+        const tg3json_value *_arr = tg3json_object_get((json_doc), (json_key)); \
+        if (tg3__json_is_array(_arr)) { \
+            size_t _count = tg3json_array_size(_arr); \
+            if (_count > 0) { \
+                size_t _i; \
+                Type *_items = (Type *)tg3__arena_alloc((ctx)->arena, _count * sizeof(Type)); \
+                if (_items) { \
+                    for (_i = 0; _i < _count; ++_i) { \
+                        const tg3json_value *_it = tg3json_array_get(_arr, _i); \
+                        if (!tg3__json_is_object(_it)) { \
+                            tg3__error_pushf((ctx)->errors, (ctx)->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH, (json_key), "Element %u must be an object", (unsigned)_i); \
+                            continue; \
+                        } \
+                        parse_fn((ctx), _it, &_items[_i]); \
+                    } \
+                    (model_field) = _items; \
+                    (count_field) = (uint32_t)_count; \
+                } \
+            } \
+        } \
+    } while (0)
+
+#define TG3__PARSE_ARRAY_IDX(ctx, json_doc, json_key, Type, model_field, count_field, parse_fn) \
+    do { \
+        const tg3json_value *_arr = tg3json_object_get((json_doc), (json_key)); \
+        if (tg3__json_is_array(_arr)) { \
+            size_t _count = tg3json_array_size(_arr); \
+            if (_count > 0) { \
+                size_t _i; \
+                Type *_items = (Type *)tg3__arena_alloc((ctx)->arena, _count * sizeof(Type)); \
+                if (_items) { \
+                    for (_i = 0; _i < _count; ++_i) { \
+                        const tg3json_value *_it = tg3json_array_get(_arr, _i); \
+                        if (!tg3__json_is_object(_it)) { \
+                            tg3__error_pushf((ctx)->errors, (ctx)->arena, TG3_SEVERITY_ERROR, TG3_ERR_JSON_TYPE_MISMATCH, (json_key), "Element %u must be an object", (unsigned)_i); \
+                            continue; \
+                        } \
+                        parse_fn((ctx), _it, &_items[_i], (int32_t)_i); \
+                    } \
+                    (model_field) = _items; \
+                    (count_field) = (uint32_t)_count; \
+                } \
+            } \
+        } \
+    } while (0)
+
+static tg3_error_code tg3__parse_from_json(tg3__parse_ctx *ctx, const tg3json_value *json_doc, tg3_model *model) {
+    const tg3json_value *asset_it = tg3json_object_get(json_doc, "asset");
+    const tg3json_value *ext_it;
+    if (tg3__json_is_object(asset_it)) {
+        tg3__parse_asset(ctx, asset_it, &model->asset);
+    } else if (ctx->opts.required_sections & TG3_REQUIRE_VERSION) {
+        tg3__error_push(ctx->errors, TG3_SEVERITY_ERROR, TG3_ERR_MISSING_REQUIRED,
+                        "Missing required 'asset' property", "/", -1);
+        return TG3_ERR_MISSING_REQUIRED;
+    }
+    if (ctx->opts.stream && ctx->opts.stream->on_asset) {
+        tg3_stream_action sa = ctx->opts.stream->on_asset(&model->asset, ctx->opts.stream->user_data);
+        if (sa == TG3_STREAM_ABORT) return TG3_ERR_STREAM_ABORTED;
+    }
+    tg3__parse_string_array(ctx, json_doc, "extensionsUsed", &model->extensions_used, &model->extensions_used_count, 0, "/");
+    tg3__parse_string_array(ctx, json_doc, "extensionsRequired", &model->extensions_required, &model->extensions_required_count, 0, "/");
+    model->default_scene = -1;
+    tg3__parse_int(ctx, json_doc, "scene", &model->default_scene, 0, "/");
+
+    TG3__PARSE_ARRAY_IDX(ctx, json_doc, "buffers", tg3_buffer, model->buffers, model->buffers_count, tg3__parse_buffer);
+    TG3__STREAM_CB(on_buffer, model->buffers, model->buffers_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "bufferViews", tg3_buffer_view, model->buffer_views, model->buffer_views_count, tg3__parse_buffer_view);
+    TG3__STREAM_CB(on_buffer_view, model->buffer_views, model->buffer_views_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "accessors", tg3_accessor, model->accessors, model->accessors_count, tg3__parse_accessor);
+    TG3__STREAM_CB(on_accessor, model->accessors, model->accessors_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "meshes", tg3_mesh, model->meshes, model->meshes_count, tg3__parse_mesh);
+    TG3__STREAM_CB(on_mesh, model->meshes, model->meshes_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "nodes", tg3_node, model->nodes, model->nodes_count, tg3__parse_node);
+    TG3__STREAM_CB(on_node, model->nodes, model->nodes_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "materials", tg3_material, model->materials, model->materials_count, tg3__parse_material);
+    TG3__STREAM_CB(on_material, model->materials, model->materials_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "textures", tg3_texture, model->textures, model->textures_count, tg3__parse_texture);
+    TG3__STREAM_CB(on_texture, model->textures, model->textures_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "samplers", tg3_sampler, model->samplers, model->samplers_count, tg3__parse_sampler);
+    TG3__STREAM_CB(on_sampler, model->samplers, model->samplers_count);
+    TG3__PARSE_ARRAY_IDX(ctx, json_doc, "images", tg3_image, model->images, model->images_count, tg3__parse_image);
+    TG3__STREAM_CB(on_image, model->images, model->images_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "skins", tg3_skin, model->skins, model->skins_count, tg3__parse_skin);
+    TG3__STREAM_CB(on_skin, model->skins, model->skins_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "animations", tg3_animation, model->animations, model->animations_count, tg3__parse_animation);
+    TG3__STREAM_CB(on_animation, model->animations, model->animations_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "cameras", tg3_camera, model->cameras, model->cameras_count, tg3__parse_camera);
+    TG3__STREAM_CB(on_camera, model->cameras, model->cameras_count);
+    TG3__PARSE_ARRAY_SIMPLE(ctx, json_doc, "scenes", tg3_scene, model->scenes, model->scenes_count, tg3__parse_scene);
+    TG3__STREAM_CB(on_scene, model->scenes, model->scenes_count);
+
+    ext_it = tg3json_object_get(json_doc, "extensions");
+    if (tg3__json_is_object(ext_it)) {
+        const tg3json_value *lights_ext = tg3json_object_get(ext_it, "KHR_lights_punctual");
+        const tg3json_value *audio_ext = tg3json_object_get(ext_it, "KHR_audio");
+        if (tg3__json_is_object(lights_ext)) {
+            TG3__PARSE_ARRAY_SIMPLE(ctx, lights_ext, "lights", tg3_light, model->lights, model->lights_count, tg3__parse_light);
+            TG3__STREAM_CB(on_light, model->lights, model->lights_count);
+        }
+        if (tg3__json_is_object(audio_ext)) {
+            TG3__PARSE_ARRAY_SIMPLE(ctx, audio_ext, "sources", tg3_audio_source, model->audio_sources, model->audio_sources_count, tg3__parse_audio_source);
+            TG3__PARSE_ARRAY_SIMPLE(ctx, audio_ext, "emitters", tg3_audio_emitter, model->audio_emitters, model->audio_emitters_count, tg3__parse_audio_emitter);
+        }
+    }
+    tg3__parse_extras_and_extensions(ctx, json_doc, &model->ext);
+    return (ctx->errors && ctx->errors->has_error) ? TG3_ERR_JSON_PARSE : TG3_OK;
+}
+
+static tg3_error_code tg3__parse_glb_header(const uint8_t *data, uint64_t size,
+                                            const uint8_t **json_out, uint64_t *json_size_out,
+                                            const uint8_t **bin_out, uint64_t *bin_size_out,
+                                            tg3_error_stack *errors) {
+    uint32_t version;
+    uint32_t total_length;
+    uint64_t offset = 12;
+    *json_out = NULL; *json_size_out = 0; *bin_out = NULL; *bin_size_out = 0;
+    if (size < 12) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_INVALID_HEADER,
+                        "GLB data too small for header", NULL, -1);
+        return TG3_ERR_GLB_INVALID_HEADER;
+    }
+    if (data[0] != 'g' || data[1] != 'l' || data[2] != 'T' || data[3] != 'F') {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_INVALID_MAGIC,
+                        "Invalid GLB magic bytes", NULL, -1);
+        return TG3_ERR_GLB_INVALID_MAGIC;
+    }
+    memcpy(&version, data + 4, 4);
+    if (version != 2) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_INVALID_VERSION,
+                        "Unsupported GLB version (expected 2)", NULL, -1);
+        return TG3_ERR_GLB_INVALID_VERSION;
+    }
+    memcpy(&total_length, data + 8, 4);
+    if ((uint64_t)total_length > size) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_SIZE_MISMATCH,
+                        "GLB total length exceeds data size", NULL, -1);
+        return TG3_ERR_GLB_SIZE_MISMATCH;
+    }
+    while (offset + 8 <= size) {
+        uint32_t chunk_length;
+        uint32_t chunk_type;
+        memcpy(&chunk_length, data + offset, 4); offset += 4;
+        memcpy(&chunk_type, data + offset, 4); offset += 4;
+        if (offset + chunk_length > size) {
+            tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_CHUNK_ERROR,
+                            "GLB chunk exceeds data size", NULL, -1);
+            return TG3_ERR_GLB_CHUNK_ERROR;
+        }
+        if (chunk_type == 0x4E4F534Au) {
+            *json_out = data + offset;
+            *json_size_out = chunk_length;
+        } else if (chunk_type == 0x004E4942u) {
+            *bin_out = data + offset;
+            *bin_size_out = chunk_length;
+        }
+        offset += chunk_length;
+        while ((offset & 3u) != 0u && offset < size) ++offset;
+    }
+    if (!*json_out) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_GLB_CHUNK_ERROR,
+                        "GLB missing JSON chunk", NULL, -1);
+        return TG3_ERR_GLB_CHUNK_ERROR;
+    }
+    return TG3_OK;
+}
+
+TINYGLTF3_API tg3_error_code tg3_parse(tg3_model *model, tg3_error_stack *errors,
+                                       const uint8_t *json_data, uint64_t json_size,
+                                       const char *base_dir, uint32_t base_dir_len,
+                                       const tg3_parse_options *options) {
+    tg3_parse_options default_opts;
+    tg3_arena *arena;
+    tg3__parse_ctx ctx;
+    tg3json_value json_doc;
+    const char *error_pos = NULL;
+    tg3_error_code ret;
+    if (!options) { tg3_parse_options_init(&default_opts); options = &default_opts; }
+    tg3__model_init(model);
+    arena = tg3__arena_create(&options->memory);
+    if (!arena) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY, "Failed to create arena", NULL, -1);
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    model->arena_ = arena;
+    if (!tg3json_parse_n((const char *)json_data, (size_t)json_size, TINYGLTF3_MAX_NESTING_DEPTH, &json_doc, &error_pos) || json_doc.type != TG3JSON_OBJECT) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_JSON_PARSE, "Failed to parse JSON", NULL,
+                        error_pos ? (int64_t)(error_pos - (const char *)json_data) : -1);
+        if (model->arena_) { tg3__arena_destroy(model->arena_); model->arena_ = NULL; }
+        return TG3_ERR_JSON_PARSE;
+    }
+    memset(&ctx, 0, sizeof(ctx));
+    ctx.arena = arena;
+    ctx.errors = errors;
+    ctx.opts = *options;
+    ctx.base_dir = base_dir;
+    ctx.base_dir_len = base_dir_len;
+#ifdef TINYGLTF3_ENABLE_FS
+    tg3__set_default_fs(&ctx.opts.fs);
+#endif
+    ret = tg3__parse_from_json(&ctx, &json_doc, model);
+    tg3json_value_free(&json_doc);
+    if (ret != TG3_OK && model->arena_) {
+        tg3__arena_destroy(model->arena_);
+        model->arena_ = NULL;
+    }
+    return ret;
+}
+
+TINYGLTF3_API tg3_error_code tg3_parse_glb(tg3_model *model, tg3_error_stack *errors,
+                                           const uint8_t *glb_data, uint64_t glb_size,
+                                           const char *base_dir, uint32_t base_dir_len,
+                                           const tg3_parse_options *options) {
+    const uint8_t *json_chunk = NULL;
+    uint64_t json_chunk_size = 0;
+    const uint8_t *bin_chunk = NULL;
+    uint64_t bin_chunk_size = 0;
+    tg3_parse_options default_opts;
+    tg3_arena *arena;
+    tg3__parse_ctx ctx;
+    tg3json_value json_doc;
+    const char *error_pos = NULL;
+    tg3_error_code err;
+    err = tg3__parse_glb_header(glb_data, glb_size, &json_chunk, &json_chunk_size, &bin_chunk, &bin_chunk_size, errors);
+    if (err != TG3_OK) return err;
+    if (!options) { tg3_parse_options_init(&default_opts); options = &default_opts; }
+    tg3__model_init(model);
+    arena = tg3__arena_create(&options->memory);
+    if (!arena) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY, "Failed to create arena", NULL, -1);
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    model->arena_ = arena;
+    if (!tg3json_parse_n((const char *)json_chunk, (size_t)json_chunk_size, TINYGLTF3_MAX_NESTING_DEPTH, &json_doc, &error_pos) || json_doc.type != TG3JSON_OBJECT) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_JSON_PARSE, "Failed to parse GLB JSON chunk", NULL,
+                        error_pos ? (int64_t)(error_pos - (const char *)json_chunk) : -1);
+        tg3__arena_destroy(model->arena_);
+        model->arena_ = NULL;
+        return TG3_ERR_JSON_PARSE;
+    }
+    memset(&ctx, 0, sizeof(ctx));
+    ctx.arena = arena;
+    ctx.errors = errors;
+    ctx.opts = *options;
+    ctx.base_dir = base_dir;
+    ctx.base_dir_len = base_dir_len;
+    ctx.is_binary = 1;
+    ctx.bin_data = bin_chunk;
+    ctx.bin_size = bin_chunk_size;
+#ifdef TINYGLTF3_ENABLE_FS
+    tg3__set_default_fs(&ctx.opts.fs);
+#endif
+    err = tg3__parse_from_json(&ctx, &json_doc, model);
+    tg3json_value_free(&json_doc);
+    if (err != TG3_OK && model->arena_) {
+        tg3__arena_destroy(model->arena_);
+        model->arena_ = NULL;
+    }
+    return err;
+}
+
+TINYGLTF3_API tg3_error_code tg3_parse_auto(tg3_model *model, tg3_error_stack *errors,
+                                            const uint8_t *data, uint64_t size,
+                                            const char *base_dir, uint32_t base_dir_len,
+                                            const tg3_parse_options *options) {
+    if (size >= 4 && data[0] == 'g' && data[1] == 'l' && data[2] == 'T' && data[3] == 'F') {
+        return tg3_parse_glb(model, errors, data, size, base_dir, base_dir_len, options);
+    }
+    return tg3_parse(model, errors, data, size, base_dir, base_dir_len, options);
+}
+
+TINYGLTF3_API tg3_error_code tg3_parse_file(tg3_model *model, tg3_error_stack *errors,
+                                            const char *filename, uint32_t filename_len,
+                                            const tg3_parse_options *options) {
+    tg3_parse_options opts;
+    uint8_t *file_data = NULL;
+    uint64_t file_size = 0;
+    char base_dir_buf[4096];
+    uint32_t base_dir_len = 0;
+    tg3_error_code result;
+    uint32_t i;
+    if (options) opts = *options;
+    else tg3_parse_options_init(&opts);
+#ifdef TINYGLTF3_ENABLE_FS
+    tg3__set_default_fs(&opts.fs);
+#endif
+    if (!opts.fs.read_file) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_FS_NOT_AVAILABLE,
+                        "No filesystem callbacks. Define TINYGLTF3_ENABLE_FS or provide fs callbacks.", NULL, -1);
+        return TG3_ERR_FS_NOT_AVAILABLE;
+    }
+    if (!opts.fs.read_file(&file_data, &file_size, filename, filename_len, opts.fs.user_data) || !file_data) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_FILE_NOT_FOUND,
+                        "Failed to read file", NULL, -1);
+        return TG3_ERR_FILE_NOT_FOUND;
+    }
+    memset(base_dir_buf, 0, sizeof(base_dir_buf));
+    for (i = 0; i < filename_len; ++i) {
+        if (filename[i] == '/' || filename[i] == '\\') base_dir_len = i;
+    }
+    if (base_dir_len > 0) {
+        memcpy(base_dir_buf, filename, base_dir_len);
+        base_dir_buf[base_dir_len] = '\0';
+    }
+    result = tg3_parse_auto(model, errors, file_data, file_size, base_dir_buf, base_dir_len, &opts);
+    if (opts.fs.free_file) opts.fs.free_file(file_data, file_size, opts.fs.user_data);
+    return result;
+}
+
+TINYGLTF3_API void tg3_model_free(tg3_model *model) {
+    if (!model) return;
+    if (model->arena_) tg3__arena_destroy(model->arena_);
+    memset(model, 0, sizeof(*model));
+    model->default_scene = -1;
+}
+
+static char *tg3__b64_encode(const uint8_t *input, size_t input_len, size_t *out_len) {
+    static const char chars[] =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    size_t enc_len = ((input_len + 2u) / 3u) * 4u;
+    char *out = (char *)malloc(enc_len + 1u);
+    size_t i;
+    size_t j = 0;
+    if (!out) return NULL;
+    for (i = 0; i < input_len; i += 3u) {
+        uint32_t a = input[i];
+        uint32_t b = (i + 1u < input_len) ? input[i + 1u] : 0u;
+        uint32_t c = (i + 2u < input_len) ? input[i + 2u] : 0u;
+        uint32_t triple = (a << 16u) | (b << 8u) | c;
+        out[j++] = chars[(triple >> 18u) & 0x3Fu];
+        out[j++] = chars[(triple >> 12u) & 0x3Fu];
+        out[j++] = (i + 1u < input_len) ? chars[(triple >> 6u) & 0x3Fu] : '=';
+        out[j++] = (i + 2u < input_len) ? chars[triple & 0x3Fu] : '=';
+    }
+    out[j] = '\0';
+    if (out_len) *out_len = enc_len;
+    return out;
+}
+
+static const char *tg3__accessor_type_to_string(int type) {
+    switch (type) {
+        case TG3_TYPE_SCALAR: return "SCALAR";
+        case TG3_TYPE_VEC2: return "VEC2";
+        case TG3_TYPE_VEC3: return "VEC3";
+        case TG3_TYPE_VEC4: return "VEC4";
+        case TG3_TYPE_MAT2: return "MAT2";
+        case TG3_TYPE_MAT3: return "MAT3";
+        case TG3_TYPE_MAT4: return "MAT4";
+        default: return "";
+    }
+}
+
+static int tg3__json_set_take(tg3json_value *obj, const char *key, tg3json_value *value) {
+    if (!tg3json_object_set_take(obj, key, value)) {
+        tg3json_value_free(value);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__json_push_take(tg3json_value *arr, tg3json_value *value) {
+    if (!tg3json_array_append_take(arr, value)) {
+        tg3json_value_free(value);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__json_set_int(tg3json_value *obj, const char *key, int64_t value) {
+    tg3json_value tmp;
+    tg3json_value_init_int(&tmp, value);
+    return tg3__json_set_take(obj, key, &tmp);
+}
+
+static int tg3__json_set_real(tg3json_value *obj, const char *key, double value) {
+    tg3json_value tmp;
+    tg3json_value_init_real(&tmp, value);
+    return tg3__json_set_take(obj, key, &tmp);
+}
+
+static int tg3__json_set_bool(tg3json_value *obj, const char *key, int value) {
+    tg3json_value tmp;
+    tg3json_value_init_bool(&tmp, value);
+    return tg3__json_set_take(obj, key, &tmp);
+}
+
+static int tg3__json_set_string_n(tg3json_value *obj, const char *key, const char *str, size_t len) {
+    tg3json_value tmp;
+    if (!tg3json_value_init_string_n(&tmp, str, len)) return 0;
+    return tg3__json_set_take(obj, key, &tmp);
+}
+
+static int tg3__json_set_string(tg3json_value *obj, const char *key, const char *str) {
+    return tg3__json_set_string_n(obj, key, str, str ? strlen(str) : 0);
+}
+
+static int tg3__json_set_value_copy(tg3json_value *obj, const char *key, const tg3json_value *value) {
+    return tg3json_object_set_copy(obj, key, value);
+}
+
+static int tg3__json_array_append_int(tg3json_value *arr, int64_t value) {
+    tg3json_value tmp;
+    tg3json_value_init_int(&tmp, value);
+    return tg3__json_push_take(arr, &tmp);
+}
+
+static int tg3__json_array_append_real(tg3json_value *arr, double value) {
+    tg3json_value tmp;
+    tg3json_value_init_real(&tmp, value);
+    return tg3__json_push_take(arr, &tmp);
+}
+
+static int tg3__json_ensure_object(tg3json_value *obj, const char *key, tg3json_value **out_child) {
+    tg3json_value *existing = tg3json_object_get_mut(obj, key);
+    if (existing) {
+        if (existing->type != TG3JSON_OBJECT) return 0;
+        *out_child = existing;
+        return 1;
+    }
+    {
+        tg3json_value tmp;
+        tg3json_value_init_object(&tmp);
+        if (!tg3__json_set_take(obj, key, &tmp)) return 0;
+    }
+    existing = tg3json_object_get_mut(obj, key);
+    if (!existing || existing->type != TG3JSON_OBJECT) return 0;
+    *out_child = existing;
+    return 1;
+}
+
+static int tg3__json_ensure_array(tg3json_value *obj, const char *key, tg3json_value **out_child) {
+    tg3json_value *existing = tg3json_object_get_mut(obj, key);
+    if (existing) {
+        if (existing->type != TG3JSON_ARRAY) return 0;
+        *out_child = existing;
+        return 1;
+    }
+    {
+        tg3json_value tmp;
+        tg3json_value_init_array(&tmp);
+        if (!tg3__json_set_take(obj, key, &tmp)) return 0;
+    }
+    existing = tg3json_object_get_mut(obj, key);
+    if (!existing || existing->type != TG3JSON_ARRAY) return 0;
+    *out_child = existing;
+    return 1;
+}
+
+static int tg3__serialize_str(tg3json_value *o, const char *key, tg3_str val) {
+    if (!val.data || val.len == 0) return 1;
+    return tg3__json_set_string_n(o, key, val.data, val.len);
+}
+
+static int tg3__serialize_int(tg3json_value *o, const char *key, int32_t val,
+                              int32_t default_val, int write_defaults) {
+    if (val == default_val && !write_defaults) return 1;
+    return tg3__json_set_int(o, key, val);
+}
+
+static int tg3__serialize_uint64(tg3json_value *o, const char *key, uint64_t val,
+                                 uint64_t default_val, int write_defaults) {
+    if (val == default_val && !write_defaults) return 1;
+    return tg3__json_set_int(o, key, (int64_t)val);
+}
+
+static int tg3__serialize_double(tg3json_value *o, const char *key, double val,
+                                 double default_val, int write_defaults) {
+    if (fabs(val - default_val) <= 1e-12 && !write_defaults) return 1;
+    return tg3__json_set_real(o, key, val);
+}
+
+static int tg3__serialize_bool(tg3json_value *o, const char *key, int32_t val,
+                               int32_t default_val, int write_defaults) {
+    if (val == default_val && !write_defaults) return 1;
+    return tg3__json_set_bool(o, key, val != 0);
+}
+
+static int tg3__json_from_double_array(const double *arr, uint32_t count, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value_init_array(out);
+    for (i = 0; i < count; ++i) {
+        if (!tg3__json_array_append_real(out, arr[i])) {
+            tg3json_value_free(out);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int tg3__json_from_int_array(const int32_t *arr, uint32_t count, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value_init_array(out);
+    for (i = 0; i < count; ++i) {
+        if (!tg3__json_array_append_int(out, arr[i])) {
+            tg3json_value_free(out);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int tg3__json_from_string_array(const tg3_str *arr, uint32_t count, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value_init_array(out);
+    for (i = 0; i < count; ++i) {
+        tg3json_value tmp;
+        if (!arr[i].data) continue;
+        if (!tg3json_value_init_string_n(&tmp, arr[i].data, arr[i].len)) {
+            tg3json_value_free(out);
+            return 0;
+        }
+        if (!tg3__json_push_take(out, &tmp)) {
+            tg3json_value_free(out);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int tg3__serialize_double_array(tg3json_value *o, const char *key,
+                                       const double *arr, uint32_t count) {
+    tg3json_value tmp;
+    if (!arr || count == 0) return 1;
+    if (!tg3__json_from_double_array(arr, count, &tmp)) return 0;
+    return tg3__json_set_take(o, key, &tmp);
+}
+
+static int tg3__serialize_int_array(tg3json_value *o, const char *key,
+                                    const int32_t *arr, uint32_t count) {
+    tg3json_value tmp;
+    if (!arr || count == 0) return 1;
+    if (!tg3__json_from_int_array(arr, count, &tmp)) return 0;
+    return tg3__json_set_take(o, key, &tmp);
+}
+
+static int tg3__serialize_string_array(tg3json_value *o, const char *key,
+                                       const tg3_str *arr, uint32_t count) {
+    tg3json_value tmp;
+    if (!arr || count == 0) return 1;
+    if (!tg3__json_from_string_array(arr, count, &tmp)) return 0;
+    return tg3__json_set_take(o, key, &tmp);
+}
+
+static int tg3__value_to_json(const tg3_value *v, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value_init_null(out);
+    if (!v) return 1;
+    switch (v->type) {
+        case TG3_VALUE_NULL:
+            return 1;
+        case TG3_VALUE_BOOL:
+            tg3json_value_init_bool(out, v->bool_val != 0);
+            return 1;
+        case TG3_VALUE_INT:
+            tg3json_value_init_int(out, v->int_val);
+            return 1;
+        case TG3_VALUE_REAL:
+            tg3json_value_init_real(out, v->real_val);
+            return 1;
+        case TG3_VALUE_STRING:
+            return tg3json_value_init_string_n(out,
+                v->string_val.data ? v->string_val.data : "",
+                v->string_val.data ? v->string_val.len : 0);
+        case TG3_VALUE_ARRAY:
+            tg3json_value_init_array(out);
+            for (i = 0; i < v->array_count; ++i) {
+                tg3json_value item;
+                if (!tg3__value_to_json(&v->array_data[i], &item)) {
+                    tg3json_value_free(out);
+                    return 0;
+                }
+                if (!tg3__json_push_take(out, &item)) {
+                    tg3json_value_free(out);
+                    return 0;
+                }
+            }
+            return 1;
+        case TG3_VALUE_OBJECT:
+            tg3json_value_init_object(out);
+            for (i = 0; i < v->object_count; ++i) {
+                tg3json_value item;
+                if (!tg3__value_to_json(&v->object_data[i].value, &item)) {
+                    tg3json_value_free(out);
+                    return 0;
+                }
+                if (!tg3json_object_set_take_n(out,
+                                               v->object_data[i].key.data ? v->object_data[i].key.data : "",
+                                               v->object_data[i].key.data ? v->object_data[i].key.len : 0,
+                                               &item)) {
+                    tg3json_value_free(&item);
+                    tg3json_value_free(out);
+                    return 0;
+                }
+            }
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+static int tg3__serialize_extras_ext(tg3json_value *o, const tg3_extras_ext *ee) {
+    uint32_t i;
+    if (!ee) return 1;
+    if (ee->extras) {
+        tg3json_value extras;
+        if (!tg3__value_to_json(ee->extras, &extras)) return 0;
+        if (!tg3__json_set_take(o, "extras", &extras)) return 0;
+    }
+    if (ee->extensions && ee->extensions_count > 0) {
+        tg3json_value *exts = NULL;
+        if (!tg3__json_ensure_object(o, "extensions", &exts)) return 0;
+        for (i = 0; i < ee->extensions_count; ++i) {
+            tg3json_value item;
+            if (!tg3__value_to_json(&ee->extensions[i].value, &item)) return 0;
+            if (!tg3json_object_set_take_n(exts,
+                                           ee->extensions[i].name.data ? ee->extensions[i].name.data : "",
+                                           ee->extensions[i].name.data ? ee->extensions[i].name.len : 0,
+                                           &item)) {
+                tg3json_value_free(&item);
+                return 0;
+            }
+        }
+    }
+    return 1;
+}
+
+static int tg3__serialize_texture_info(tg3json_value *parent, const char *key,
+                                       const tg3_texture_info *ti, int wd) {
+    tg3json_value o;
+    if (ti->index < 0) return 1;
+    tg3json_value_init_object(&o);
+    if (!tg3__json_set_int(&o, "index", ti->index) ||
+        !tg3__serialize_int(&o, "texCoord", ti->tex_coord, 0, wd) ||
+        !tg3__serialize_extras_ext(&o, &ti->ext) ||
+        !tg3__json_set_take(parent, key, &o)) {
+        tg3json_value_free(&o);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_normal_texture_info(tg3json_value *parent, const char *key,
+                                              const tg3_normal_texture_info *ti, int wd) {
+    tg3json_value o;
+    if (ti->index < 0) return 1;
+    tg3json_value_init_object(&o);
+    if (!tg3__json_set_int(&o, "index", ti->index) ||
+        !tg3__serialize_int(&o, "texCoord", ti->tex_coord, 0, wd) ||
+        !tg3__serialize_double(&o, "scale", ti->scale, 1.0, wd) ||
+        !tg3__serialize_extras_ext(&o, &ti->ext) ||
+        !tg3__json_set_take(parent, key, &o)) {
+        tg3json_value_free(&o);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_occlusion_texture_info(tg3json_value *parent, const char *key,
+                                                 const tg3_occlusion_texture_info *ti, int wd) {
+    tg3json_value o;
+    if (ti->index < 0) return 1;
+    tg3json_value_init_object(&o);
+    if (!tg3__json_set_int(&o, "index", ti->index) ||
+        !tg3__serialize_int(&o, "texCoord", ti->tex_coord, 0, wd) ||
+        !tg3__serialize_double(&o, "strength", ti->strength, 1.0, wd) ||
+        !tg3__serialize_extras_ext(&o, &ti->ext) ||
+        !tg3__json_set_take(parent, key, &o)) {
+        tg3json_value_free(&o);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_asset(const tg3_asset *a, int wd, tg3json_value *out) {
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "version", a->version) ||
+        !tg3__serialize_str(out, "generator", a->generator) ||
+        !tg3__serialize_str(out, "minVersion", a->min_version) ||
+        !tg3__serialize_str(out, "copyright", a->copyright) ||
+        !tg3__serialize_extras_ext(out, &a->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_buffer(const tg3_buffer *b, int wd, int embed, tg3json_value *out) {
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", b->name) ||
+        !tg3__json_set_int(out, "byteLength", (int64_t)b->data.count)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (b->uri.data && b->uri.len > 0) {
+        if (!tg3__serialize_str(out, "uri", b->uri)) {
+            tg3json_value_free(out);
+            return 0;
+        }
+    } else if (embed && b->data.data && b->data.count > 0) {
+        size_t enc_len = 0;
+        char *encoded = tg3__b64_encode(b->data.data, (size_t)b->data.count, &enc_len);
+        const char prefix[] = "data:application/octet-stream;base64,";
+        size_t prefix_len = sizeof(prefix) - 1u;
+        char *uri;
+        if (!encoded) {
+            tg3json_value_free(out);
+            return 0;
+        }
+        uri = (char *)malloc(prefix_len + enc_len + 1u);
+        if (!uri) {
+            free(encoded);
+            tg3json_value_free(out);
+            return 0;
+        }
+        memcpy(uri, prefix, prefix_len);
+        memcpy(uri + prefix_len, encoded, enc_len);
+        uri[prefix_len + enc_len] = '\0';
+        free(encoded);
+        if (!tg3__json_set_string_n(out, "uri", uri, prefix_len + enc_len)) {
+            free(uri);
+            tg3json_value_free(out);
+            return 0;
+        }
+        free(uri);
+    }
+    if (!tg3__serialize_extras_ext(out, &b->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_buffer_view(const tg3_buffer_view *bv, int wd, tg3json_value *out) {
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", bv->name) ||
+        !tg3__json_set_int(out, "buffer", bv->buffer) ||
+        !tg3__json_set_int(out, "byteLength", (int64_t)bv->byte_length) ||
+        !tg3__serialize_uint64(out, "byteOffset", bv->byte_offset, 0, wd)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (bv->byte_stride > 0 && !tg3__json_set_int(out, "byteStride", bv->byte_stride)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (!tg3__serialize_int(out, "target", bv->target, 0, wd) ||
+        !tg3__serialize_extras_ext(out, &bv->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_accessor(const tg3_accessor *acc, int wd, tg3json_value *out) {
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", acc->name) ||
+        !tg3__serialize_uint64(out, "byteOffset", acc->byte_offset, 0, wd) ||
+        !tg3__json_set_int(out, "componentType", acc->component_type) ||
+        !tg3__json_set_int(out, "count", (int64_t)acc->count) ||
+        !tg3__json_set_string(out, "type", tg3__accessor_type_to_string(acc->type)) ||
+        !tg3__serialize_bool(out, "normalized", acc->normalized, 0, wd) ||
+        !tg3__serialize_double_array(out, "min", acc->min_values, acc->min_values_count) ||
+        !tg3__serialize_double_array(out, "max", acc->max_values, acc->max_values_count)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (acc->buffer_view >= 0 && !tg3__json_set_int(out, "bufferView", acc->buffer_view)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (acc->sparse.is_sparse) {
+        tg3json_value sparse, indices, values;
+        tg3json_value_init_object(&sparse);
+        tg3json_value_init_object(&indices);
+        tg3json_value_init_object(&values);
+        if (!tg3__json_set_int(&sparse, "count", acc->sparse.count) ||
+            !tg3__json_set_int(&indices, "bufferView", acc->sparse.indices.buffer_view) ||
+            !tg3__json_set_int(&indices, "componentType", acc->sparse.indices.component_type) ||
+            !tg3__serialize_uint64(&indices, "byteOffset", acc->sparse.indices.byte_offset, 0, wd) ||
+            !tg3__serialize_extras_ext(&indices, &acc->sparse.indices.ext) ||
+            !tg3__json_set_take(&sparse, "indices", &indices) ||
+            !tg3__json_set_int(&values, "bufferView", acc->sparse.values.buffer_view) ||
+            !tg3__serialize_uint64(&values, "byteOffset", acc->sparse.values.byte_offset, 0, wd) ||
+            !tg3__serialize_extras_ext(&values, &acc->sparse.values.ext) ||
+            !tg3__json_set_take(&sparse, "values", &values) ||
+            !tg3__serialize_extras_ext(&sparse, &acc->sparse.ext) ||
+            !tg3__json_set_take(out, "sparse", &sparse)) {
+            tg3json_value_free(&indices);
+            tg3json_value_free(&values);
+            tg3json_value_free(&sparse);
+            tg3json_value_free(out);
+            return 0;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &acc->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_image(const tg3_image *img, int wd, int embed, tg3json_value *out) {
+    (void)wd;
+    (void)embed;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", img->name) ||
+        !tg3__serialize_str(out, "uri", img->uri) ||
+        !tg3__serialize_str(out, "mimeType", img->mime_type) ||
+        !tg3__serialize_extras_ext(out, &img->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (img->buffer_view >= 0 && !tg3__json_set_int(out, "bufferView", img->buffer_view)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_sampler(const tg3_sampler *s, int wd, tg3json_value *out) {
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", s->name) ||
+        !tg3__serialize_int(out, "wrapS", s->wrap_s, TG3_TEXTURE_WRAP_REPEAT, wd) ||
+        !tg3__serialize_int(out, "wrapT", s->wrap_t, TG3_TEXTURE_WRAP_REPEAT, wd) ||
+        !tg3__serialize_extras_ext(out, &s->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (s->min_filter >= 0 && !tg3__json_set_int(out, "minFilter", s->min_filter)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (s->mag_filter >= 0 && !tg3__json_set_int(out, "magFilter", s->mag_filter)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_texture(const tg3_texture *t, int wd, tg3json_value *out) {
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", t->name) ||
+        !tg3__serialize_extras_ext(out, &t->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (t->sampler >= 0 && !tg3__json_set_int(out, "sampler", t->sampler)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (t->source >= 0 && !tg3__json_set_int(out, "source", t->source)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_material(const tg3_material *m, int wd, tg3json_value *out) {
+    tg3json_value pbr;
+    int has_pbr = 0;
+    const tg3_pbr_metallic_roughness *p = &m->pbr_metallic_roughness;
+    tg3json_value_init_object(out);
+    tg3json_value_init_object(&pbr);
+    if (!tg3__serialize_str(out, "name", m->name)) goto fail;
+    if (p->base_color_factor[0] != 1.0 || p->base_color_factor[1] != 1.0 ||
+        p->base_color_factor[2] != 1.0 || p->base_color_factor[3] != 1.0 || wd) {
+        if (!tg3__serialize_double_array(&pbr, "baseColorFactor", p->base_color_factor, 4)) goto fail;
+        has_pbr = 1;
+    }
+    if (!tg3__serialize_double(&pbr, "metallicFactor", p->metallic_factor, 1.0, wd)) goto fail;
+    if (fabs(p->metallic_factor - 1.0) > 1e-12 || wd) has_pbr = 1;
+    if (!tg3__serialize_double(&pbr, "roughnessFactor", p->roughness_factor, 1.0, wd)) goto fail;
+    if (fabs(p->roughness_factor - 1.0) > 1e-12 || wd) has_pbr = 1;
+    if (p->base_color_texture.index >= 0) {
+        if (!tg3__serialize_texture_info(&pbr, "baseColorTexture", &p->base_color_texture, wd)) goto fail;
+        has_pbr = 1;
+    }
+    if (p->metallic_roughness_texture.index >= 0) {
+        if (!tg3__serialize_texture_info(&pbr, "metallicRoughnessTexture", &p->metallic_roughness_texture, wd)) goto fail;
+        has_pbr = 1;
+    }
+    if (!tg3__serialize_extras_ext(&pbr, &p->ext)) goto fail;
+    if ((has_pbr || wd) && !tg3__json_set_take(out, "pbrMetallicRoughness", &pbr)) goto fail;
+    if (!tg3__serialize_normal_texture_info(out, "normalTexture", &m->normal_texture, wd) ||
+        !tg3__serialize_occlusion_texture_info(out, "occlusionTexture", &m->occlusion_texture, wd) ||
+        !tg3__serialize_texture_info(out, "emissiveTexture", &m->emissive_texture, wd)) goto fail;
+    if ((m->emissive_factor[0] != 0.0 || m->emissive_factor[1] != 0.0 ||
+         m->emissive_factor[2] != 0.0 || wd) &&
+        !tg3__serialize_double_array(out, "emissiveFactor", m->emissive_factor, 3)) goto fail;
+    if (m->alpha_mode.data && !tg3_str_equals_cstr(m->alpha_mode, "OPAQUE") &&
+        !tg3__serialize_str(out, "alphaMode", m->alpha_mode)) goto fail;
+    if (!tg3__serialize_double(out, "alphaCutoff", m->alpha_cutoff, 0.5, wd) ||
+        !tg3__serialize_bool(out, "doubleSided", m->double_sided, 0, wd) ||
+        !tg3__serialize_extras_ext(out, &m->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(&pbr);
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_primitive(const tg3_primitive *p, int wd, tg3json_value *out) {
+    tg3json_value attrs, targets;
+    uint32_t i;
+    tg3json_value_init_object(out);
+    if (p->attributes && p->attributes_count > 0) {
+        tg3json_value_init_object(&attrs);
+        for (i = 0; i < p->attributes_count; ++i) {
+            tg3json_value item;
+            tg3json_value_init_int(&item, p->attributes[i].value);
+            if (!tg3json_object_set_take_n(&attrs,
+                                           p->attributes[i].key.data ? p->attributes[i].key.data : "",
+                                           p->attributes[i].key.data ? p->attributes[i].key.len : 0,
+                                           &item)) {
+                tg3json_value_free(&item);
+                tg3json_value_free(&attrs);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(out, "attributes", &attrs)) {
+            tg3json_value_free(&attrs);
+            goto fail;
+        }
+    }
+    if (p->indices >= 0 && !tg3__json_set_int(out, "indices", p->indices)) goto fail;
+    if (p->material >= 0 && !tg3__json_set_int(out, "material", p->material)) goto fail;
+    if (!tg3__serialize_int(out, "mode", p->mode, TG3_MODE_TRIANGLES, wd)) goto fail;
+    if (p->targets && p->targets_count > 0) {
+        uint32_t t;
+        tg3json_value_init_array(&targets);
+        for (t = 0; t < p->targets_count; ++t) {
+            tg3json_value tgt;
+            uint32_t acount = p->target_attribute_counts ? p->target_attribute_counts[t] : 0;
+            tg3json_value_init_object(&tgt);
+            for (i = 0; i < acount; ++i) {
+                tg3json_value item;
+                tg3json_value_init_int(&item, p->targets[t][i].value);
+                if (!tg3json_object_set_take_n(&tgt,
+                                               p->targets[t][i].key.data ? p->targets[t][i].key.data : "",
+                                               p->targets[t][i].key.data ? p->targets[t][i].key.len : 0,
+                                               &item)) {
+                    tg3json_value_free(&item);
+                    tg3json_value_free(&tgt);
+                    tg3json_value_free(&targets);
+                    goto fail;
+                }
+            }
+            if (!tg3__json_push_take(&targets, &tgt)) {
+                tg3json_value_free(&tgt);
+                tg3json_value_free(&targets);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(out, "targets", &targets)) {
+            tg3json_value_free(&targets);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &p->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_mesh(const tg3_mesh *m, int wd, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value prims;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", m->name)) goto fail;
+    if (m->primitives && m->primitives_count > 0) {
+        tg3json_value_init_array(&prims);
+        for (i = 0; i < m->primitives_count; ++i) {
+            tg3json_value prim;
+            if (!tg3__serialize_primitive(&m->primitives[i], wd, &prim) ||
+                !tg3__json_push_take(&prims, &prim)) {
+                tg3json_value_free(&prim);
+                tg3json_value_free(&prims);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(out, "primitives", &prims)) {
+            tg3json_value_free(&prims);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_double_array(out, "weights", m->weights, m->weights_count) ||
+        !tg3__serialize_extras_ext(out, &m->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_node(const tg3_node *n, int wd, tg3json_value *out) {
+    tg3json_value *exts = NULL;
+    tg3json_value tmp;
+    int has_t, has_r, has_s;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", n->name) ||
+        !tg3__serialize_int_array(out, "children", n->children, n->children_count)) goto fail;
+    if (n->camera >= 0 && !tg3__json_set_int(out, "camera", n->camera)) goto fail;
+    if (n->skin >= 0 && !tg3__json_set_int(out, "skin", n->skin)) goto fail;
+    if (n->mesh >= 0 && !tg3__json_set_int(out, "mesh", n->mesh)) goto fail;
+    if (n->has_matrix) {
+        if (!tg3__serialize_double_array(out, "matrix", n->matrix, 16)) goto fail;
+    } else {
+        has_t = (n->translation[0] != 0.0 || n->translation[1] != 0.0 || n->translation[2] != 0.0);
+        has_r = (n->rotation[0] != 0.0 || n->rotation[1] != 0.0 || n->rotation[2] != 0.0 || n->rotation[3] != 1.0);
+        has_s = (n->scale[0] != 1.0 || n->scale[1] != 1.0 || n->scale[2] != 1.0);
+        if ((has_t || wd) && !tg3__serialize_double_array(out, "translation", n->translation, 3)) goto fail;
+        if ((has_r || wd) && !tg3__serialize_double_array(out, "rotation", n->rotation, 4)) goto fail;
+        if ((has_s || wd) && !tg3__serialize_double_array(out, "scale", n->scale, 3)) goto fail;
+    }
+    if (!tg3__serialize_double_array(out, "weights", n->weights, n->weights_count) ||
+        !tg3__serialize_extras_ext(out, &n->ext)) goto fail;
+    if (n->light >= 0 || n->emitter >= 0 || (n->lods && n->lods_count > 0)) {
+        if (!tg3__json_ensure_object(out, "extensions", &exts)) goto fail;
+        if (n->light >= 0) {
+            tg3json_value_init_object(&tmp);
+            if (!tg3__json_set_int(&tmp, "light", n->light) ||
+                !tg3__json_set_take(exts, "KHR_lights_punctual", &tmp)) {
+                tg3json_value_free(&tmp);
+                goto fail;
+            }
+        }
+        if (n->emitter >= 0) {
+            tg3json_value_init_object(&tmp);
+            if (!tg3__json_set_int(&tmp, "emitter", n->emitter) ||
+                !tg3__json_set_take(exts, "KHR_audio", &tmp)) {
+                tg3json_value_free(&tmp);
+                goto fail;
+            }
+        }
+        if (n->lods && n->lods_count > 0) {
+            tg3json_value_init_object(&tmp);
+            if (!tg3__serialize_int_array(&tmp, "ids", n->lods, n->lods_count) ||
+                !tg3__json_set_take(exts, "MSFT_lod", &tmp)) {
+                tg3json_value_free(&tmp);
+                goto fail;
+            }
+        }
+    }
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_skin(const tg3_skin *s, int wd, tg3json_value *out) {
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", s->name) ||
+        !tg3__serialize_int_array(out, "joints", s->joints, s->joints_count) ||
+        !tg3__serialize_extras_ext(out, &s->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (s->inverse_bind_matrices >= 0 &&
+        !tg3__json_set_int(out, "inverseBindMatrices", s->inverse_bind_matrices)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    if (s->skeleton >= 0 && !tg3__json_set_int(out, "skeleton", s->skeleton)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_animation(const tg3_animation *a, int wd, tg3json_value *out) {
+    uint32_t i;
+    tg3json_value channels, samplers;
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", a->name)) goto fail;
+    if (a->channels && a->channels_count > 0) {
+        tg3json_value_init_array(&channels);
+        for (i = 0; i < a->channels_count; ++i) {
+            tg3json_value ch, tgt;
+            tg3json_value_init_object(&ch);
+            tg3json_value_init_object(&tgt);
+            if (a->channels[i].target.node >= 0 &&
+                !tg3__json_set_int(&tgt, "node", a->channels[i].target.node)) {
+                tg3json_value_free(&tgt);
+                tg3json_value_free(&ch);
+                tg3json_value_free(&channels);
+                goto fail;
+            }
+            if (!tg3__json_set_int(&ch, "sampler", a->channels[i].sampler) ||
+                !tg3__serialize_str(&tgt, "path", a->channels[i].target.path) ||
+                !tg3__serialize_extras_ext(&tgt, &a->channels[i].target.ext) ||
+                !tg3__json_set_take(&ch, "target", &tgt) ||
+                !tg3__serialize_extras_ext(&ch, &a->channels[i].ext) ||
+                !tg3__json_push_take(&channels, &ch)) {
+                tg3json_value_free(&tgt);
+                tg3json_value_free(&ch);
+                tg3json_value_free(&channels);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(out, "channels", &channels)) {
+            tg3json_value_free(&channels);
+            goto fail;
+        }
+    }
+    if (a->samplers && a->samplers_count > 0) {
+        tg3json_value_init_array(&samplers);
+        for (i = 0; i < a->samplers_count; ++i) {
+            tg3json_value s;
+            tg3json_value_init_object(&s);
+            if (!tg3__json_set_int(&s, "input", a->samplers[i].input) ||
+                !tg3__json_set_int(&s, "output", a->samplers[i].output) ||
+                !tg3__serialize_str(&s, "interpolation", a->samplers[i].interpolation) ||
+                !tg3__serialize_extras_ext(&s, &a->samplers[i].ext) ||
+                !tg3__json_push_take(&samplers, &s)) {
+                tg3json_value_free(&s);
+                tg3json_value_free(&samplers);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(out, "samplers", &samplers)) {
+            tg3json_value_free(&samplers);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &a->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_camera(const tg3_camera *c, int wd, tg3json_value *out) {
+    tg3json_value tmp;
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", c->name) ||
+        !tg3__serialize_str(out, "type", c->type)) goto fail;
+    if (c->type.data && tg3_str_equals_cstr(c->type, "perspective")) {
+        tg3json_value_init_object(&tmp);
+        if ((c->perspective.aspect_ratio > 0.0 &&
+             !tg3__json_set_real(&tmp, "aspectRatio", c->perspective.aspect_ratio)) ||
+            !tg3__json_set_real(&tmp, "yfov", c->perspective.yfov) ||
+            (c->perspective.zfar > 0.0 &&
+             !tg3__json_set_real(&tmp, "zfar", c->perspective.zfar)) ||
+            !tg3__json_set_real(&tmp, "znear", c->perspective.znear) ||
+            !tg3__serialize_extras_ext(&tmp, &c->perspective.ext) ||
+            !tg3__json_set_take(out, "perspective", &tmp)) {
+            tg3json_value_free(&tmp);
+            goto fail;
+        }
+    } else if (c->type.data && tg3_str_equals_cstr(c->type, "orthographic")) {
+        tg3json_value_init_object(&tmp);
+        if (!tg3__json_set_real(&tmp, "xmag", c->orthographic.xmag) ||
+            !tg3__json_set_real(&tmp, "ymag", c->orthographic.ymag) ||
+            !tg3__json_set_real(&tmp, "zfar", c->orthographic.zfar) ||
+            !tg3__json_set_real(&tmp, "znear", c->orthographic.znear) ||
+            !tg3__serialize_extras_ext(&tmp, &c->orthographic.ext) ||
+            !tg3__json_set_take(out, "orthographic", &tmp)) {
+            tg3json_value_free(&tmp);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &c->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_scene(const tg3_scene *s, int wd, tg3json_value *out) {
+    (void)wd;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", s->name) ||
+        !tg3__serialize_int_array(out, "nodes", s->nodes, s->nodes_count) ||
+        !tg3__serialize_extras_ext(out, &s->ext)) {
+        tg3json_value_free(out);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3__serialize_light(const tg3_light *l, int wd, tg3json_value *out) {
+    tg3json_value spot;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_str(out, "name", l->name) ||
+        !tg3__serialize_str(out, "type", l->type) ||
+        !tg3__serialize_double(out, "intensity", l->intensity, 1.0, wd) ||
+        !tg3__serialize_double(out, "range", l->range, 0.0, wd)) goto fail;
+    if ((l->color[0] != 1.0 || l->color[1] != 1.0 || l->color[2] != 1.0 || wd) &&
+        !tg3__serialize_double_array(out, "color", l->color, 3)) goto fail;
+    if (l->type.data && tg3_str_equals_cstr(l->type, "spot")) {
+        tg3json_value_init_object(&spot);
+        if (!tg3__serialize_double(&spot, "innerConeAngle", l->spot.inner_cone_angle, 0.0, wd) ||
+            !tg3__serialize_double(&spot, "outerConeAngle", l->spot.outer_cone_angle, 0.7853981634, wd) ||
+            !tg3__serialize_extras_ext(&spot, &l->spot.ext) ||
+            !tg3__json_set_take(out, "spot", &spot)) {
+            tg3json_value_free(&spot);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &l->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+static int tg3__serialize_model(const tg3_model *model, int wd,
+                                int embed_images, int embed_buffers,
+                                tg3json_value *out) {
+    tg3json_value asset, arr, item, lights_ext, lights, *exts;
+    uint32_t i;
+    tg3json_value_init_object(out);
+    if (!tg3__serialize_asset(&model->asset, wd, &asset) ||
+        !tg3__json_set_take(out, "asset", &asset)) goto fail;
+    if (model->default_scene >= 0 && !tg3__json_set_int(out, "scene", model->default_scene)) goto fail;
+    if (!tg3__serialize_string_array(out, "extensionsUsed", model->extensions_used, model->extensions_used_count) ||
+        !tg3__serialize_string_array(out, "extensionsRequired", model->extensions_required, model->extensions_required_count)) goto fail;
+
+#define TG3__SERIALIZE_ARRAY_FIELD(json_key, arr_ptr, arr_count, fn, ...) \
+    do { \
+        if ((arr_ptr) && (arr_count) > 0) { \
+            tg3json_value_init_array(&arr); \
+            for (i = 0; i < (arr_count); ++i) { \
+                tg3json_value_init_null(&item); \
+                if (!fn(&(arr_ptr)[i], __VA_ARGS__, &item) || !tg3__json_push_take(&arr, &item)) { \
+                    tg3json_value_free(&item); \
+                    tg3json_value_free(&arr); \
+                    goto fail; \
+                } \
+            } \
+            if (!tg3__json_set_take(out, json_key, &arr)) { \
+                tg3json_value_free(&arr); \
+                goto fail; \
+            } \
+        } \
+    } while (0)
+
+    TG3__SERIALIZE_ARRAY_FIELD("buffers", model->buffers, model->buffers_count, tg3__serialize_buffer, wd, embed_buffers);
+    TG3__SERIALIZE_ARRAY_FIELD("bufferViews", model->buffer_views, model->buffer_views_count, tg3__serialize_buffer_view, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("accessors", model->accessors, model->accessors_count, tg3__serialize_accessor, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("meshes", model->meshes, model->meshes_count, tg3__serialize_mesh, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("nodes", model->nodes, model->nodes_count, tg3__serialize_node, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("materials", model->materials, model->materials_count, tg3__serialize_material, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("textures", model->textures, model->textures_count, tg3__serialize_texture, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("samplers", model->samplers, model->samplers_count, tg3__serialize_sampler, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("images", model->images, model->images_count, tg3__serialize_image, wd, embed_images);
+    TG3__SERIALIZE_ARRAY_FIELD("skins", model->skins, model->skins_count, tg3__serialize_skin, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("animations", model->animations, model->animations_count, tg3__serialize_animation, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("cameras", model->cameras, model->cameras_count, tg3__serialize_camera, wd);
+    TG3__SERIALIZE_ARRAY_FIELD("scenes", model->scenes, model->scenes_count, tg3__serialize_scene, wd);
+
+#undef TG3__SERIALIZE_ARRAY_FIELD
+
+    if (model->lights && model->lights_count > 0) {
+        tg3json_value_init_object(&lights_ext);
+        tg3json_value_init_array(&lights);
+        for (i = 0; i < model->lights_count; ++i) {
+            tg3json_value_init_null(&item);
+            if (!tg3__serialize_light(&model->lights[i], wd, &item) ||
+                !tg3__json_push_take(&lights, &item)) {
+                tg3json_value_free(&item);
+                tg3json_value_free(&lights);
+                tg3json_value_free(&lights_ext);
+                goto fail;
+            }
+        }
+        if (!tg3__json_set_take(&lights_ext, "lights", &lights) ||
+            !tg3__json_ensure_object(out, "extensions", &exts) ||
+            !tg3__json_set_take(exts, "KHR_lights_punctual", &lights_ext)) {
+            tg3json_value_free(&lights);
+            tg3json_value_free(&lights_ext);
+            goto fail;
+        }
+    }
+    if (!tg3__serialize_extras_ext(out, &model->ext)) goto fail;
+    return 1;
+fail:
+    tg3json_value_free(out);
+    return 0;
+}
+
+TINYGLTF3_API tg3_error_code tg3_write_to_memory(const tg3_model *model, tg3_error_stack *errors,
+                                                 uint8_t **out_data, uint64_t *out_size,
+                                                 const tg3_write_options *options) {
+    tg3_write_options default_opts;
+    tg3json_value root;
+    char *json_str;
+    size_t json_len;
+    if (out_data) *out_data = NULL;
+    if (out_size) *out_size = 0;
+    if (!model || !out_data || !out_size) return TG3_ERR_WRITE_FAILED;
+    if (!options) {
+        tg3_write_options_init(&default_opts);
+        options = &default_opts;
+    }
+    if (!tg3__serialize_model(model, options->serialize_defaults,
+                              options->embed_images, options->embed_buffers, &root)) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                        "Failed to serialize model to JSON tree", NULL, -1);
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    json_str = options->pretty_print
+        ? tg3json_stringify_pretty(&root, 2, &json_len)
+        : tg3json_stringify(&root, &json_len);
+    tg3json_value_free(&root);
+    if (!json_str) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                        "Failed to stringify JSON output", NULL, -1);
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    if (options->write_binary) {
+        uint32_t json_padded = ((uint32_t)json_len + 3u) & ~3u;
+        const uint8_t *bin_data = NULL;
+        uint64_t bin_len = 0;
+        uint32_t bin_padded;
+        uint32_t total;
+        uint8_t *glb;
+        if (model->buffers_count > 0 && model->buffers && model->buffers[0].data.data) {
+            bin_data = model->buffers[0].data.data;
+            bin_len = model->buffers[0].data.count;
+        }
+        bin_padded = ((uint32_t)bin_len + 3u) & ~3u;
+        total = 12u + 8u + json_padded + ((bin_data && bin_len > 0) ? (8u + bin_padded) : 0u);
+        glb = (uint8_t *)malloc(total);
+        if (!glb) {
+            free(json_str);
+            tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                            "OOM allocating GLB output", NULL, -1);
+            return TG3_ERR_OUT_OF_MEMORY;
+        }
+        memcpy(glb, "glTF", 4);
+        {
+            uint32_t version = 2u;
+            uint32_t json_type = 0x4E4F534Au;
+            memcpy(glb + 4, &version, 4);
+            memcpy(glb + 8, &total, 4);
+            memcpy(glb + 12, &json_padded, 4);
+            memcpy(glb + 16, &json_type, 4);
+            memcpy(glb + 20, json_str, json_len);
+        }
+        while ((uint32_t)json_len < json_padded) {
+            glb[20u + json_len] = ' ';
+            ++json_len;
+        }
+        if (bin_data && bin_len > 0) {
+            uint32_t bin_off = 20u + json_padded;
+            uint32_t bin_type = 0x004E4942u;
+            uint32_t i;
+            memcpy(glb + bin_off, &bin_padded, 4);
+            memcpy(glb + bin_off + 4u, &bin_type, 4);
+            memcpy(glb + bin_off + 8u, bin_data, (size_t)bin_len);
+            for (i = (uint32_t)bin_len; i < bin_padded; ++i) glb[bin_off + 8u + i] = 0;
+        }
+        free(json_str);
+        *out_data = glb;
+        *out_size = total;
+        return TG3_OK;
+    } else {
+        uint8_t *data = (uint8_t *)malloc(json_len);
+        if (!data) {
+            free(json_str);
+            tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_OUT_OF_MEMORY,
+                            "OOM allocating JSON output", NULL, -1);
+            return TG3_ERR_OUT_OF_MEMORY;
+        }
+        memcpy(data, json_str, json_len);
+        free(json_str);
+        *out_data = data;
+        *out_size = (uint64_t)json_len;
+        return TG3_OK;
+    }
+}
+
+TINYGLTF3_API tg3_error_code tg3_write_to_file(const tg3_model *model, tg3_error_stack *errors,
+                                               const char *filename, uint32_t filename_len,
+                                               const tg3_write_options *options) {
+    tg3_write_options opts;
+    uint8_t *data = NULL;
+    uint64_t size = 0;
+    tg3_error_code err;
+    int32_t ok;
+    if (options) opts = *options;
+    else tg3_write_options_init(&opts);
+#ifdef TINYGLTF3_ENABLE_FS
+    tg3__set_default_fs(&opts.fs);
+#endif
+    if (!opts.fs.write_file) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_FS_NOT_AVAILABLE,
+                        "No filesystem write callback", NULL, -1);
+        return TG3_ERR_FS_NOT_AVAILABLE;
+    }
+    err = tg3_write_to_memory(model, errors, &data, &size, &opts);
+    if (err != TG3_OK) return err;
+    ok = opts.fs.write_file(filename, filename_len, data, size, opts.fs.user_data);
+    free(data);
+    if (!ok) {
+        tg3__error_push(errors, TG3_SEVERITY_ERROR, TG3_ERR_FILE_WRITE,
+                        "Failed to write file", NULL, -1);
+        return TG3_ERR_FILE_WRITE;
+    }
+    return TG3_OK;
+}
+
+TINYGLTF3_API void tg3_write_free(uint8_t *data, const tg3_write_options *options) {
+    (void)options;
+    free(data);
+}
+
+TINYGLTF3_API tg3_writer *tg3_writer_create(tg3_write_chunk_fn chunk_fn, void *user_data,
+                                            const tg3_write_options *options) {
+    tg3_writer *w = (tg3_writer *)malloc(sizeof(tg3_writer));
+    if (!w) return NULL;
+    memset(w, 0, sizeof(*w));
+    w->chunk_fn = chunk_fn;
+    w->user_data = user_data;
+    if (options) w->options = *options;
+    else tg3_write_options_init(&w->options);
+    tg3json_value_init_object(&w->root);
+    return w;
+}
+
+TINYGLTF3_API tg3_error_code tg3_writer_begin(tg3_writer *w, const tg3_asset *asset) {
+    tg3json_value asset_json;
+    if (!w || !asset) return TG3_ERR_WRITE_FAILED;
+    tg3json_value_init_null(&asset_json);
+    if (!tg3__serialize_asset(asset, w->options.serialize_defaults, &asset_json) ||
+        !tg3__json_set_take(&w->root, "asset", &asset_json)) {
+        tg3json_value_free(&asset_json);
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    w->begun = 1;
+    return TG3_OK;
+}
+
+static tg3_error_code tg3__writer_add_item(tg3_writer *w, const char *json_key, const tg3json_value *item) {
+    tg3json_value *arr = NULL;
+    if (!w || !w->begun) return TG3_ERR_WRITE_FAILED;
+    if (!tg3__json_ensure_array(&w->root, json_key, &arr) ||
+        !tg3json_array_append_copy(arr, item)) {
+        return TG3_ERR_OUT_OF_MEMORY;
+    }
+    return TG3_OK;
+}
+
+#define TG3__WRITER_ADD_IMPL(name, Type, json_key, serialize_fn, ...) \
+    TINYGLTF3_API tg3_error_code tg3_writer_add_##name(tg3_writer *w, const Type *item) { \
+        tg3json_value tmp; \
+        if (!item) return TG3_ERR_WRITE_FAILED; \
+        if (!serialize_fn(item, w->options.serialize_defaults, __VA_ARGS__, &tmp)) return TG3_ERR_OUT_OF_MEMORY; \
+        { tg3_error_code err = tg3__writer_add_item(w, json_key, &tmp); tg3json_value_free(&tmp); return err; } \
+    }
+
+#define TG3__WRITER_ADD_SIMPLE(name, Type, json_key, serialize_fn) \
+    TINYGLTF3_API tg3_error_code tg3_writer_add_##name(tg3_writer *w, const Type *item) { \
+        tg3json_value tmp; \
+        if (!item) return TG3_ERR_WRITE_FAILED; \
+        if (!serialize_fn(item, w->options.serialize_defaults, &tmp)) return TG3_ERR_OUT_OF_MEMORY; \
+        { tg3_error_code err = tg3__writer_add_item(w, json_key, &tmp); tg3json_value_free(&tmp); return err; } \
+    }
+
+TG3__WRITER_ADD_IMPL(buffer, tg3_buffer, "buffers", tg3__serialize_buffer, w->options.embed_buffers)
+TG3__WRITER_ADD_SIMPLE(buffer_view, tg3_buffer_view, "bufferViews", tg3__serialize_buffer_view)
+TG3__WRITER_ADD_SIMPLE(accessor, tg3_accessor, "accessors", tg3__serialize_accessor)
+TG3__WRITER_ADD_SIMPLE(mesh, tg3_mesh, "meshes", tg3__serialize_mesh)
+TG3__WRITER_ADD_SIMPLE(node, tg3_node, "nodes", tg3__serialize_node)
+TG3__WRITER_ADD_SIMPLE(material, tg3_material, "materials", tg3__serialize_material)
+TG3__WRITER_ADD_SIMPLE(texture, tg3_texture, "textures", tg3__serialize_texture)
+TG3__WRITER_ADD_IMPL(image, tg3_image, "images", tg3__serialize_image, w->options.embed_images)
+TG3__WRITER_ADD_SIMPLE(sampler, tg3_sampler, "samplers", tg3__serialize_sampler)
+TG3__WRITER_ADD_SIMPLE(animation, tg3_animation, "animations", tg3__serialize_animation)
+TG3__WRITER_ADD_SIMPLE(skin, tg3_skin, "skins", tg3__serialize_skin)
+TG3__WRITER_ADD_SIMPLE(camera, tg3_camera, "cameras", tg3__serialize_camera)
+TG3__WRITER_ADD_SIMPLE(scene, tg3_scene, "scenes", tg3__serialize_scene)
+TG3__WRITER_ADD_SIMPLE(light, tg3_light, "lights", tg3__serialize_light)
+
+#undef TG3__WRITER_ADD_IMPL
+#undef TG3__WRITER_ADD_SIMPLE
+
+TINYGLTF3_API tg3_error_code tg3_writer_end(tg3_writer *w) {
+    char *json_str;
+    size_t json_len;
+    int32_t ok;
+    if (!w || !w->begun || !w->chunk_fn) return TG3_ERR_WRITE_FAILED;
+    json_str = w->options.pretty_print
+        ? tg3json_stringify_pretty(&w->root, 2, &json_len)
+        : tg3json_stringify(&w->root, &json_len);
+    if (!json_str) return TG3_ERR_OUT_OF_MEMORY;
+    ok = w->chunk_fn((const uint8_t *)json_str, (uint64_t)json_len, w->user_data);
+    free(json_str);
+    return ok ? TG3_OK : TG3_ERR_WRITE_FAILED;
+}
+
+TINYGLTF3_API void tg3_writer_destroy(tg3_writer *w) {
+    if (!w) return;
+    tg3json_value_free(&w->root);
+    free(w);
+}
diff --git a/tiny_gltf_v3.h b/tiny_gltf_v3.h
index 8d8a92b..a8234da 100644
--- a/tiny_gltf_v3.h
+++ b/tiny_gltf_v3.h
@@ -1,5 +1,5 @@
 /*
- * tiny_gltf_v3.h - Header-only C glTF 2.0 loader and writer (v3)
+ * tiny_gltf_v3.h - C-first glTF 2.0 loader and writer API (v3)
  *
  * The MIT License (MIT)
  * Copyright (c) 2026 - Present: Syoyo Fujita
@@ -27,7 +27,7 @@
  * Version: v3.0.0-alpha
  *
  * Ground-up C-centric API rewrite of tinygltf.
- * Uses tinygltf_json.h as the sole JSON backend.
+ * The default runtime implementation lives in tiny_gltf_v3.c.
  *
  * Key differences from v2:
  *   - Pure C POD structs (no STL containers in public API)
@@ -46,7 +46,7 @@
  * Section 2: Configuration Macros
  * ====================================================================== */
 
-/* Build mode: define in ONE C++ translation unit (.cpp) */
+/* Legacy single-translation-unit build mode: define in ONE C or C++ file */
 /* #define TINYGLTF3_IMPLEMENTATION */
 
 /* Opt-in features (OFF by default) */
@@ -1219,6 +1219,11 @@ ParseGenerator tg3_parse_coro(
  * ====================================================================== */
 
 #ifdef TINYGLTF3_IMPLEMENTATION
+#define TINYGLTF3_SOURCE_INCLUDED_FROM_HEADER 1
+#include "tiny_gltf_v3.c"
+#undef TINYGLTF3_SOURCE_INCLUDED_FROM_HEADER
+
+#if 0
 
 #if !defined(__cplusplus)
 #error "TINYGLTF3_IMPLEMENTATION requires a C++ translation unit (compile as .cpp)"
@@ -4431,6 +4436,7 @@ TINYGLTF3_API void tg3_writer_destroy(tg3_writer *w) {
     delete w;
 }
 
+#endif /* legacy header-only v3 implementation */
 #endif /* TINYGLTF3_IMPLEMENTATION */
 
 #endif /* TINY_GLTF_V3_H_ */
diff --git a/tinygltf_json_c.h b/tinygltf_json_c.h
new file mode 100644
index 0000000..67971a6
--- /dev/null
+++ b/tinygltf_json_c.h
@@ -0,0 +1,1022 @@
+#ifndef TINYGLTF_JSON_C_H_
+#define TINYGLTF_JSON_C_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum tg3json_type {
+    TG3JSON_NULL = 0,
+    TG3JSON_BOOL = 1,
+    TG3JSON_INT = 2,
+    TG3JSON_REAL = 3,
+    TG3JSON_STRING = 4,
+    TG3JSON_ARRAY = 5,
+    TG3JSON_OBJECT = 6
+} tg3json_type;
+
+typedef struct tg3json_value tg3json_value;
+
+typedef struct tg3json_string {
+    char *ptr;
+    size_t len;
+} tg3json_string;
+
+typedef struct tg3json_array {
+    tg3json_value *items;
+    size_t count;
+} tg3json_array;
+
+typedef struct tg3json_object_entry {
+    char *key;
+    size_t key_len;
+    tg3json_value *value;
+} tg3json_object_entry;
+
+typedef struct tg3json_object {
+    tg3json_object_entry *items;
+    size_t count;
+} tg3json_object;
+
+struct tg3json_value {
+    tg3json_type type;
+    union {
+        int boolean;
+        int64_t integer;
+        double real;
+        tg3json_string string;
+        tg3json_array array;
+        tg3json_object object;
+    } u;
+};
+
+int tg3json_parse_n(const char *data, size_t len, size_t depth_limit,
+                    tg3json_value *out_value, const char **out_error_pos);
+int tg3json_parse(const char *begin, const char *end, size_t depth_limit,
+                  tg3json_value *out_value, const char **out_error_pos);
+void tg3json_value_free(tg3json_value *value);
+void tg3json_value_init_null(tg3json_value *value);
+void tg3json_value_init_bool(tg3json_value *value, int boolean_value);
+void tg3json_value_init_int(tg3json_value *value, int64_t integer_value);
+void tg3json_value_init_real(tg3json_value *value, double real_value);
+int tg3json_value_init_string_n(tg3json_value *value, const char *str, size_t len);
+int tg3json_value_init_string(tg3json_value *value, const char *str);
+void tg3json_value_init_array(tg3json_value *value);
+void tg3json_value_init_object(tg3json_value *value);
+int tg3json_value_copy(tg3json_value *dst, const tg3json_value *src);
+
+const tg3json_value *tg3json_object_get(const tg3json_value *object,
+                                        const char *key);
+const tg3json_value *tg3json_object_get_n(const tg3json_value *object,
+                                          const char *key, size_t key_len);
+tg3json_value *tg3json_object_get_mut(tg3json_value *object, const char *key);
+tg3json_value *tg3json_object_get_mut_n(tg3json_value *object,
+                                        const char *key, size_t key_len);
+const tg3json_object_entry *tg3json_object_at(const tg3json_value *object,
+                                              size_t index);
+size_t tg3json_object_size(const tg3json_value *object);
+int tg3json_object_set_take_n(tg3json_value *object, const char *key, size_t key_len,
+                              tg3json_value *value);
+int tg3json_object_set_take(tg3json_value *object, const char *key,
+                            tg3json_value *value);
+int tg3json_object_set_copy_n(tg3json_value *object, const char *key, size_t key_len,
+                              const tg3json_value *value);
+int tg3json_object_set_copy(tg3json_value *object, const char *key,
+                            const tg3json_value *value);
+const tg3json_value *tg3json_array_get(const tg3json_value *array, size_t index);
+size_t tg3json_array_size(const tg3json_value *array);
+int tg3json_array_append_take(tg3json_value *array, tg3json_value *value);
+int tg3json_array_append_copy(tg3json_value *array, const tg3json_value *value);
+char *tg3json_stringify(const tg3json_value *value, size_t *out_len);
+char *tg3json_stringify_pretty(const tg3json_value *value, int indent, size_t *out_len);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#ifdef TINYGLTF_JSON_C_IMPLEMENTATION
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct tg3json__parser {
+    const char *cur;
+    const char *end;
+    const char *error;
+    size_t depth_limit;
+} tg3json__parser;
+
+typedef struct tg3json__buffer {
+    char *data;
+    size_t len;
+    size_t cap;
+} tg3json__buffer;
+
+static void tg3json__init_value(tg3json_value *value) {
+    if (!value) return;
+    memset(value, 0, sizeof(*value));
+    value->type = TG3JSON_NULL;
+}
+
+static char *tg3json__strndup_local(const char *src, size_t len) {
+    char *dst = (char *)malloc(len + 1);
+    if (!dst) return NULL;
+    if (len > 0) memcpy(dst, src, len);
+    dst[len] = '\0';
+    return dst;
+}
+
+static int tg3json__reserve_bytes(void **ptr, size_t elem_size,
+                                  size_t needed, size_t *capacity) {
+    void *new_ptr;
+    size_t new_cap;
+
+    if (needed <= *capacity) return 1;
+    new_cap = (*capacity > 0) ? *capacity : 8;
+    while (new_cap < needed) {
+        if (new_cap > ((size_t)-1) / 2) {
+            new_cap = needed;
+            break;
+        }
+        new_cap *= 2;
+    }
+
+    if (elem_size != 0 && new_cap > ((size_t)-1) / elem_size) return 0;
+    new_ptr = realloc(*ptr, elem_size * new_cap);
+    if (!new_ptr) return 0;
+    *ptr = new_ptr;
+    *capacity = new_cap;
+    return 1;
+}
+
+static const char *tg3json__skip_ws(const char *p, const char *end) {
+    while (p < end) {
+        unsigned char c = (unsigned char)*p;
+        if (c != ' ' && c != '\n' && c != '\r' && c != '\t') break;
+        ++p;
+    }
+    return p;
+}
+
+static void tg3json__set_error(tg3json__parser *parser, const char *pos) {
+    if (!parser->error) parser->error = pos;
+}
+
+static int tg3json__buf_append(tg3json__buffer *buf, const char *src, size_t len) {
+    if (len == 0) return 1;
+    if (!tg3json__reserve_bytes((void **)&buf->data, 1, buf->len + len + 1, &buf->cap)) {
+        return 0;
+    }
+    memcpy(buf->data + buf->len, src, len);
+    buf->len += len;
+    buf->data[buf->len] = '\0';
+    return 1;
+}
+
+static int tg3json__buf_putc(tg3json__buffer *buf, char c) {
+    if (!tg3json__reserve_bytes((void **)&buf->data, 1, buf->len + 2, &buf->cap)) {
+        return 0;
+    }
+    buf->data[buf->len++] = c;
+    buf->data[buf->len] = '\0';
+    return 1;
+}
+
+static int tg3json__hex4(const char *p, uint32_t *out) {
+    uint32_t value = 0;
+    size_t i;
+    for (i = 0; i < 4; ++i) {
+        unsigned char c = (unsigned char)p[i];
+        value <<= 4;
+        if (c >= '0' && c <= '9') value |= (uint32_t)(c - '0');
+        else if (c >= 'a' && c <= 'f') value |= (uint32_t)(10 + c - 'a');
+        else if (c >= 'A' && c <= 'F') value |= (uint32_t)(10 + c - 'A');
+        else return 0;
+    }
+    *out = value;
+    return 1;
+}
+
+static int tg3json__append_utf8(tg3json__buffer *buf, uint32_t cp) {
+    char tmp[4];
+    size_t len = 0;
+    if (cp <= 0x7Fu) {
+        tmp[len++] = (char)cp;
+    } else if (cp <= 0x7FFu) {
+        tmp[len++] = (char)(0xC0u | ((cp >> 6) & 0x1Fu));
+        tmp[len++] = (char)(0x80u | (cp & 0x3Fu));
+    } else if (cp <= 0xFFFFu) {
+        tmp[len++] = (char)(0xE0u | ((cp >> 12) & 0x0Fu));
+        tmp[len++] = (char)(0x80u | ((cp >> 6) & 0x3Fu));
+        tmp[len++] = (char)(0x80u | (cp & 0x3Fu));
+    } else if (cp <= 0x10FFFFu) {
+        tmp[len++] = (char)(0xF0u | ((cp >> 18) & 0x07u));
+        tmp[len++] = (char)(0x80u | ((cp >> 12) & 0x3Fu));
+        tmp[len++] = (char)(0x80u | ((cp >> 6) & 0x3Fu));
+        tmp[len++] = (char)(0x80u | (cp & 0x3Fu));
+    } else {
+        return 0;
+    }
+    return tg3json__buf_append(buf, tmp, len);
+}
+
+static int tg3json__parse_string_raw(tg3json__parser *parser,
+                                     char **out_str, size_t *out_len) {
+    tg3json__buffer buf;
+    const char *start;
+    memset(&buf, 0, sizeof(buf));
+
+    if (parser->cur >= parser->end || *parser->cur != '"') {
+        tg3json__set_error(parser, parser->cur);
+        return 0;
+    }
+
+    ++parser->cur;
+    start = parser->cur;
+    while (parser->cur < parser->end) {
+        unsigned char c = (unsigned char)*parser->cur;
+        if (c == '"') {
+            if (!tg3json__buf_append(&buf, start, (size_t)(parser->cur - start))) goto oom;
+            ++parser->cur;
+            *out_str = buf.data;
+            *out_len = buf.len;
+            return 1;
+        }
+        if (c == '\\') {
+            uint32_t codepoint;
+            if (!tg3json__buf_append(&buf, start, (size_t)(parser->cur - start))) goto oom;
+            ++parser->cur;
+            if (parser->cur >= parser->end) break;
+            switch (*parser->cur) {
+                case '"': if (!tg3json__buf_putc(&buf, '"')) goto oom; break;
+                case '\\': if (!tg3json__buf_putc(&buf, '\\')) goto oom; break;
+                case '/': if (!tg3json__buf_putc(&buf, '/')) goto oom; break;
+                case 'b': if (!tg3json__buf_putc(&buf, '\b')) goto oom; break;
+                case 'f': if (!tg3json__buf_putc(&buf, '\f')) goto oom; break;
+                case 'n': if (!tg3json__buf_putc(&buf, '\n')) goto oom; break;
+                case 'r': if (!tg3json__buf_putc(&buf, '\r')) goto oom; break;
+                case 't': if (!tg3json__buf_putc(&buf, '\t')) goto oom; break;
+                case 'u': {
+                    if ((size_t)(parser->end - parser->cur) < 5) break;
+                    if (!tg3json__hex4(parser->cur + 1, &codepoint)) break;
+                    parser->cur += 4;
+                    if (codepoint >= 0xD800u && codepoint <= 0xDBFFu) {
+                        uint32_t low;
+                        if ((size_t)(parser->end - parser->cur) < 7 || parser->cur[1] != '\\' || parser->cur[2] != 'u') break;
+                        if (!tg3json__hex4(parser->cur + 3, &low)) break;
+                        if (low < 0xDC00u || low > 0xDFFFu) break;
+                        codepoint = 0x10000u + (((codepoint - 0xD800u) << 10) | (low - 0xDC00u));
+                        parser->cur += 6;
+                    } else if (codepoint >= 0xDC00u && codepoint <= 0xDFFFu) {
+                        break;
+                    }
+                    if (!tg3json__append_utf8(&buf, codepoint)) goto oom;
+                    break;
+                }
+                default:
+                    tg3json__set_error(parser, parser->cur);
+                    free(buf.data);
+                    return 0;
+            }
+            ++parser->cur;
+            start = parser->cur;
+            continue;
+        }
+        if (c < 0x20u) break;
+        ++parser->cur;
+    }
+
+    tg3json__set_error(parser, parser->cur);
+    free(buf.data);
+    return 0;
+
+oom:
+    tg3json__set_error(parser, parser->cur);
+    free(buf.data);
+    return 0;
+}
+
+static int tg3json__parse_value(tg3json__parser *parser, size_t depth,
+                                tg3json_value *out_value);
+
+static int tg3json__parse_array(tg3json__parser *parser, size_t depth,
+                                tg3json_value *out_value) {
+    tg3json_value *items = NULL;
+    size_t count = 0;
+    size_t cap = 0;
+
+    ++parser->cur;
+    parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+    if (parser->cur < parser->end && *parser->cur == ']') {
+        ++parser->cur;
+        out_value->type = TG3JSON_ARRAY;
+        out_value->u.array.items = NULL;
+        out_value->u.array.count = 0;
+        return 1;
+    }
+
+    while (parser->cur < parser->end) {
+        tg3json_value value;
+        tg3json__init_value(&value);
+        if (!tg3json__reserve_bytes((void **)&items, sizeof(*items), count + 1, &cap)) goto oom;
+        if (!tg3json__parse_value(parser, depth + 1, &value)) goto fail;
+        items[count++] = value;
+        parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+        if (parser->cur >= parser->end) break;
+        if (*parser->cur == ',') {
+            ++parser->cur;
+            parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+            continue;
+        }
+        if (*parser->cur == ']') {
+            ++parser->cur;
+            out_value->type = TG3JSON_ARRAY;
+            out_value->u.array.items = items;
+            out_value->u.array.count = count;
+            return 1;
+        }
+        break;
+    }
+
+fail:
+    while (count > 0) {
+        --count;
+        tg3json_value_free(&items[count]);
+    }
+    free(items);
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+
+oom:
+    while (count > 0) {
+        --count;
+        tg3json_value_free(&items[count]);
+    }
+    free(items);
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+}
+
+static int tg3json__parse_object(tg3json__parser *parser, size_t depth,
+                                 tg3json_value *out_value) {
+    tg3json_object_entry *items = NULL;
+    size_t count = 0;
+    size_t cap = 0;
+
+    ++parser->cur;
+    parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+    if (parser->cur < parser->end && *parser->cur == '}') {
+        ++parser->cur;
+        out_value->type = TG3JSON_OBJECT;
+        out_value->u.object.items = NULL;
+        out_value->u.object.count = 0;
+        return 1;
+    }
+
+    while (parser->cur < parser->end) {
+        char *key = NULL;
+        size_t key_len = 0;
+        tg3json_value value;
+        tg3json__init_value(&value);
+        if (!tg3json__parse_string_raw(parser, &key, &key_len)) goto fail;
+        parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+        if (parser->cur >= parser->end || *parser->cur != ':') {
+            free(key);
+            goto fail;
+        }
+        ++parser->cur;
+        parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+        if (!tg3json__parse_value(parser, depth + 1, &value)) {
+            free(key);
+            goto fail;
+        }
+        if (!tg3json__reserve_bytes((void **)&items, sizeof(*items), count + 1, &cap)) {
+            free(key);
+            tg3json_value_free(&value);
+            goto oom;
+        }
+        items[count].key = key;
+        items[count].key_len = key_len;
+        items[count].value = (tg3json_value *)malloc(sizeof(tg3json_value));
+        if (!items[count].value) {
+            free(key);
+            tg3json_value_free(&value);
+            goto oom;
+        }
+        *items[count].value = value;
+        ++count;
+        parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+        if (parser->cur >= parser->end) break;
+        if (*parser->cur == ',') {
+            ++parser->cur;
+            parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+            continue;
+        }
+        if (*parser->cur == '}') {
+            ++parser->cur;
+            out_value->type = TG3JSON_OBJECT;
+            out_value->u.object.items = items;
+            out_value->u.object.count = count;
+            return 1;
+        }
+        break;
+    }
+
+fail:
+    while (count > 0) {
+        --count;
+        free(items[count].key);
+        if (items[count].value) {
+            tg3json_value_free(items[count].value);
+            free(items[count].value);
+        }
+    }
+    free(items);
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+
+oom:
+    while (count > 0) {
+        --count;
+        free(items[count].key);
+        if (items[count].value) {
+            tg3json_value_free(items[count].value);
+            free(items[count].value);
+        }
+    }
+    free(items);
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+}
+
+static int tg3json__parse_number(tg3json__parser *parser, tg3json_value *out_value) {
+    const char *start = parser->cur;
+    const char *p = parser->cur;
+    int is_real = 0;
+    size_t len;
+    char stack_buf[128];
+    char *num_buf = stack_buf;
+
+    if (*p == '-') ++p;
+    if (p >= parser->end) goto fail;
+    if (*p == '0') {
+        ++p;
+    } else if (*p >= '1' && *p <= '9') {
+        do { ++p; } while (p < parser->end && *p >= '0' && *p <= '9');
+    } else {
+        goto fail;
+    }
+    if (p < parser->end && *p == '.') {
+        is_real = 1;
+        ++p;
+        if (p >= parser->end || *p < '0' || *p > '9') goto fail;
+        do { ++p; } while (p < parser->end && *p >= '0' && *p <= '9');
+    }
+    if (p < parser->end && (*p == 'e' || *p == 'E')) {
+        is_real = 1;
+        ++p;
+        if (p < parser->end && (*p == '+' || *p == '-')) ++p;
+        if (p >= parser->end || *p < '0' || *p > '9') goto fail;
+        do { ++p; } while (p < parser->end && *p >= '0' && *p <= '9');
+    }
+
+    len = (size_t)(p - start);
+    if (len + 1 > sizeof(stack_buf)) {
+        num_buf = (char *)malloc(len + 1);
+        if (!num_buf) goto oom;
+    }
+    memcpy(num_buf, start, len);
+    num_buf[len] = '\0';
+
+    if (!is_real) {
+        char *endptr = NULL;
+        long long v;
+        errno = 0;
+        v = strtoll(num_buf, &endptr, 10);
+        if (errno == 0 && endptr == num_buf + len) {
+            out_value->type = TG3JSON_INT;
+            out_value->u.integer = (int64_t)v;
+            parser->cur = p;
+            if (num_buf != stack_buf) free(num_buf);
+            return 1;
+        }
+        is_real = 1;
+    }
+
+    {
+        char *endptr = NULL;
+        errno = 0;
+        out_value->u.real = strtod(num_buf, &endptr);
+        if (endptr != num_buf + len) {
+            if (num_buf != stack_buf) free(num_buf);
+            goto fail;
+        }
+        out_value->type = TG3JSON_REAL;
+        parser->cur = p;
+        if (num_buf != stack_buf) free(num_buf);
+        return 1;
+    }
+
+fail:
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+oom:
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+}
+
+static int tg3json__parse_value(tg3json__parser *parser, size_t depth,
+                                tg3json_value *out_value) {
+    tg3json__init_value(out_value);
+    if (depth > parser->depth_limit) {
+        tg3json__set_error(parser, parser->cur);
+        return 0;
+    }
+    parser->cur = tg3json__skip_ws(parser->cur, parser->end);
+    if (parser->cur >= parser->end) {
+        tg3json__set_error(parser, parser->cur);
+        return 0;
+    }
+    switch (*parser->cur) {
+        case 'n':
+            if ((size_t)(parser->end - parser->cur) >= 4 && memcmp(parser->cur, "null", 4) == 0) {
+                out_value->type = TG3JSON_NULL;
+                parser->cur += 4;
+                return 1;
+            }
+            break;
+        case 't':
+            if ((size_t)(parser->end - parser->cur) >= 4 && memcmp(parser->cur, "true", 4) == 0) {
+                out_value->type = TG3JSON_BOOL;
+                out_value->u.boolean = 1;
+                parser->cur += 4;
+                return 1;
+            }
+            break;
+        case 'f':
+            if ((size_t)(parser->end - parser->cur) >= 5 && memcmp(parser->cur, "false", 5) == 0) {
+                out_value->type = TG3JSON_BOOL;
+                out_value->u.boolean = 0;
+                parser->cur += 5;
+                return 1;
+            }
+            break;
+        case '"':
+            out_value->type = TG3JSON_STRING;
+            return tg3json__parse_string_raw(parser, &out_value->u.string.ptr,
+                                             &out_value->u.string.len);
+        case '[':
+            return tg3json__parse_array(parser, depth, out_value);
+        case '{':
+            return tg3json__parse_object(parser, depth, out_value);
+        default:
+            if (*parser->cur == '-' || (*parser->cur >= '0' && *parser->cur <= '9')) {
+                return tg3json__parse_number(parser, out_value);
+            }
+            break;
+    }
+    tg3json__set_error(parser, parser->cur);
+    return 0;
+}
+
+int tg3json_parse_n(const char *data, size_t len, size_t depth_limit,
+                    tg3json_value *out_value, const char **out_error_pos) {
+    tg3json__parser parser;
+    tg3json__init_value(out_value);
+    parser.cur = data;
+    parser.end = data + len;
+    parser.error = NULL;
+    parser.depth_limit = depth_limit ? depth_limit : 512;
+
+    if (!tg3json__parse_value(&parser, 0, out_value)) {
+        if (out_error_pos) *out_error_pos = parser.error;
+        tg3json_value_free(out_value);
+        return 0;
+    }
+    parser.cur = tg3json__skip_ws(parser.cur, parser.end);
+    if (parser.cur != parser.end) {
+        if (out_error_pos) *out_error_pos = parser.cur;
+        tg3json_value_free(out_value);
+        return 0;
+    }
+    if (out_error_pos) *out_error_pos = NULL;
+    return 1;
+}
+
+int tg3json_parse(const char *begin, const char *end, size_t depth_limit,
+                  tg3json_value *out_value, const char **out_error_pos) {
+    if (!begin || !end || end < begin) {
+        if (out_error_pos) *out_error_pos = begin;
+        return 0;
+    }
+    return tg3json_parse_n(begin, (size_t)(end - begin), depth_limit,
+                           out_value, out_error_pos);
+}
+
+void tg3json_value_free(tg3json_value *value) {
+    size_t i;
+    if (!value) return;
+    switch (value->type) {
+        case TG3JSON_STRING:
+            free(value->u.string.ptr);
+            break;
+        case TG3JSON_ARRAY:
+            for (i = 0; i < value->u.array.count; ++i) {
+                tg3json_value_free(&value->u.array.items[i]);
+            }
+            free(value->u.array.items);
+            break;
+        case TG3JSON_OBJECT:
+            for (i = 0; i < value->u.object.count; ++i) {
+                free(value->u.object.items[i].key);
+                if (value->u.object.items[i].value) {
+                    tg3json_value_free(value->u.object.items[i].value);
+                    free(value->u.object.items[i].value);
+                }
+            }
+            free(value->u.object.items);
+            break;
+        default:
+            break;
+    }
+    tg3json__init_value(value);
+}
+
+void tg3json_value_init_null(tg3json_value *value) {
+    tg3json__init_value(value);
+}
+
+void tg3json_value_init_bool(tg3json_value *value, int boolean_value) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_BOOL;
+    value->u.boolean = boolean_value ? 1 : 0;
+}
+
+void tg3json_value_init_int(tg3json_value *value, int64_t integer_value) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_INT;
+    value->u.integer = integer_value;
+}
+
+void tg3json_value_init_real(tg3json_value *value, double real_value) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_REAL;
+    value->u.real = real_value;
+}
+
+int tg3json_value_init_string_n(tg3json_value *value, const char *str, size_t len) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_STRING;
+    value->u.string.ptr = tg3json__strndup_local(str ? str : "", str ? len : 0);
+    if (!value->u.string.ptr) {
+        tg3json__init_value(value);
+        return 0;
+    }
+    value->u.string.len = str ? len : 0;
+    return 1;
+}
+
+int tg3json_value_init_string(tg3json_value *value, const char *str) {
+    return tg3json_value_init_string_n(value, str, str ? strlen(str) : 0);
+}
+
+void tg3json_value_init_array(tg3json_value *value) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_ARRAY;
+}
+
+void tg3json_value_init_object(tg3json_value *value) {
+    tg3json__init_value(value);
+    value->type = TG3JSON_OBJECT;
+}
+
+int tg3json_value_copy(tg3json_value *dst, const tg3json_value *src) {
+    size_t i;
+    tg3json__init_value(dst);
+    if (!src) return 1;
+    switch (src->type) {
+        case TG3JSON_NULL:
+            return 1;
+        case TG3JSON_BOOL:
+            tg3json_value_init_bool(dst, src->u.boolean);
+            return 1;
+        case TG3JSON_INT:
+            tg3json_value_init_int(dst, src->u.integer);
+            return 1;
+        case TG3JSON_REAL:
+            tg3json_value_init_real(dst, src->u.real);
+            return 1;
+        case TG3JSON_STRING:
+            return tg3json_value_init_string_n(dst, src->u.string.ptr, src->u.string.len);
+        case TG3JSON_ARRAY:
+            tg3json_value_init_array(dst);
+            for (i = 0; i < src->u.array.count; ++i) {
+                if (!tg3json_array_append_copy(dst, &src->u.array.items[i])) {
+                    tg3json_value_free(dst);
+                    return 0;
+                }
+            }
+            return 1;
+        case TG3JSON_OBJECT:
+            tg3json_value_init_object(dst);
+            for (i = 0; i < src->u.object.count; ++i) {
+                if (!tg3json_object_set_copy_n(dst, src->u.object.items[i].key,
+                                               src->u.object.items[i].key_len,
+                                               src->u.object.items[i].value)) {
+                    tg3json_value_free(dst);
+                    return 0;
+                }
+            }
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+const tg3json_value *tg3json_object_get_n(const tg3json_value *object,
+                                          const char *key, size_t key_len) {
+    size_t i;
+    if (!object || object->type != TG3JSON_OBJECT) return NULL;
+    for (i = 0; i < object->u.object.count; ++i) {
+        const tg3json_object_entry *entry = &object->u.object.items[i];
+        if (entry->key_len == key_len && memcmp(entry->key, key, key_len) == 0) {
+            return entry->value;
+        }
+    }
+    return NULL;
+}
+
+const tg3json_value *tg3json_object_get(const tg3json_value *object,
+                                        const char *key) {
+    if (!key) return NULL;
+    return tg3json_object_get_n(object, key, strlen(key));
+}
+
+tg3json_value *tg3json_object_get_mut_n(tg3json_value *object,
+                                        const char *key, size_t key_len) {
+    size_t i;
+    if (!object || object->type != TG3JSON_OBJECT) return NULL;
+    for (i = 0; i < object->u.object.count; ++i) {
+        tg3json_object_entry *entry = &object->u.object.items[i];
+        if (entry->key_len == key_len && memcmp(entry->key, key, key_len) == 0) {
+            return entry->value;
+        }
+    }
+    return NULL;
+}
+
+tg3json_value *tg3json_object_get_mut(tg3json_value *object, const char *key) {
+    if (!key) return NULL;
+    return tg3json_object_get_mut_n(object, key, strlen(key));
+}
+
+const tg3json_object_entry *tg3json_object_at(const tg3json_value *object,
+                                              size_t index) {
+    if (!object || object->type != TG3JSON_OBJECT || index >= object->u.object.count) {
+        return NULL;
+    }
+    return &object->u.object.items[index];
+}
+
+size_t tg3json_object_size(const tg3json_value *object) {
+    if (!object || object->type != TG3JSON_OBJECT) return 0;
+    return object->u.object.count;
+}
+
+int tg3json_object_set_take_n(tg3json_value *object, const char *key, size_t key_len,
+                              tg3json_value *value) {
+    tg3json_value *existing;
+    tg3json_object_entry *entry;
+    size_t cap;
+    if (!object || object->type != TG3JSON_OBJECT || !value || !key) return 0;
+    existing = tg3json_object_get_mut_n(object, key, key_len);
+    if (existing) {
+        tg3json_value_free(existing);
+        *existing = *value;
+        tg3json__init_value(value);
+        return 1;
+    }
+    cap = object->u.object.count;
+    if (!tg3json__reserve_bytes((void **)&object->u.object.items, sizeof(*object->u.object.items),
+                                object->u.object.count + 1, &cap)) {
+        return 0;
+    }
+    entry = &object->u.object.items[object->u.object.count];
+    entry->key = tg3json__strndup_local(key, key_len);
+    if (!entry->key) return 0;
+    entry->key_len = key_len;
+    entry->value = (tg3json_value *)malloc(sizeof(tg3json_value));
+    if (!entry->value) {
+        free(entry->key);
+        entry->key = NULL;
+        entry->key_len = 0;
+        return 0;
+    }
+    *entry->value = *value;
+    tg3json__init_value(value);
+    object->u.object.count += 1;
+    return 1;
+}
+
+int tg3json_object_set_take(tg3json_value *object, const char *key,
+                            tg3json_value *value) {
+    if (!key) return 0;
+    return tg3json_object_set_take_n(object, key, strlen(key), value);
+}
+
+int tg3json_object_set_copy_n(tg3json_value *object, const char *key, size_t key_len,
+                              const tg3json_value *value) {
+    tg3json_value copy;
+    tg3json__init_value(&copy);
+    if (!tg3json_value_copy(&copy, value)) return 0;
+    if (!tg3json_object_set_take_n(object, key, key_len, &copy)) {
+        tg3json_value_free(&copy);
+        return 0;
+    }
+    return 1;
+}
+
+int tg3json_object_set_copy(tg3json_value *object, const char *key,
+                            const tg3json_value *value) {
+    if (!key) return 0;
+    return tg3json_object_set_copy_n(object, key, strlen(key), value);
+}
+
+const tg3json_value *tg3json_array_get(const tg3json_value *array, size_t index) {
+    if (!array || array->type != TG3JSON_ARRAY || index >= array->u.array.count) {
+        return NULL;
+    }
+    return &array->u.array.items[index];
+}
+
+size_t tg3json_array_size(const tg3json_value *array) {
+    if (!array || array->type != TG3JSON_ARRAY) return 0;
+    return array->u.array.count;
+}
+
+int tg3json_array_append_take(tg3json_value *array, tg3json_value *value) {
+    size_t cap;
+    if (!array || array->type != TG3JSON_ARRAY || !value) return 0;
+    cap = array->u.array.count;
+    if (!tg3json__reserve_bytes((void **)&array->u.array.items, sizeof(*array->u.array.items),
+                                array->u.array.count + 1, &cap)) {
+        return 0;
+    }
+    array->u.array.items[array->u.array.count++] = *value;
+    tg3json__init_value(value);
+    return 1;
+}
+
+int tg3json_array_append_copy(tg3json_value *array, const tg3json_value *value) {
+    tg3json_value copy;
+    tg3json__init_value(&copy);
+    if (!tg3json_value_copy(&copy, value)) return 0;
+    if (!tg3json_array_append_take(array, &copy)) {
+        tg3json_value_free(&copy);
+        return 0;
+    }
+    return 1;
+}
+
+static int tg3json__indent(tg3json__buffer *buf, int indent, int depth) {
+    int i;
+    if (indent <= 0) return 1;
+    if (!tg3json__buf_putc(buf, '\n')) return 0;
+    for (i = 0; i < indent * depth; ++i) {
+        if (!tg3json__buf_putc(buf, ' ')) return 0;
+    }
+    return 1;
+}
+
+static int tg3json__stringify_value_ex(tg3json__buffer *buf, const tg3json_value *value,
+                                       int indent, int depth) {
+    size_t i;
+    char numbuf[64];
+    switch (value->type) {
+        case TG3JSON_NULL:
+            return tg3json__buf_append(buf, "null", 4);
+        case TG3JSON_BOOL:
+            return value->u.boolean ? tg3json__buf_append(buf, "true", 4)
+                                    : tg3json__buf_append(buf, "false", 5);
+        case TG3JSON_INT:
+            snprintf(numbuf, sizeof(numbuf), "%lld", (long long)value->u.integer);
+            return tg3json__buf_append(buf, numbuf, strlen(numbuf));
+        case TG3JSON_REAL:
+            snprintf(numbuf, sizeof(numbuf), "%.17g", value->u.real);
+            {
+                const char *b = numbuf;
+                if (*b == '-') ++b;
+                if (*b == 'n' || *b == 'N' || *b == 'i' || *b == 'I') {
+                    return tg3json__buf_append(buf, "null", 4);
+                }
+            }
+            if (!strchr(numbuf, '.') && !strchr(numbuf, 'e') && !strchr(numbuf, 'E')) {
+                size_t nlen = strlen(numbuf);
+                if (nlen + 2 < sizeof(numbuf)) {
+                    numbuf[nlen] = '.';
+                    numbuf[nlen + 1] = '0';
+                    numbuf[nlen + 2] = '\0';
+                }
+            }
+            return tg3json__buf_append(buf, numbuf, strlen(numbuf));
+        case TG3JSON_STRING:
+            if (!tg3json__buf_putc(buf, '"')) return 0;
+            for (i = 0; i < value->u.string.len; ++i) {
+                unsigned char c = (unsigned char)value->u.string.ptr[i];
+                switch (c) {
+                    case '"': if (!tg3json__buf_append(buf, "\\\"", 2)) return 0; break;
+                    case '\\': if (!tg3json__buf_append(buf, "\\\\", 2)) return 0; break;
+                    case '\b': if (!tg3json__buf_append(buf, "\\b", 2)) return 0; break;
+                    case '\f': if (!tg3json__buf_append(buf, "\\f", 2)) return 0; break;
+                    case '\n': if (!tg3json__buf_append(buf, "\\n", 2)) return 0; break;
+                    case '\r': if (!tg3json__buf_append(buf, "\\r", 2)) return 0; break;
+                    case '\t': if (!tg3json__buf_append(buf, "\\t", 2)) return 0; break;
+                    default:
+                        if (c < 0x20u) {
+                            snprintf(numbuf, sizeof(numbuf), "\\u%04x", (unsigned int)c);
+                            if (!tg3json__buf_append(buf, numbuf, 6)) return 0;
+                        } else {
+                            if (!tg3json__buf_putc(buf, (char)c)) return 0;
+                        }
+                        break;
+                }
+            }
+            return tg3json__buf_putc(buf, '"');
+        case TG3JSON_ARRAY:
+            if (!tg3json__buf_putc(buf, '[')) return 0;
+            for (i = 0; i < value->u.array.count; ++i) {
+                if (i > 0 && !tg3json__buf_putc(buf, ',')) return 0;
+                if (indent > 0 && !tg3json__indent(buf, indent, depth + 1)) return 0;
+                if (!tg3json__stringify_value_ex(buf, &value->u.array.items[i], indent, depth + 1)) return 0;
+            }
+            if (indent > 0 && value->u.array.count > 0 && !tg3json__indent(buf, indent, depth)) return 0;
+            return tg3json__buf_putc(buf, ']');
+        case TG3JSON_OBJECT:
+            if (!tg3json__buf_putc(buf, '{')) return 0;
+            for (i = 0; i < value->u.object.count; ++i) {
+                tg3json_value key_value;
+                if (i > 0 && !tg3json__buf_putc(buf, ',')) return 0;
+                if (indent > 0 && !tg3json__indent(buf, indent, depth + 1)) return 0;
+                tg3json__init_value(&key_value);
+                key_value.type = TG3JSON_STRING;
+                key_value.u.string.ptr = value->u.object.items[i].key;
+                key_value.u.string.len = value->u.object.items[i].key_len;
+                if (!tg3json__stringify_value_ex(buf, &key_value, indent, depth + 1)) return 0;
+                if (!tg3json__buf_putc(buf, ':')) return 0;
+                if (indent > 0 && !tg3json__buf_putc(buf, ' ')) return 0;
+                if (!tg3json__stringify_value_ex(buf, value->u.object.items[i].value, indent, depth + 1)) return 0;
+            }
+            if (indent > 0 && value->u.object.count > 0 && !tg3json__indent(buf, indent, depth)) return 0;
+            return tg3json__buf_putc(buf, '}');
+        default:
+            return 0;
+    }
+}
+
+char *tg3json_stringify(const tg3json_value *value, size_t *out_len) {
+    tg3json__buffer buf;
+    memset(&buf, 0, sizeof(buf));
+    if (!value || !tg3json__stringify_value_ex(&buf, value, -1, 0)) {
+        free(buf.data);
+        if (out_len) *out_len = 0;
+        return NULL;
+    }
+    if (!buf.data) {
+        buf.data = (char *)malloc(1);
+        if (!buf.data) {
+            if (out_len) *out_len = 0;
+            return NULL;
+        }
+        buf.data[0] = '\0';
+    }
+    if (out_len) *out_len = buf.len;
+    return buf.data;
+}
+
+char *tg3json_stringify_pretty(const tg3json_value *value, int indent, size_t *out_len) {
+    tg3json__buffer buf;
+    memset(&buf, 0, sizeof(buf));
+    if (!value || !tg3json__stringify_value_ex(&buf, value, indent, 0)) {
+        free(buf.data);
+        if (out_len) *out_len = 0;
+        return NULL;
+    }
+    if (!buf.data) {
+        buf.data = (char *)malloc(1);
+        if (!buf.data) {
+            if (out_len) *out_len = 0;
+            return NULL;
+        }
+        buf.data[0] = '\0';
+    }
+    if (out_len) *out_len = buf.len;
+    return buf.data;
+}
+
+#endif /* TINYGLTF_JSON_C_IMPLEMENTATION */
+#endif /* TINYGLTF_JSON_C_H_ */