Add CBOR support with RFC 8949 compliance tests

- CBOR decoder using simdjson tape format (C++)
- CBOR encoder (pure OCaml)
- Half-precision float (16-bit) support
- Indefinite-length arrays/maps/strings
- 64/81 RFC 8949 Appendix A tests passing
- Memory leak tests for CBOR operations
- README documentation and API docstrings
- Version bump to 0.2.0

README.md

···
       print_endline ("Parse error: " ^ e.message)
 ```
 
+## CBOR
+
+`simdjsont` includes support for [CBOR (RFC 8949)](https://cbor.io/), using the same codecs as JSON. It decodes CBOR into the same internal `Simdjsont.Json.t` representation, allowing you to use your existing data models and validation logic.
+
+### CBOR Quick Start
+
+```ocaml
+type point = { x: int; y: int }
+
+let point_codec =
+  let open Simdjsont.Decode in
+  Obj.field (fun x y -> { x; y })
+  |> Obj.mem "x" int ~enc:(fun p -> p.x)
+  |> Obj.mem "y" int ~enc:(fun p -> p.y)
+  |> Obj.finish
+
+(* Encode to CBOR binary string *)
+let cbor = Simdjsont.Cbor.encode_string point_codec { x = 10; y = 20 }
+
+(* Decode from CBOR *)
+match Simdjsont.Cbor.decode_string point_codec cbor with
+| Ok p -> Printf.printf "Point from CBOR: (%d, %d)\n" p.x p.y
+| Error e -> print_endline e
+```
+
+### CBOR Streaming
+
+CBOR often contains multiple concatenated items. Use `Simdjsont.Cbor.to_seq` to parse these as a sequence:
+
+```ocaml
+let cbor_data = 
+  Simdjsont.Cbor.encode_string Simdjsont.Decode.int 1 ^
+  Simdjsont.Cbor.encode_string Simdjsont.Decode.int 2 ^
+  Simdjsont.Cbor.encode_string Simdjsont.Decode.int 3
+
+let () =
+  Simdjsont.Cbor.to_seq Simdjsont.Decode.int cbor_data
+  |> Seq.iter (function
+       | Ok n -> Printf.printf "Decoded: %d\n" n
+       | Error e -> Printf.printf "Error: %s\n" e)
+```
+
+### CBOR Limitations
+
+The CBOR implementation is optimized for JSON-compatible data structures. The following CBOR features are currently NOT supported:
+
+- **Tags**: While basic tags are skipped, specialized tag processing (e.g., for Date/Time) is not included.
+- **Bignums**: Integers are limited to 64-bit signed/unsigned.
+- **Byte Strings**: Decoded as strings; binary-only data might fail UTF-8 validation if decoded via `string` codec.
+- **Undefined/Simple Values**: Only `true`, `false`, and `null` are supported.
+- **Integer Map Keys**: Only string keys (Major type 3) and byte string keys (Major type 2) are supported for objects.
+
 ## License
 
 ISC

bench/bench_cbor.ml

···
+let read_file path =
+  let ic = open_in path in
+  let n = in_channel_length ic in
+  let s = really_input_string ic n in
+  close_in ic;
+  s
+
+let twitter_json = lazy (read_file "bench/data/twitter.json")
+let citm_json = lazy (read_file "bench/data/citm_catalog.json")
+
+let json_to_cbor_string json_str =
+  match Simdjsont.Codec.decode_string Simdjsont.Codec.value json_str with
+  | Ok json -> Simdjsont.Cbor.encode_string Simdjsont.Codec.value json
+  | Error e -> failwith e
+
+let twitter_cbor = lazy (json_to_cbor_string (Lazy.force twitter_json))
+let citm_cbor = lazy (json_to_cbor_string (Lazy.force citm_json))
+
+let time_it name iterations f =
+  Gc.full_major ();
+  let start = Unix.gettimeofday () in
+  for _ = 1 to iterations do
+    f ()
+  done;
+  let elapsed = Unix.gettimeofday () -. start in
+  let ns_per_op = elapsed /. float_of_int iterations *. 1_000_000_000.0 in
+  (name, ns_per_op)
+
+let run_cbor_benchmarks name cbor_str iterations =
+  Printf.printf "\n=== %s (%d bytes) ===\n\n%!" name (String.length cbor_str);
+
+  Printf.printf "--- DECODE (to AST) ---\n%!";
+
+  Printf.printf "Running simdjsont decode...\n%!";
+  let decode_results =
+    [
+      time_it "simdjsont" iterations (fun () ->
+          match Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor_str with
+          | Ok _ -> ()
+          | Error e -> failwith ("Simdjsont error: " ^ e));
+      time_it "ocaml-cbor" iterations (fun () ->
+          let _ = CBOR.Simple.decode cbor_str in
+          ());
+    ]
+  in
+  let baseline = List.assoc "ocaml-cbor" decode_results in
+  List.iter
+    (fun (n, ns) ->
+      Printf.printf "  %-12s %10.0f ns  (%.1fx)\n%!" n ns (baseline /. ns))
+    decode_results;
+
+  Printf.printf "\n--- ENCODE (AST to string) ---\n%!";
+
+  let simdjson_ast =
+    match Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor_str with
+    | Ok v -> v
+    | Error e -> failwith e
+  in
+
+  let cbor_ast = CBOR.Simple.decode cbor_str in
+  let encode_results =
+    [
+      time_it "simdjsont" iterations (fun () ->
+          let _ =
+            Simdjsont.Cbor.encode_string Simdjsont.Codec.value simdjson_ast
+          in
+          ());
+      time_it "ocaml-cbor" iterations (fun () ->
+          let _ = CBOR.Simple.encode cbor_ast in
+          ());
+    ]
+  in
+  let baseline = List.assoc "ocaml-cbor" encode_results in
+  List.iter
+    (fun (n, ns) ->
+      Printf.printf "  %-12s %10.0f ns  (%.1fx)\n%!" n ns (baseline /. ns))
+    encode_results
+
+let () =
+  Printf.printf "Preparing CBOR data...\n%!";
+  let twitter = Lazy.force twitter_cbor in
+  let citm = Lazy.force citm_cbor in
+  Printf.printf "CBOR data prepared. Twitter size: %d, CITM size: %d\n%!"
+    (String.length twitter) (String.length citm);
+
+  (* Printf.printf "Testing tiny CBOR...\n%!";
+  let tiny_json = "123" in
+  let tiny_cbor = json_to_cbor_string tiny_json in
+  (match Simdjsont.Cbor.decode_string Simdjsont.Codec.value tiny_cbor with
+  | Ok _ -> Printf.printf "Tiny decode success\n%!"
+  | Error e -> Printf.printf "Tiny decode failed: %s\n%!" e);
+
+  Printf.printf "Testing array CBOR...\n%!";
+  let array_json = "[1, 2, 3]" in
+  let array_cbor = json_to_cbor_string array_json in
+  (match Simdjsont.Cbor.decode_string Simdjsont.Codec.value array_cbor with
+  | Ok _ -> Printf.printf "Array decode success\n%!"
+  | Error e -> Printf.printf "Array decode failed: %s\n%!" e); *)
+  Printf.printf "CBOR benchmarks\n%!";
+  Printf.printf "==============================\n%!";
+  run_cbor_benchmarks "twitter.cbor" twitter 50;
+  run_cbor_benchmarks "citm_catalog.cbor" citm 20

bench/dune

···
 (executable
  (name bench_ndjson)
  (libraries simdjsont unix))
+
+(executable
+ (name bench_cbor)
+ (libraries simdjsont cbor unix))

dune-project

···
 (lang dune 3.20)
 
 (name simdjsont)
-(version 0.1.0)
+(version 0.2.0)
 
 (generate_opam_files true)
 
···
 
  (package
   (name simdjsont)
-  (synopsis "JSON parsing with simdjson, with support for ndjson streaming")
+  (synopsis "JSON and CBOR parsing with simdjson, with support for streaming")
   (description
-   "OCaml bindings to simdjson with support for ndjson streaming. Includes vendored simdjson 4.2.4.")
+   "OCaml bindings to simdjson with support for ndjson streaming and CBOR encoding/decoding. Includes vendored simdjson 4.2.4.")
    (depends
     (ocaml (>= 5.4.0))
    integers

lib/dune

···
  (libraries integers)
  (foreign_stubs
   (language cxx)
-  (names simdjsont_stubs simdjsont_impl)
-  (extra_deps simdjson_vendor.cc simdjson_vendor.hh)
+  (names simdjsont_stubs simdjsont_impl simdcbor)
+  (extra_deps simdjson_vendor.cc simdjson_vendor.hh simdcbor.hh)
    (flags
     :standard
     -std=c++17

lib/simdcbor.cpp

···
+#include "simdcbor.hh"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <stdexcept>
+
+#if defined(_MSC_VER)
+#include <stdlib.h>
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+#else
+#define bswap_16(x) __builtin_bswap16(x)
+#define bswap_32(x) __builtin_bswap32(x)
+#define bswap_64(x) __builtin_bswap64(x)
+#endif
+
+using namespace simdjson;
+
+namespace {
+
+class CborReader {
+public:
+    const uint8_t* current;
+    const uint8_t* end;
+    dom::document& doc;
+    size_t tape_idx;
+    uint8_t* current_string_buf;
+    const uint8_t* string_buf_start;
+    
+    CborReader(const uint8_t* buf, size_t len, dom::document& d) 
+        : current(buf), end(buf + len), doc(d), tape_idx(0), 
+          current_string_buf(d.string_buf.get()),
+          string_buf_start(d.string_buf.get()) {}
+
+    void append_tape(uint64_t val, internal::tape_type type) {
+        doc.tape[tape_idx++] = val | (uint64_t(type) << 56);
+    }
+
+    void append_tape_value(uint64_t val) {
+        doc.tape[tape_idx++] = val;
+    }
+    
+    size_t reserve_tape() {
+        return tape_idx++;
+    }
+    
+    void set_tape(size_t idx, uint64_t val, internal::tape_type type) {
+        doc.tape[idx] = val | (uint64_t(type) << 56);
+    }
+
+    error_code parse_root() {
+        size_t root_start = reserve_tape();
+        
+        error_code ec = parse_item();
+        if (ec != SUCCESS) return ec;
+        
+        size_t root_end = reserve_tape();
+        
+        set_tape(root_start, root_end, internal::tape_type::ROOT);
+        set_tape(root_end, root_start, internal::tape_type::ROOT);
+        
+        return SUCCESS;
+    }
+
+    error_code parse_item() {
+        if (current >= end) return EMPTY;
+
+        uint8_t initial = *current++;
+        uint8_t major = initial >> 5;
+        uint8_t additional = initial & 0x1F;
+
+        switch (major) {
+            case 0: return parse_uint(additional);
+            case 1: return parse_nint(additional);
+            case 2: return parse_byte_string(additional);
+            case 3: return parse_text_string(additional);
+            case 4: return parse_array(additional);
+            case 5: return parse_map(additional);
+            case 6: return parse_item();
+            case 7: return parse_float_simple(additional);
+            default: return UNEXPECTED_ERROR;
+        }
+    }
+
+private:
+    uint64_t read_uint(uint8_t additional, error_code& ec) {
+        if (additional < 24) {
+            return additional;
+        } else if (additional == 24) {
+            if (current + 1 > end) { ec = INDEX_OUT_OF_BOUNDS; return 0; }
+            uint8_t v = *current++;
+            return v;
+        } else if (additional == 25) {
+            if (current + 2 > end) { ec = INDEX_OUT_OF_BOUNDS; return 0; }
+            uint16_t v;
+            memcpy(&v, current, 2);
+            current += 2;
+            return bswap_16(v);
+        } else if (additional == 26) {
+            if (current + 4 > end) { ec = INDEX_OUT_OF_BOUNDS; return 0; }
+            uint32_t v;
+            memcpy(&v, current, 4);
+            current += 4;
+            return bswap_32(v);
+        } else if (additional == 27) {
+            if (current + 8 > end) { ec = INDEX_OUT_OF_BOUNDS; return 0; }
+            uint64_t v;
+            memcpy(&v, current, 8);
+            current += 8;
+            return bswap_64(v);
+        } else {
+            ec = UNEXPECTED_ERROR;
+            return 0;
+        }
+    }
+
+    error_code parse_uint(uint8_t additional) {
+        error_code ec = SUCCESS;
+        uint64_t val = read_uint(additional, ec);
+        if (ec != SUCCESS) return ec;
+
+        append_tape(0, internal::tape_type::UINT64);
+        append_tape_value(val);
+        return SUCCESS;
+    }
+
+    error_code parse_nint(uint8_t additional) {
+        error_code ec = SUCCESS;
+        uint64_t val = read_uint(additional, ec);
+        if (ec != SUCCESS) return ec;
+
+        append_tape(0, internal::tape_type::INT64);
+        int64_t nval = -1 - int64_t(val); 
+        append_tape_value((uint64_t)nval);
+        return SUCCESS;
+    }
+
+    error_code parse_byte_string(uint8_t additional) {
+        if (additional == 31) return UNEXPECTED_ERROR;
+
+        error_code ec = SUCCESS;
+        uint64_t len = read_uint(additional, ec);
+        if (ec != SUCCESS) return ec;
+
+        if (current + len > end) return INDEX_OUT_OF_BOUNDS;
+        
+        return write_string(current, len);
+    }
+
+    error_code parse_text_string(uint8_t additional) {
+        if (additional == 31) {
+            size_t offset = current_string_buf - string_buf_start;
+            uint8_t* len_ptr = current_string_buf;
+            current_string_buf += sizeof(uint32_t);
+            size_t total_len = 0;
+            
+            while (true) {
+                if (current >= end) return UNEXPECTED_ERROR;
+                if (*current == 0xFF) {
+                    current++;
+                    break;
+                }
+                uint8_t chunk_initial = *current++;
+                if ((chunk_initial >> 5) != 3) return INCORRECT_TYPE;
+                
+                error_code ec = SUCCESS;
+                uint64_t chunk_len = read_uint(chunk_initial & 0x1F, ec);
+                if (ec != SUCCESS) return ec;
+                if (current + chunk_len > end) return INDEX_OUT_OF_BOUNDS;
+                
+                if (!simdjson::validate_utf8((const char*)current, chunk_len)) {
+                    return UTF8_ERROR;
+                }
+                
+                memcpy(current_string_buf, current, chunk_len);
+                current_string_buf += chunk_len;
+                current += chunk_len;
+                total_len += chunk_len;
+            }
+            
+            *current_string_buf++ = 0;
+            uint32_t len32 = (uint32_t)total_len;
+            memcpy(len_ptr, &len32, sizeof(uint32_t));
+            append_tape(offset, internal::tape_type::STRING);
+            return SUCCESS;
+        }
+
+        error_code ec = SUCCESS;
+        uint64_t len = read_uint(additional, ec);
+        if (ec != SUCCESS) return ec;
+
+        if (current + len > end) return INDEX_OUT_OF_BOUNDS;
+
+        if (!simdjson::validate_utf8((const char*)current, len)) {
+            return UTF8_ERROR;
+        }
+
+        return write_string(current, len);
+    }
+
+    error_code write_string(const uint8_t* ptr, size_t len) {
+        uint32_t len32 = (uint32_t)len;
+        size_t offset = current_string_buf - string_buf_start;
+        
+        append_tape(offset, internal::tape_type::STRING);
+        
+        memcpy(current_string_buf, &len32, sizeof(uint32_t));
+        current_string_buf += sizeof(uint32_t);
+        
+        memcpy(current_string_buf, ptr, len);
+        current_string_buf += len;
+        
+        *current_string_buf++ = 0;
+        current += len;
+        
+        return SUCCESS;
+    }
+    
+    error_code parse_array(uint8_t additional) {
+        size_t start_idx = reserve_tape();
+        uint64_t count = 0;
+        
+        if (additional == 31) {
+            while (true) {
+                if (current >= end) return UNEXPECTED_ERROR;
+                if (*current == 0xFF) {
+                    current++;
+                    break;
+                }
+                error_code ec = parse_item();
+                if (ec != SUCCESS) return ec;
+                count++;
+            }
+        } else {
+            error_code ec = SUCCESS;
+            count = read_uint(additional, ec);
+            if (ec != SUCCESS) return ec;
+            
+            for (uint64_t i = 0; i < count; ++i) {
+                ec = parse_item();
+                if (ec != SUCCESS) return ec;
+            }
+        }
+        
+        size_t end_idx = reserve_tape();
+        size_t next_idx = end_idx + 1;
+        
+        uint64_t start_payload = next_idx | (count << 32);
+        doc.tape[start_idx] = start_payload | (uint64_t(internal::tape_type::START_ARRAY) << 56);
+        doc.tape[end_idx] = start_idx | (uint64_t(internal::tape_type::END_ARRAY) << 56);
+        
+        return SUCCESS;
+    }
+
+    error_code parse_map(uint8_t additional) {
+        size_t start_idx = reserve_tape();
+        uint64_t count = 0;
+        
+        if (additional == 31) {
+            while (true) {
+                if (current >= end) return UNEXPECTED_ERROR;
+                if (*current == 0xFF) {
+                    current++;
+                    break;
+                }
+                
+                error_code ec = parse_key();
+                if (ec != SUCCESS) return ec;
+                
+                ec = parse_item();
+                if (ec != SUCCESS) return ec;
+                count++;
+            }
+        } else {
+            error_code ec = SUCCESS;
+            count = read_uint(additional, ec);
+            if (ec != SUCCESS) return ec;
+            
+            for (uint64_t i = 0; i < count; ++i) {
+                ec = parse_key();
+                if (ec != SUCCESS) return ec;
+                
+                ec = parse_item();
+                if (ec != SUCCESS) return ec;
+            }
+        }
+        
+        size_t end_idx = reserve_tape();
+        size_t next_idx = end_idx + 1;
+        
+        uint64_t start_payload = next_idx | (count << 32);
+        doc.tape[start_idx] = start_payload | (uint64_t(internal::tape_type::START_OBJECT) << 56);
+        doc.tape[end_idx] = start_idx | (uint64_t(internal::tape_type::END_OBJECT) << 56);
+        
+        return SUCCESS;
+    }
+    
+    error_code parse_key() {
+        if (current >= end) return EMPTY;
+        
+        uint8_t initial = *current;
+        uint8_t major = initial >> 5;
+        
+        if (major == 3) {
+            current++;
+            return parse_text_string(initial & 0x1F);
+        } else if (major == 2) {
+            current++;
+            return parse_byte_string(initial & 0x1F);
+        } else {
+            return INCORRECT_TYPE;
+        }
+    }
+
+    error_code parse_float_simple(uint8_t additional) {
+        if (additional < 20) {
+            return UNEXPECTED_ERROR;
+        }
+        switch (additional) {
+            case 20:
+                append_tape(0, internal::tape_type::FALSE_VALUE);
+                return SUCCESS;
+            case 21:
+                append_tape(0, internal::tape_type::TRUE_VALUE);
+                return SUCCESS;
+            case 22:
+                append_tape(0, internal::tape_type::NULL_VALUE);
+                return SUCCESS;
+            case 23:
+                append_tape(0, internal::tape_type::NULL_VALUE);
+                return SUCCESS;
+            case 24:
+                if (current + 1 > end) return INDEX_OUT_OF_BOUNDS;
+                current++;
+                return UNEXPECTED_ERROR;
+            case 25: {
+                if (current + 2 > end) return INDEX_OUT_OF_BOUNDS;
+                uint16_t v;
+                memcpy(&v, current, 2);
+                current += 2;
+                v = bswap_16(v);
+                
+                uint32_t sign = (v >> 15) & 1;
+                uint32_t exp = (v >> 10) & 0x1F;
+                uint32_t mant = v & 0x3FF;
+                
+                double d;
+                if (exp == 0) {
+                    d = std::ldexp(mant, -24);
+                } else if (exp == 31) {
+                    d = (mant == 0) ? INFINITY : NAN;
+                } else {
+                    d = std::ldexp(mant + 1024, exp - 25);
+                }
+                if (sign) d = -d;
+                
+                append_tape(0, internal::tape_type::DOUBLE);
+                uint64_t d_as_u64;
+                memcpy(&d_as_u64, &d, 8);
+                append_tape_value(d_as_u64);
+                return SUCCESS;
+            }
+            case 26: {
+                if (current + 4 > end) return INDEX_OUT_OF_BOUNDS;
+                uint32_t v;
+                memcpy(&v, current, 4);
+                current += 4;
+                v = bswap_32(v);
+                float f;
+                memcpy(&f, &v, 4);
+                
+                append_tape(0, internal::tape_type::DOUBLE);
+                double d = f;
+                uint64_t d_as_u64;
+                memcpy(&d_as_u64, &d, 8);
+                append_tape_value(d_as_u64);
+                return SUCCESS;
+            }
+            case 27: {
+                if (current + 8 > end) return INDEX_OUT_OF_BOUNDS;
+                uint64_t v;
+                memcpy(&v, current, 8);
+                current += 8;
+                v = bswap_64(v);
+                
+                append_tape(0, internal::tape_type::DOUBLE);
+                append_tape_value(v);
+                return SUCCESS;
+            }
+            default:
+                return UNEXPECTED_ERROR;
+        }
+    }
+};
+
+}
+
+simdjson::error_code simdcbor::parse(const uint8_t* buf, size_t len, simdjson::dom::parser& parser, size_t& bytes_read) {
+    auto err = parser.doc.allocate(len * 8 + 4096);
+    if (err != SUCCESS) return err;
+    
+    CborReader reader(buf, len, parser.doc);
+    err = reader.parse_root();
+    bytes_read = reader.current - buf;
+    return err;
+}
+
+simdjson::dom::element simdcbor::get_root(simdjson::dom::parser& parser) {
+    return parser.doc.root();
+}

lib/simdcbor.hh

···
+#ifndef SIMDCBOR_HH
+#define SIMDCBOR_HH
+
+#include "simdjson_vendor.hh"
+
+class simdcbor {
+public:
+  static simdjson::error_code parse(const uint8_t* buf, size_t len, simdjson::dom::parser& parser, size_t& bytes_read);
+  static simdjson::dom::element get_root(simdjson::dom::parser& parser);
+};
+
+#endif

lib/simdjson_vendor.hh

···
+class simdcbor;
 /* auto-generated on 2025-12-17 20:32:36 -0500. version 4.2.4 Do not edit! */
 /* including simdjson.h:  */
 /* begin file simdjson.h */
···
  * This class cannot be copied, only moved, to avoid unintended allocations.
  */
 class document {
+  friend class ::simdcbor;
 public:
   /**
    * Create a document container with zero capacity.
···
  * @note This is not thread safe: one parser cannot produce two documents at the same time!
  */
 class parser {
+  friend class ::simdcbor;
 public:
   /**
    * Create a JSON parser.

lib/simdjsont.ml

···
 let validate = Validate.is_valid
 let decode codec s = Codec.decode_string codec s
 let encode codec v = Codec.encode_string codec v
+
+(** {1 CBOR} *)
+
+module Cbor = struct
+  external parse_cbor :
+    Raw.parser -> Raw.buffer -> int -> Raw.error_code * Raw.element option
+    = "simdjson_parse_cbor"
+
+  external cbor_next :
+    Raw.parser ->
+    Raw.buffer ->
+    int ->
+    int ->
+    Raw.error_code * Raw.element option * int = "simdjson_cbor_next"
+
+  let decode_string codec s =
+    let parser = Raw.create_parser () in
+    let buf = Raw.buffer_of_string s in
+    let len = String.length s in
+    match parse_cbor parser buf len with
+    | Raw.Success, Some elt -> Codec.decode_element codec elt
+    | Raw.Success, None -> Error "Internal error: success but no element"
+    | err, _ -> Error (Raw.error_message err)
+
+  let to_seq codec s =
+    let parser = Raw.create_parser () in
+    let buf = Raw.buffer_of_string s in
+    let len = String.length s in
+    let rec aux offset () =
+      if offset >= len then Seq.Nil
+      else
+        match cbor_next parser buf len offset with
+        | Raw.Success, Some elt, new_offset ->
+            let res = Codec.decode_element codec elt in
+            Seq.Cons (res, aux new_offset)
+        | Raw.Success, None, _ -> Seq.Nil
+        | Raw.Empty, _, _ -> Seq.Nil
+        | err, _, _ ->
+            let msg = Raw.error_message err in
+            Seq.Cons (Error msg, fun () -> Seq.Nil)
+    in
+    aux 0
+
+  let encode_to_buffer codec v =
+    let ast = Codec.to_json codec v in
+    Simdjsont_cbor_encode.to_buffer ast
+
+  let encode_string codec v =
+    let ast = Codec.to_json codec v in
+    Simdjsont_cbor_encode.to_string ast
+end

lib/simdjsont.mli

···
 
 val encode : 'a Codec.t -> 'a -> string
 (** Convenience alias for {!Codec.encode_string}. *)
+
+(** {1 CBOR}
+
+    CBOR (Concise Binary Object Representation, RFC 8949) support using the same
+    codec infrastructure as JSON. The same codecs work for both formats.
+
+    {b Supported CBOR types:}
+    - Integers (major types 0, 1) including 64-bit
+    - Floats (major type 7) including half-precision (16-bit)
+    - Text strings (major type 3) including indefinite-length
+    - Arrays (major type 4) including indefinite-length
+    - Maps (major type 5) with string keys, including indefinite-length
+    - Simple values: true, false, null
+
+    {b Not supported} (returns error or skipped):
+    - Byte strings (major type 2)
+    - Tagged values (major type 6)
+    - Integer map keys
+    - Bignums, undefined, other simple values *)
+
+module Cbor : sig
+  val decode_string : 'a Codec.t -> string -> ('a, string) result
+  (** [decode_string codec cbor] decodes a CBOR byte string using [codec].
+
+      Uses the same codec type as JSON decoding, so you can reuse codecs:
+      {[
+        let point = Simdjsont.Cbor.decode_string point_codec cbor_bytes
+      ]} *)
+
+  val to_seq : 'a Codec.t -> string -> ('a, string) result Seq.t
+  (** [to_seq codec data] parses multiple concatenated CBOR items from [data].
+
+      Returns a sequence of decode results, one per CBOR item. Useful for
+      processing streams of CBOR-encoded records:
+      {[
+        Simdjsont.Cbor.to_seq event_codec cbor_stream
+        |> Seq.iter (function
+          | Ok event -> process event
+          | Error msg -> log_error msg)
+      ]} *)
+
+  val encode_string : 'a Codec.t -> 'a -> string
+  (** [encode_string codec value] encodes [value] to a CBOR byte string.
+
+      The result is a binary string containing valid CBOR. *)
+
+  val encode_to_buffer : 'a Codec.t -> 'a -> Buffer.t
+  (** [encode_to_buffer codec value] encodes [value] to a fresh buffer
+      containing CBOR bytes. *)
+end

lib/simdjsont_cbor_encode.ml

···
+module Json = Simdjsont_json
+
+let write_byte buf b = Buffer.add_char buf (Char.unsafe_chr b)
+
+let write_uint_body buf v =
+  if v < 24L then write_byte buf (Int64.to_int v)
+  else if v <= 0xFFL then (
+    write_byte buf 24;
+    write_byte buf (Int64.to_int v))
+  else if v <= 0xFFFFL then (
+    write_byte buf 25;
+    let v_int = Int64.to_int v in
+    write_byte buf ((v_int lsr 8) land 0xFF);
+    write_byte buf (v_int land 0xFF))
+  else if v <= 0xFFFFFFFFL then (
+    write_byte buf 26;
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 24) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 16) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 8) land 0xFF);
+    write_byte buf (Int64.to_int v land 0xFF))
+  else (
+    write_byte buf 27;
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 56) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 48) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 40) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 32) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 24) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 16) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 8) land 0xFF);
+    write_byte buf (Int64.to_int v land 0xFF))
+
+
+let write_head buf major v =
+  let major_bits = major lsl 5 in
+  if v < 24L then write_byte buf (major_bits lor Int64.to_int v)
+  else if v <= 0xFFL then (
+    write_byte buf (major_bits lor 24);
+    write_byte buf (Int64.to_int v))
+  else if v <= 0xFFFFL then (
+    write_byte buf (major_bits lor 25);
+    let v_int = Int64.to_int v in
+    write_byte buf ((v_int lsr 8) land 0xFF);
+    write_byte buf (v_int land 0xFF))
+  else if v <= 0xFFFFFFFFL then (
+    write_byte buf (major_bits lor 26);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 24) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 16) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 8) land 0xFF);
+    write_byte buf (Int64.to_int v land 0xFF))
+  else (
+    write_byte buf (major_bits lor 27);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 56) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 48) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 40) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 32) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 24) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 16) land 0xFF);
+    write_byte buf (Int64.to_int (Int64.shift_right_logical v 8) land 0xFF);
+    write_byte buf (Int64.to_int v land 0xFF))
+
+let rec write buf = function
+  | Json.Null -> write_byte buf 0xF6
+  | Json.Bool false -> write_byte buf 0xF4
+  | Json.Bool true -> write_byte buf 0xF5
+  | Json.Int i ->
+      if i >= 0L then write_head buf 0 i else write_head buf 1 (Int64.lognot i)
+  | Json.Float f ->
+      write_byte buf 0xFB;
+      let i = Int64.bits_of_float f in
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 56) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 48) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 40) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 32) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 24) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 16) land 0xFF);
+      write_byte buf (Int64.to_int (Int64.shift_right_logical i 8) land 0xFF);
+      write_byte buf (Int64.to_int i land 0xFF)
+  | Json.String s ->
+      let len = String.length s in
+      write_head buf 3 (Int64.of_int len);
+      Buffer.add_string buf s
+  | Json.Array items ->
+      let len = List.length items in
+      write_head buf 4 (Int64.of_int len);
+      List.iter (write buf) items
+  | Json.Object members ->
+      let len = List.length members in
+      write_head buf 5 (Int64.of_int len);
+      List.iter
+        (fun (k, v) ->
+          let klen = String.length k in
+          write_head buf 3 (Int64.of_int klen);
+          Buffer.add_string buf k;
+          write buf v)
+        members
+
+let to_buffer ?(capacity = 256) v =
+  let buf = Buffer.create capacity in
+  write buf v;
+  buf
+
+let to_string v =
+  let buf = Buffer.create 256 in
+  write buf v;
+  Buffer.contents buf

lib/simdjsont_codec.ml

···
 
 type 'a decoder = string list -> Simdjsont_raw.element -> 'a
 type encoder = Buffer.t -> unit
-type 'a t = { decode : 'a decoder; encode : 'a -> encoder }
+
+type 'a t = {
+  decode : 'a decoder;
+  encode : 'a -> encoder;
+  to_json : 'a -> Simdjsont_json.t;
+}
 
 let decode_element codec elt =
   try Ok (codec.decode [] elt)
···
   buf
 
 let encode_string codec v = Buffer.contents (encode_to_buffer codec v)
+let to_json codec v = codec.to_json v
 
 let write_escaped_string buf s =
   Buffer.add_char buf '"';
···
         | Simdjsont_raw.Null -> ()
         | _ -> decode_error path "expected null");
     encode = (fun () buf -> Buffer.add_string buf "null");
+    to_json = (fun () -> Simdjsont_json.Null);
   }
 
 let bool : bool t =
···
         | Error _ -> decode_error path "expected bool");
     encode =
       (fun b buf -> Buffer.add_string buf (if b then "true" else "false"));
+    to_json = (fun b -> Simdjsont_json.Bool b);
   }
 
 let int : int t =
···
         | Ok i -> Int64.to_int i
         | Error _ -> decode_error path "expected int");
     encode = (fun i buf -> Buffer.add_string buf (string_of_int i));
+    to_json = (fun i -> Simdjsont_json.Int (Int64.of_int i));
   }
 
 let int64 : int64 t =
···
         | Ok i -> i
         | Error _ -> decode_error path "expected int64");
     encode = (fun i buf -> Buffer.add_string buf (Int64.to_string i));
+    to_json = (fun i -> Simdjsont_json.Int i);
   }
 
 let float : float t =
···
         if Float.is_finite f then
           Buffer.add_string buf (Printf.sprintf "%.17g" f)
         else Buffer.add_string buf "null");
+    to_json = (fun f -> Simdjsont_json.Float f);
   }
 
 let string : string t =
···
         | Ok s -> s
         | Error _ -> decode_error path "expected string");
     encode = (fun s buf -> write_escaped_string buf s);
+    to_json = (fun s -> Simdjsont_json.String s);
   }
 
 let list (item : 'a t) : 'a list t =
···
                 item.encode v buf)
               xs);
         Buffer.add_char buf ']');
+    to_json = (fun items -> Simdjsont_json.Array (List.map item.to_json items));
   }
 
 let array (item : 'a t) : 'a array t =
···
           done
         end;
         Buffer.add_char buf ']');
+    to_json =
+      (fun items ->
+        Simdjsont_json.Array (List.map item.to_json (Array.to_list items)));
   }
 
 let optional (inner : 'a t) : 'a option t =
···
         match opt with
         | None -> Buffer.add_string buf "null"
         | Some v -> inner.encode v buf);
+    to_json =
+      (function None -> Simdjsont_json.Null | Some v -> inner.to_json v);
   }
 
 let map (f : 'a -> 'b) (g : 'b -> 'a) (codec : 'a t) : 'b t =
   {
     decode = (fun path elt -> f (codec.decode path elt));
     encode = (fun v buf -> codec.encode (g v) buf);
+    to_json = (fun v -> codec.to_json (g v));
   }
 
 let decode_obj_field path (obj : Simdjsont_raw.object_) name (dec : 'a decoder)
···
   type ('o, 'dec) builder = {
     dec : string list -> Simdjsont_raw.object_ -> 'dec;
     enc : 'o -> Buffer.t -> bool -> bool;
+    ast : 'o -> (string * Simdjsont_json.t) list;
   }
 
   let field constructor =
     {
       dec = (fun _path _obj -> constructor);
       enc = (fun _v _buf first -> first);
+      ast = (fun _v -> []);
     }
 
   let mem name (codec : 'a t) ~enc:(get : 'o -> 'a)
···
           Buffer.add_char buf ':';
           codec.encode (get v) buf;
           false);
+      ast = (fun v -> (name, codec.to_json (get v)) :: builder.ast v);
     }
 
   let opt_mem name (codec : 'a t) ~enc:(get : 'o -> 'a option)
···
               Buffer.add_char buf ':';
               codec.encode inner_v buf;
               false);
+      ast =
+        (fun v ->
+          match get v with
+          | None -> builder.ast v
+          | Some inner_v -> (name, codec.to_json inner_v) :: builder.ast v);
     }
 
   let finish (builder : ('o, 'o) builder) : 'o t =
···
           Buffer.add_char buf '{';
           let _ = builder.enc v buf true in
           Buffer.add_char buf '}');
+      to_json = (fun v -> Simdjsont_json.Object (builder.ast v));
     }
 end
 
···
             Simdjsont_json.Object (List.rev !members)
         | Error _ -> Simdjsont_json.Object [])
   in
-  { decode = decode_value; encode = (fun v buf -> Simdjsont_json.write buf v) }
+  {
+    decode = decode_value;
+    encode = (fun v buf -> Simdjsont_json.write buf v);
+    to_json = (fun v -> v);
+  }

lib/simdjsont_codec.mli

···
 val encode_string : 'a t -> 'a -> string
 (** Encode a value to a JSON string using the given codec. *)
 
+val to_json : 'a t -> 'a -> Simdjsont_json.t
+(** Convert a value to JSON AST using the given codec. *)
+
 val null : unit t
 (** Codec for the JSON [null] value. *)
 

lib/simdjsont_stubs.cpp

···
 #include "simdjson_vendor.hh"
+#include "simdcbor.hh"
 #include <cmath>
 
 extern "C" {
···
     DocumentStreamState *state = DocStream_val(stream);
     CAMLreturn(Val_long(state->stream.size_in_bytes()));
 }
+
+/* ========================================================================= */
+/* CBOR operations                                                           */
+/* ========================================================================= */
+
+extern "C" CAMLprim value simdjson_parse_cbor(value parser, value buf, value len) {
+    CAMLparam3(parser, buf, len);
+    CAMLlocal3(result, element_val, some_val);
+    
+    dom::parser *p = Parser_val(parser);
+    const uint8_t *data = (const uint8_t *)Caml_ba_data_val(buf);
+    size_t length = Long_val(len);
+    
+    size_t bytes_read = 0;
+    auto error = simdcbor::parse(data, length, *p, bytes_read);
+    
+    result = caml_alloc_tuple(2);
+    Store_field(result, 0, Val_int(error_code_to_int(error)));
+    
+    if (error == SUCCESS) {
+        element_val = caml_alloc_custom(&element_ops, sizeof(dom::element), 0, 1);
+        Element_val(element_val) = simdcbor::get_root(*p);
+        
+        some_val = caml_alloc(1, 0);
+        Store_field(some_val, 0, element_val);
+        Store_field(result, 1, some_val);
+    } else {
+        Store_field(result, 1, Val_none);
+    }
+    
+    CAMLreturn(result);
+}
+
+extern "C" CAMLprim value simdjson_cbor_next(value parser, value buf, value len, value offset_val) {
+    CAMLparam4(parser, buf, len, offset_val);
+    CAMLlocal3(result, element_val, some_val);
+    
+    dom::parser *p = Parser_val(parser);
+    const uint8_t *data = (const uint8_t *)Caml_ba_data_val(buf);
+    size_t length = Long_val(len);
+    size_t offset = Long_val(offset_val);
+    
+    if (offset >= length) {
+        result = caml_alloc_tuple(3);
+        Store_field(result, 0, Val_int(error_code_to_int(EMPTY)));
+        Store_field(result, 1, Val_none);
+        Store_field(result, 2, Val_long(offset));
+        CAMLreturn(result);
+    }
+    
+    size_t bytes_read = 0;
+    auto error = simdcbor::parse(data + offset, length - offset, *p, bytes_read);
+    
+    result = caml_alloc_tuple(3);
+    Store_field(result, 0, Val_int(error_code_to_int(error)));
+    
+    if (error == SUCCESS) {
+        element_val = caml_alloc_custom(&element_ops, sizeof(dom::element), 0, 1);
+        Element_val(element_val) = simdcbor::get_root(*p);
+        
+        some_val = caml_alloc(1, 0);
+        Store_field(some_val, 0, element_val);
+        Store_field(result, 1, some_val);
+        Store_field(result, 2, Val_long(offset + bytes_read));
+    } else {
+        Store_field(result, 1, Val_none);
+        Store_field(result, 2, Val_long(offset));
+    }
+    
+    CAMLreturn(result);
+}

simdjsont.opam

···
 # This file is generated by dune, edit dune-project instead
 opam-version: "2.0"
-version: "0.1.0"
-synopsis: "JSON parsing with simdjson, with support for ndjson streaming"
+version: "0.2.0"
+synopsis: "JSON and CBOR parsing with simdjson, with support for streaming"
 description:
-  "OCaml bindings to simdjson with support for ndjson streaming. Includes vendored simdjson 4.2.4."
+  "OCaml bindings to simdjson with support for ndjson streaming and CBOR encoding/decoding. Includes vendored simdjson 4.2.4."
 maintainer: ["Gabriel Díaz"]
 authors: ["Gabriel Díaz"]
 license: "ISC"

test/dune

···
 (test
  (name test_memory)
  (libraries simdjsont alcotest))
+
+(test
+ (name test_cbor)
+ (libraries simdjsont alcotest))
+
+(test
+ (name test_cbor_compliance)
+ (libraries simdjsont))

test/test_cbor.ml

···
+(* Test CBOR parsing and encoding *)
+
+let test_decode_int () =
+  (* CBOR encoding of integer 42: 0x18 0x2a *)
+  let cbor_int = "\x18\x2a" in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.int cbor_int with
+  | Ok n -> Alcotest.(check int) "decode int 42" 42 n
+  | Error e -> Alcotest.fail ("decode_int failed: " ^ e)
+
+let test_decode_small_int () =
+  (* Small integers 0-23 are encoded in a single byte *)
+  let cbor_int = "\x05" in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.int cbor_int with
+  | Ok n -> Alcotest.(check int) "decode int 5" 5 n
+  | Error e -> Alcotest.fail ("decode_small_int failed: " ^ e)
+
+let test_decode_string () =
+  (* CBOR text string "hello": 0x65 h e l l o *)
+  let cbor_str = "\x65hello" in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.string cbor_str with
+  | Ok s -> Alcotest.(check string) "decode string" "hello" s
+  | Error e -> Alcotest.fail ("decode_string failed: " ^ e)
+
+let test_decode_array () =
+  let cbor_arr = "\x83\x01\x02\x03" in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.(list int) cbor_arr with
+  | Ok lst -> Alcotest.(check (list int)) "decode array" [ 1; 2; 3 ] lst
+  | Error e -> Alcotest.fail ("decode_array failed: " ^ e)
+
+let test_decode_bool () =
+  (* CBOR true: 0xf5, false: 0xf4 *)
+  let cbor_true = "\xf5" in
+  let cbor_false = "\xf4" in
+  (match Simdjsont.Cbor.decode_string Simdjsont.Codec.bool cbor_true with
+  | Ok b -> Alcotest.(check bool) "decode true" true b
+  | Error e -> Alcotest.fail ("decode_true failed: " ^ e));
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.bool cbor_false with
+  | Ok b -> Alcotest.(check bool) "decode false" false b
+  | Error e -> Alcotest.fail ("decode_false failed: " ^ e)
+
+let test_decode_null () =
+  (* CBOR null: 0xf6 *)
+  let cbor_null = "\xf6" in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.null cbor_null with
+  | Ok () -> ()
+  | Error e -> Alcotest.fail ("decode_null failed: " ^ e)
+
+let test_decode_map () =
+  (* CBOR {"a": 1}: 0xa1 0x61 a 0x01 *)
+  let cbor_map = "\xa1\x61a\x01" in
+  let codec =
+    Simdjsont.Codec.Obj.field (fun a -> a)
+    |> Simdjsont.Codec.Obj.mem "a" Simdjsont.Codec.int ~enc:Fun.id
+    |> Simdjsont.Codec.Obj.finish
+  in
+  match Simdjsont.Cbor.decode_string codec cbor_map with
+  | Ok n -> Alcotest.(check int) "decode map" 1 n
+  | Error e -> Alcotest.fail ("decode_map failed: " ^ e)
+
+let cbor_tests =
+  [
+    ("decode int", `Quick, test_decode_int);
+    ("decode small int", `Quick, test_decode_small_int);
+    ("decode string", `Quick, test_decode_string);
+    ("decode array", `Quick, test_decode_array);
+    ("decode bool", `Quick, test_decode_bool);
+    ("decode null", `Quick, test_decode_null);
+    ("decode map", `Quick, test_decode_map);
+  ]
+
+let () = Alcotest.run "cbor" [ ("cbor", cbor_tests) ]

test/test_cbor_compliance.ml

···
+(* RFC 8949 Appendix A - https://github.com/cbor/test-vectors *)
+
+let hex_to_bytes hex =
+  let len = String.length hex in
+  if len mod 2 <> 0 then failwith "hex_to_bytes: odd length";
+  let result = Bytes.create (len / 2) in
+  for i = 0 to (len / 2) - 1 do
+    let hi = Char.code hex.[i * 2] in
+    let lo = Char.code hex.[(i * 2) + 1] in
+    let hex_val c =
+      if c >= Char.code '0' && c <= Char.code '9' then c - Char.code '0'
+      else if c >= Char.code 'a' && c <= Char.code 'f' then
+        c - Char.code 'a' + 10
+      else if c >= Char.code 'A' && c <= Char.code 'F' then
+        c - Char.code 'A' + 10
+      else
+        failwith
+          ("hex_to_bytes: invalid hex char: " ^ String.make 1 (Char.chr c))
+    in
+    Bytes.set result i (Char.chr ((hex_val hi lsl 4) lor hex_val lo))
+  done;
+  Bytes.to_string result
+
+type test_result = Pass | Fail of string | Skip of string
+
+let passed = ref 0
+let failed = ref 0
+let skipped = ref 0
+
+let run_test name f =
+  match f () with
+  | Pass ->
+      incr passed;
+      Printf.printf "  ✓ %s\n%!" name
+  | Fail reason ->
+      incr failed;
+      Printf.printf "  ✗ %s: %s\n%!" name reason
+  | Skip reason ->
+      incr skipped;
+      Printf.printf "  ⊘ %s: %s\n%!" name reason
+
+let decode_int hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.int64 cbor with
+  | Ok n when n = expected -> Pass
+  | Ok n -> Fail (Printf.sprintf "expected %Ld, got %Ld" expected n)
+  | Error e -> Fail e
+
+let decode_float hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.float cbor with
+  | Ok f when f = expected -> Pass
+  | Ok f when Float.is_nan f && Float.is_nan expected -> Pass
+  | Ok f -> Fail (Printf.sprintf "expected %g, got %g" expected f)
+  | Error e -> Fail e
+
+let decode_bool hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.bool cbor with
+  | Ok b when b = expected -> Pass
+  | Ok b -> Fail (Printf.sprintf "expected %b, got %b" expected b)
+  | Error e -> Fail e
+
+let decode_null hex =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.null cbor with
+  | Ok () -> Pass
+  | Error e -> Fail e
+
+let decode_string hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.string cbor with
+  | Ok s when s = expected -> Pass
+  | Ok s -> Fail (Printf.sprintf "expected %S, got %S" expected s)
+  | Error e -> Fail e
+
+let decode_int_list hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.(list int) cbor with
+  | Ok lst when lst = expected -> Pass
+  | Ok lst ->
+      Fail
+        (Printf.sprintf "expected [%s], got [%s]"
+           (String.concat "; " (List.map string_of_int expected))
+           (String.concat "; " (List.map string_of_int lst)))
+  | Error e -> Fail e
+
+let decode_json hex expected =
+  let cbor = hex_to_bytes hex in
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor with
+  | Ok v when v = expected -> Pass
+  | Ok v ->
+      Fail
+        (Printf.sprintf "expected %s, got %s"
+           (Simdjsont.Json.to_string expected)
+           (Simdjsont.Json.to_string v))
+  | Error e -> Fail e
+
+let test_unsigned_integers () =
+  Printf.printf "\n=== Unsigned Integers ===\n%!";
+
+  run_test "0 (0x00)" (fun () -> decode_int "00" 0L);
+  run_test "1 (0x01)" (fun () -> decode_int "01" 1L);
+  run_test "10 (0x0a)" (fun () -> decode_int "0a" 10L);
+  run_test "23 (0x17)" (fun () -> decode_int "17" 23L);
+  run_test "24 (0x1818)" (fun () -> decode_int "1818" 24L);
+  run_test "25 (0x1819)" (fun () -> decode_int "1819" 25L);
+  run_test "100 (0x1864)" (fun () -> decode_int "1864" 100L);
+  run_test "1000 (0x1903e8)" (fun () -> decode_int "1903e8" 1000L);
+  run_test "1000000 (0x1a000f4240)" (fun () -> decode_int "1a000f4240" 1000000L);
+  run_test "1000000000000 (0x1b000000e8d4a51000)" (fun () ->
+      decode_int "1b000000e8d4a51000" 1000000000000L);
+  run_test "18446744073709551615 (0x1bffffffffffffffff)" (fun () ->
+      Skip "uint64 max exceeds int64 range")
+
+let test_negative_integers () =
+  Printf.printf "\n=== Negative Integers ===\n%!";
+
+  run_test "-1 (0x20)" (fun () -> decode_int "20" (-1L));
+  run_test "-10 (0x29)" (fun () -> decode_int "29" (-10L));
+  run_test "-100 (0x3863)" (fun () -> decode_int "3863" (-100L));
+  run_test "-1000 (0x3903e7)" (fun () -> decode_int "3903e7" (-1000L))
+
+let test_floats () =
+  Printf.printf "\n=== Floating Point ===\n%!";
+
+  run_test "0.0 half (0xf90000)" (fun () -> decode_float "f90000" 0.0);
+  run_test "-0.0 half (0xf98000)" (fun () -> decode_float "f98000" (-0.0));
+  run_test "1.0 half (0xf93c00)" (fun () -> decode_float "f93c00" 1.0);
+  run_test "1.5 half (0xf93e00)" (fun () -> decode_float "f93e00" 1.5);
+  run_test "65504.0 half (0xf97bff)" (fun () -> decode_float "f97bff" 65504.0);
+  run_test "-4.0 half (0xf9c400)" (fun () -> decode_float "f9c400" (-4.0));
+
+  run_test "100000.0 single (0xfa47c35000)" (fun () ->
+      decode_float "fa47c35000" 100000.0);
+  run_test "3.4028234663852886e+38 single (0xfa7f7fffff)" (fun () ->
+      decode_float "fa7f7fffff" 3.4028234663852886e+38);
+
+  run_test "1.1 double (0xfb3ff199999999999a)" (fun () ->
+      decode_float "fb3ff199999999999a" 1.1);
+  run_test "1.0e+300 double (0xfb7e37e43c8800759c)" (fun () ->
+      decode_float "fb7e37e43c8800759c" 1.0e+300);
+  run_test "-4.1 double (0xfbc010666666666666)" (fun () ->
+      decode_float "fbc010666666666666" (-4.1));
+
+  run_test "Infinity half (0xf97c00)" (fun () ->
+      decode_float "f97c00" Float.infinity);
+  run_test "-Infinity half (0xf9fc00)" (fun () ->
+      decode_float "f9fc00" Float.neg_infinity);
+  run_test "NaN half (0xf97e00)" (fun () -> decode_float "f97e00" Float.nan);
+  run_test "Infinity single (0xfa7f800000)" (fun () ->
+      decode_float "fa7f800000" Float.infinity);
+  run_test "-Infinity single (0xfaff800000)" (fun () ->
+      decode_float "faff800000" Float.neg_infinity);
+  run_test "NaN single (0xfa7fc00000)" (fun () ->
+      decode_float "fa7fc00000" Float.nan);
+  run_test "Infinity double (0xfb7ff0000000000000)" (fun () ->
+      decode_float "fb7ff0000000000000" Float.infinity);
+  run_test "-Infinity double (0xfbfff0000000000000)" (fun () ->
+      decode_float "fbfff0000000000000" Float.neg_infinity);
+  run_test "NaN double (0xfb7ff8000000000000)" (fun () ->
+      decode_float "fb7ff8000000000000" Float.nan);
+
+  run_test "5.960464477539063e-08 half (0xf90001)" (fun () ->
+      decode_float "f90001" 5.960464477539063e-08);
+  run_test "6.103515625e-05 half (0xf90400)" (fun () ->
+      decode_float "f90400" 6.103515625e-05)
+
+let test_booleans () =
+  Printf.printf "\n=== Booleans ===\n%!";
+
+  run_test "false (0xf4)" (fun () -> decode_bool "f4" false);
+  run_test "true (0xf5)" (fun () -> decode_bool "f5" true)
+
+let test_null_undefined () =
+  Printf.printf "\n=== Null and Undefined ===\n%!";
+
+  run_test "null (0xf6)" (fun () -> decode_null "f6");
+  run_test "undefined (0xf7)" (fun () ->
+      Skip "undefined not supported in JSON model")
+
+let test_simple_values () =
+  Printf.printf "\n=== Simple Values ===\n%!";
+
+  run_test "simple(16) (0xf0)" (fun () -> Skip "simple values not supported");
+  run_test "simple(24) (0xf818)" (fun () -> Skip "simple values not supported");
+  run_test "simple(255) (0xf8ff)" (fun () -> Skip "simple values not supported")
+
+let test_tags () =
+  Printf.printf "\n=== Tags ===\n%!";
+
+  run_test "tag 0 datetime (0xc074...)" (fun () -> Skip "tags not supported");
+  run_test "tag 1 epoch (0xc11a514b67b0)" (fun () -> Skip "tags not supported");
+  run_test "tag 23 base16 (0xd74401020304)" (fun () ->
+      Skip "tags not supported");
+  run_test "tag 24 embedded CBOR (0xd818...)" (fun () ->
+      Skip "tags not supported");
+  run_test "tag 32 URI (0xd82076...)" (fun () -> Skip "tags not supported")
+
+let test_bignum () =
+  Printf.printf "\n=== Bignum (Tags 2/3) ===\n%!";
+
+  run_test "bignum 18446744073709551616 (0xc249...)" (fun () ->
+      Skip "bignum tags not supported");
+  run_test "bignum -18446744073709551617 (0xc349...)" (fun () ->
+      Skip "bignum tags not supported");
+  run_test "-18446744073709551616 (0x3bffffffffffffffff)" (fun () ->
+      Skip "exceeds int64 range")
+
+let test_byte_strings () =
+  Printf.printf "\n=== Byte Strings ===\n%!";
+
+  run_test "empty byte string h'' (0x40)" (fun () ->
+      Skip "byte strings not in JSON model");
+  run_test "byte string h'01020304' (0x4401020304)" (fun () ->
+      Skip "byte strings not in JSON model");
+  run_test "indefinite byte string (0x5f42010243030405ff)" (fun () ->
+      Skip "byte strings not in JSON model")
+
+let test_text_strings () =
+  Printf.printf "\n=== Text Strings ===\n%!";
+
+  run_test "empty string \"\" (0x60)" (fun () -> decode_string "60" "");
+  run_test "\"a\" (0x6161)" (fun () -> decode_string "6161" "a");
+  run_test "\"IETF\" (0x6449455446)" (fun () ->
+      decode_string "6449455446" "IETF");
+  run_test "\"\\\"\\\\\" (0x62225c)" (fun () -> decode_string "62225c" "\"\\");
+  run_test "\"ü\" UTF-8 (0x62c3bc)" (fun () -> decode_string "62c3bc" "ü");
+  run_test "\"水\" UTF-8 (0x63e6b0b4)" (fun () -> decode_string "63e6b0b4" "水");
+  run_test "\"𐅑\" UTF-8 4-byte (0x64f0908591)" (fun () ->
+      decode_string "64f0908591" "𐅑");
+  run_test "indefinite \"streaming\" (0x7f657374726561646d696e67ff)" (fun () ->
+      decode_string "7f657374726561646d696e67ff" "streaming")
+
+let test_arrays () =
+  Printf.printf "\n=== Arrays ===\n%!";
+
+  run_test "[] empty (0x80)" (fun () -> decode_int_list "80" []);
+  run_test "[1,2,3] (0x83010203)" (fun () ->
+      decode_int_list "83010203" [ 1; 2; 3 ]);
+  run_test "[1,[2,3],[4,5]] nested (0x8301820203820405)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "8301820203820405"
+        (Array [ Int 1L; Array [ Int 2L; Int 3L ]; Array [ Int 4L; Int 5L ] ]));
+  run_test "[1..25] long array (0x98190102...)" (fun () ->
+      decode_int_list
+        "98190102030405060708090a0b0c0d0e0f101112131415161718181819"
+        (List.init 25 (fun i -> i + 1)));
+  run_test "indefinite [] (0x9fff)" (fun () -> decode_int_list "9fff" []);
+  run_test "indefinite [1,[2,3],[4,5]] (0x9f018202039f0405ffff)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "9f018202039f0405ffff"
+        (Array [ Int 1L; Array [ Int 2L; Int 3L ]; Array [ Int 4L; Int 5L ] ]));
+  run_test "mixed definite/indefinite (0x9f01820203820405ff)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "9f01820203820405ff"
+        (Array [ Int 1L; Array [ Int 2L; Int 3L ]; Array [ Int 4L; Int 5L ] ]));
+  run_test "definite outer, indefinite inner (0x83018202039f0405ff)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "83018202039f0405ff"
+        (Array [ Int 1L; Array [ Int 2L; Int 3L ]; Array [ Int 4L; Int 5L ] ]));
+  run_test "indefinite outer, definite inner (0x83019f0203ff820405)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "83019f0203ff820405"
+        (Array [ Int 1L; Array [ Int 2L; Int 3L ]; Array [ Int 4L; Int 5L ] ]));
+  run_test "indefinite [1..25] (0x9f0102...19ff)" (fun () ->
+      decode_int_list
+        "9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff"
+        (List.init 25 (fun i -> i + 1)))
+
+let test_maps () =
+  Printf.printf "\n=== Maps ===\n%!";
+
+  run_test "{} empty (0xa0)" (fun () ->
+      decode_json "a0" (Simdjsont.Json.Object []));
+  run_test "{1:2, 3:4} int keys (0xa201020304)" (fun () ->
+      Skip "integer keys not supported in JSON model");
+  run_test "{\"a\":1, \"b\":[2,3]} (0xa26161016162820203)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "a26161016162820203"
+        (Object [ ("a", Int 1L); ("b", Array [ Int 2L; Int 3L ]) ]));
+  run_test "[\"a\", {\"b\":\"c\"}] (0x826161a161626163)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "826161a161626163"
+        (Array [ String "a"; Object [ ("b", String "c") ] ]));
+  run_test "{\"a\"..\"e\": \"A\"..\"E\"} 5 pairs (0xa56161614161626142...)"
+    (fun () ->
+      let open Simdjsont.Json in
+      decode_json "a56161614161626142616361436164614461656145"
+        (Object
+           [
+             ("a", String "A");
+             ("b", String "B");
+             ("c", String "C");
+             ("d", String "D");
+             ("e", String "E");
+           ]));
+  run_test "indefinite {\"a\":1, \"b\":[2,3]} (0xbf61610161629f0203ffff)"
+    (fun () ->
+      let open Simdjsont.Json in
+      decode_json "bf61610161629f0203ffff"
+        (Object [ ("a", Int 1L); ("b", Array [ Int 2L; Int 3L ]) ]));
+  run_test "[\"a\", indef {\"b\":\"c\"}] (0x826161bf61626163ff)" (fun () ->
+      let open Simdjsont.Json in
+      decode_json "826161bf61626163ff"
+        (Array [ String "a"; Object [ ("b", String "c") ] ]));
+  run_test "indefinite {\"Fun\":true, \"Amt\":-2} (0xbf6346756ef563416d7421ff)"
+    (fun () ->
+      let open Simdjsont.Json in
+      decode_json "bf6346756ef563416d7421ff"
+        (Object [ ("Fun", Bool true); ("Amt", Int (-2L)) ]))
+
+let () =
+  Printf.printf "RFC 8949 Appendix A Compliance Tests\n";
+  Printf.printf "=====================================\n%!";
+
+  test_unsigned_integers ();
+  test_negative_integers ();
+  test_floats ();
+  test_booleans ();
+  test_null_undefined ();
+  test_simple_values ();
+  test_tags ();
+  test_bignum ();
+  test_byte_strings ();
+  test_text_strings ();
+  test_arrays ();
+  test_maps ();
+
+  Printf.printf "\n=====================================\n";
+  Printf.printf "Results: %d passed, %d failed, %d skipped\n%!" !passed !failed
+    !skipped;
+  Printf.printf "Total: %d tests\n%!" (!passed + !failed + !skipped);
+
+  if !failed > 0 then exit 1 else exit 0

test/test_memory.ml

···
       (Printf.sprintf "RSS grew by %dKB in second half - possible C memory leak"
          growth_mid_to_after)
 
+let test_cbor_decode_lifecycle () =
+  Printf.printf "CBOR decode lifecycle test:\n";
+
+  let cbor_data = "\xa2\x61a\x01\x61b\x82\x02\x03" in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 10000 do
+    let _ = Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor_data in
+    ()
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_encode_lifecycle () =
+  Printf.printf "CBOR encode lifecycle test:\n";
+
+  let data = [ 1; 2; 3; 4; 5 ] in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 10000 do
+    let _ = Simdjsont.Cbor.encode_string Simdjsont.Codec.(list int) data in
+    ()
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_roundtrip_lifecycle () =
+  Printf.printf "CBOR roundtrip lifecycle test:\n";
+
+  let codec = Simdjsont.Codec.(list (list int)) in
+  let data = [ [ 1; 2; 3 ]; [ 4; 5; 6 ]; [ 7; 8; 9 ] ] in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 10000 do
+    let cbor = Simdjsont.Cbor.encode_string codec data in
+    let _ = Simdjsont.Cbor.decode_string codec cbor in
+    ()
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_complex_structures () =
+  Printf.printf "CBOR complex structures lifecycle test:\n";
+
+  let codec =
+    let open Simdjsont.Codec in
+    Obj.field (fun id name items -> (id, name, items))
+    |> Obj.mem "id" int ~enc:(fun (id, _, _) -> id)
+    |> Obj.mem "name" string ~enc:(fun (_, name, _) -> name)
+    |> Obj.mem "items" (list int) ~enc:(fun (_, _, items) -> items)
+    |> Obj.finish
+  in
+
+  let initial_mem = get_mem_usage () in
+
+  for i = 1 to 10000 do
+    let data = (i, Printf.sprintf "item%d" i, [ i; i + 1; i + 2 ]) in
+    let cbor = Simdjsont.Cbor.encode_string codec data in
+    let _ = Simdjsont.Cbor.decode_string codec cbor in
+    ()
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_streaming_lifecycle () =
+  Printf.printf "CBOR streaming lifecycle test:\n";
+
+  let item1 = "\x83\x01\x02\x03" in
+  let item2 = "\x83\x04\x05\x06" in
+  let item3 = "\x83\x07\x08\x09" in
+  let multi_cbor = item1 ^ item2 ^ item3 in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 5000 do
+    let seq = Simdjsont.Cbor.to_seq Simdjsont.Codec.(list int) multi_cbor in
+    Seq.iter (function Ok _ -> () | Error _ -> ()) seq
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_decode_discard_no_growth () =
+  Printf.printf "CBOR decode-and-discard memory growth test:\n";
+
+  let make_cbor i =
+    let codec =
+      let open Simdjsont.Codec in
+      Obj.field (fun id data -> (id, data))
+      |> Obj.mem "id" int ~enc:fst
+      |> Obj.mem "data" (list int) ~enc:snd
+      |> Obj.finish
+    in
+    Simdjsont.Cbor.encode_string codec (i, [ 1; 2; 3; 4; 5 ])
+  in
+
+  Gc.compact ();
+  let rss_before = get_rss_kb () in
+
+  for i = 1 to 50000 do
+    let cbor = make_cbor i in
+    match Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor with
+    | Ok _ -> ()
+    | Error _ -> ()
+  done;
+
+  Gc.compact ();
+  let rss_mid = get_rss_kb () in
+
+  for i = 50001 to 100000 do
+    let cbor = make_cbor i in
+    match Simdjsont.Cbor.decode_string Simdjsont.Codec.value cbor with
+    | Ok _ -> ()
+    | Error _ -> ()
+  done;
+
+  Gc.compact ();
+  let rss_after = get_rss_kb () in
+
+  Printf.printf "  RSS:     before=%dKB  mid=%dKB  after=%dKB\n" rss_before
+    rss_mid rss_after;
+
+  let growth_mid_to_after = rss_after - rss_mid in
+  Printf.printf "  RSS growth (mid->after): %dKB\n" growth_mid_to_after;
+
+  if growth_mid_to_after > 10000 then
+    Alcotest.fail
+      (Printf.sprintf "RSS grew by %dKB in second half - possible C memory leak"
+         growth_mid_to_after)
+
+let test_cbor_half_float_lifecycle () =
+  Printf.printf "CBOR half-precision float lifecycle test:\n";
+
+  let half_floats =
+    [
+      "\xf9\x3c\x00";
+      "\xf9\x3e\x00";
+      "\xf9\x7b\xff";
+      "\xf9\xc4\x00";
+      "\xf9\x7c\x00";
+      "\xf9\xfc\x00";
+    ]
+  in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 10000 do
+    List.iter
+      (fun cbor ->
+        let _ = Simdjsont.Cbor.decode_string Simdjsont.Codec.float cbor in
+        ())
+      half_floats
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
+let test_cbor_indefinite_lifecycle () =
+  Printf.printf "CBOR indefinite-length lifecycle test:\n";
+
+  let indef_array = "\x9f\x01\x02\x03\x04\x05\xff" in
+  let indef_map = "\xbf\x61a\x01\x61b\x02\xff" in
+  let indef_string = "\x7f\x63foo\x63bar\xff" in
+
+  let initial_mem = get_mem_usage () in
+
+  for _ = 1 to 10000 do
+    let _ =
+      Simdjsont.Cbor.decode_string Simdjsont.Codec.(list int) indef_array
+    in
+    let _ = Simdjsont.Cbor.decode_string Simdjsont.Codec.value indef_map in
+    let _ = Simdjsont.Cbor.decode_string Simdjsont.Codec.string indef_string in
+    ()
+  done;
+
+  let final_mem = get_mem_usage () in
+  let diff = final_mem - initial_mem in
+
+  Printf.printf "  Initial: %d bytes\n" initial_mem;
+  Printf.printf "  Final:   %d bytes\n" final_mem;
+  Printf.printf "  Diff:    %d bytes\n" diff;
+
+  if diff > 1_000_000 then
+    Alcotest.fail
+      (Printf.sprintf "Memory grew by %d bytes - possible leak" diff)
+
 let () =
   Printf.printf "=== Memory Leak Tests ===\n\n";
 
···
           ( "raw parse discard no growth",
             `Slow,
             test_raw_parse_discard_no_growth );
+        ] );
+      ( "cbor",
+        [
+          ("cbor decode lifecycle", `Quick, test_cbor_decode_lifecycle);
+          ("cbor encode lifecycle", `Quick, test_cbor_encode_lifecycle);
+          ("cbor roundtrip lifecycle", `Quick, test_cbor_roundtrip_lifecycle);
+          ("cbor complex structures", `Quick, test_cbor_complex_structures);
+          ("cbor streaming lifecycle", `Quick, test_cbor_streaming_lifecycle);
+          ( "cbor decode discard no growth",
+            `Slow,
+            test_cbor_decode_discard_no_growth );
+          ("cbor half float lifecycle", `Quick, test_cbor_half_float_lifecycle);
+          ("cbor indefinite lifecycle", `Quick, test_cbor_indefinite_lifecycle);
         ] );
     ]