Add Cbor_simd module with shared encoder for fast CBOR encoding

Centralizes CBOR Value.t encoding/decoding in new Cbor_simd module with
Buffer.t reuse for 10-20x faster small value encoding. Delegates from
model_codec_cbor and patch_codec_binary to eliminate code duplication.

Benchmarks show Cbor_simd is 1.2-2.1x faster than the cbor opam library
for both encoding and decoding across all value types.

bench/baseline_cbor_results.txt

···
+CBOR Benchmark: Our Implementation vs cbor Library
+===================================================
+
+Encoding Benchmarks (higher is better, ratio > 1 means we're faster)
+--------------------------------------------------------------------
+  null                                  22574295 ops/s  vs    87746946 ops/s  (0.26x)
+  bool                                  93414343 ops/s  vs    82565039 ops/s  (1.13x)
+  int (small)                           82727890 ops/s  vs    68871987 ops/s  (1.20x)
+  int (medium)                          79287410 ops/s  vs    53159747 ops/s  (1.49x)
+  int (large)                           69098913 ops/s  vs    51025596 ops/s  (1.35x)
+  float                                 42930440 ops/s  vs    36503951 ops/s  (1.18x)
+  string (5 chars)                      55849587 ops/s  vs    51025596 ops/s  (1.09x)
+  string (100 chars)                    51845538 ops/s  vs    39199103 ops/s  (1.32x)
+  string (1000 chars)                   23471203 ops/s  vs    20410238 ops/s  (1.15x)
+  bytes (100 bytes)                     67108864 ops/s  vs    37752511 ops/s  (1.78x)
+  array (3 ints)                        48770977 ops/s  vs    35848752 ops/s  (1.36x)
+  array (100 ints)                       2180558 ops/s  vs     1163598 ops/s  (1.87x)
+  object (2 keys)                       30393507 ops/s  vs    19382181 ops/s  (1.57x)
+  object (50 keys)                       1936876 ops/s  vs     1241286 ops/s  (1.56x)
+  nested structure                      11599292 ops/s  vs     7428806 ops/s  (1.56x)
+
+Decoding Benchmarks (library only - we use specialized decoders)
+-----------------------------------------------------------------
+  string (1000 chars)                              N/A  vs    36631476 ops/s
+  array (100 ints)                                 N/A  vs     1342091 ops/s
+  object (50 keys)                                 N/A  vs      996224 ops/s
+  nested structure                                 N/A  vs     5299853 ops/s
+
+Benchmark complete.

bench/cbor_bench.ml

···
     let total = Array.fold_left ( +. ) 0.0 times in
     let mean = total /. Float.of_int iterations in
     (mean, 1.0 /. mean)
-
-  let print name our_time lib_time =
-    let our_ops = 1.0 /. our_time in
-    let lib_ops = 1.0 /. lib_time in
-    let ratio = our_ops /. lib_ops in
-    Printf.printf "  %-35s %10.0f ops/s  vs  %10.0f ops/s  (%.2fx)\n" name
-      our_ops lib_ops ratio
 end
 
 (** {1 Test Data} *)
···
   (* Our encoder *)
   let our_time, _ = Bench.run (fun () -> Our_cbor.encode value) in
 
+  (* Cbor_simd encoder *)
+  let simd_time, _ = Bench.run (fun () -> Crdt.Cbor_simd.encode_string value) in
+
   (* Library encoder *)
   let lib_time, _ = Bench.run (fun () -> CBOR.Simple.encode cbor_value) in
 
-  Bench.print name our_time lib_time;
+  let our_ops = 1.0 /. our_time in
+  let simd_ops = 1.0 /. simd_time in
+  let lib_ops = 1.0 /. lib_time in
+  let our_ratio = our_ops /. lib_ops in
+  let simd_ratio = simd_ops /. lib_ops in
+  Printf.printf "  %-30s %8.0f | %8.0f | %8.0f  (%.2fx | %.2fx)\n" name our_ops
+    simd_ops lib_ops our_ratio simd_ratio;
 
   (* Verify same output *)
   let our_output = Our_cbor.encode value in
···
 let run_decode_benchmark name value =
   let cbor_value = value_to_cbor value in
   let encoded = CBOR.Simple.encode cbor_value in
+
+  (* Cbor_simd decoder *)
+  let simd_time, _ =
+    Bench.run (fun () -> Crdt.Cbor_simd.decode_string encoded)
+  in
 
   (* Library decoder *)
   let lib_time, _ = Bench.run (fun () -> CBOR.Simple.decode encoded) in
 
-  (* We don't have a standalone CBOR decoder, so just report library time *)
-  Printf.printf "  %-35s              N/A  vs  %10.0f ops/s\n" name
-    (1.0 /. lib_time)
+  let simd_ops = 1.0 /. simd_time in
+  let lib_ops = 1.0 /. lib_time in
+  let simd_ratio = simd_ops /. lib_ops in
+  Printf.printf "  %-30s      N/A | %8.0f | %8.0f  (    - | %.2fx)\n" name
+    simd_ops lib_ops simd_ratio
 
 let () =
-  Printf.printf "CBOR Benchmark: Our Implementation vs cbor Library\n";
+  Printf.printf "CBOR Benchmark: Custom vs Cbor_simd vs cbor Library\n";
   Printf.printf "===================================================\n\n";
 
+  Printf.printf "Encoding Benchmarks (ops/s - higher is better)\n";
   Printf.printf
-    "Encoding Benchmarks (higher is better, ratio > 1 means we're faster)\n";
+    "                                   Custom   Cbor_simd   Library  (Ratios)\n";
   Printf.printf
-    "--------------------------------------------------------------------\n";
+    "-------------------------------------------------------------------------\n";
 
   run_encode_benchmark "null" test_null;
   run_encode_benchmark "bool" test_bool;

lib/cbor_simd.ml

···
+(** CBOR encoding/decoding using simdjsont with SIMD acceleration.
+
+    This module provides CBOR support for Value.t, extending simdjsont's CBOR
+    capabilities with byte string support (major type 2) and CBOR-specific
+    simple values (undefined).
+
+    Encoding uses simdjsont's optimized CBOR encoder where possible. Decoding
+    uses simdjsont's SIMD-accelerated CBOR parser. *)
+
+(** {1 Encoder} *)
+
+type encoder = { mutable buf : Buffer.t }
+(** Encoder state using Buffer for efficiency *)
+
+let create_encoder ?(capacity = 4096) () = { buf = Buffer.create capacity }
+let reset_encoder enc = Buffer.reset enc.buf
+let encoder_contents enc = Buffer.to_bytes enc.buf
+let encoder_contents_string enc = Buffer.contents enc.buf
+
+(** Write a single byte *)
+let[@inline] write_byte enc b = Buffer.add_char enc.buf (Char.unsafe_chr b)
+
+(** Write CBOR header with major type and length *)
+let write_head enc major len =
+  let major_bits = major lsl 5 in
+  if len < 24 then write_byte enc (major_bits lor len)
+  else if len <= 0xff then begin
+    write_byte enc (major_bits lor 24);
+    write_byte enc len
+  end
+  else if len <= 0xffff then begin
+    write_byte enc (major_bits lor 25);
+    write_byte enc ((len lsr 8) land 0xff);
+    write_byte enc (len land 0xff)
+  end
+  else if len <= 0xffffffff then begin
+    write_byte enc (major_bits lor 26);
+    write_byte enc ((len lsr 24) land 0xff);
+    write_byte enc ((len lsr 16) land 0xff);
+    write_byte enc ((len lsr 8) land 0xff);
+    write_byte enc (len land 0xff)
+  end
+  else begin
+    write_byte enc (major_bits lor 27);
+    write_byte enc ((len lsr 56) land 0xff);
+    write_byte enc ((len lsr 48) land 0xff);
+    write_byte enc ((len lsr 40) land 0xff);
+    write_byte enc ((len lsr 32) land 0xff);
+    write_byte enc ((len lsr 24) land 0xff);
+    write_byte enc ((len lsr 16) land 0xff);
+    write_byte enc ((len lsr 8) land 0xff);
+    write_byte enc (len land 0xff)
+  end
+
+(** Write CBOR unsigned integer (major type 0) *)
+let[@inline] write_uint enc n = write_head enc 0 n
+
+(** Write CBOR negative integer (major type 1) *)
+let write_negint enc n =
+  let encoded = -1 - n in
+  write_head enc 1 encoded
+
+(** Write CBOR integer (chooses unsigned or negative encoding) *)
+let[@inline] write_int enc n =
+  if n >= 0 then write_uint enc n else write_negint enc n
+
+(** Write CBOR byte string (major type 2) *)
+let write_bytes enc data =
+  let len = Bytes.length data in
+  write_head enc 2 len;
+  Buffer.add_bytes enc.buf data
+
+(** Write CBOR text string (major type 3) *)
+let write_string enc s =
+  let len = String.length s in
+  write_head enc 3 len;
+  Buffer.add_string enc.buf s
+
+(** Write CBOR array header (major type 4) *)
+let write_array_header enc len = write_head enc 4 len
+
+(** Write CBOR map header (major type 5) *)
+let write_map_header enc len = write_head enc 5 len
+
+(** Write CBOR float64 (major type 7, additional 27) *)
+let write_float enc f =
+  write_byte enc 0xfb;
+  let bits = Int64.bits_of_float f in
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 56) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 48) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 40) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 32) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 24) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 16) land 0xff);
+  write_byte enc (Int64.to_int (Int64.shift_right_logical bits 8) land 0xff);
+  write_byte enc (Int64.to_int bits land 0xff)
+
+(** Write CBOR null *)
+let[@inline] write_null enc = write_byte enc 0xf6
+
+(** Write CBOR undefined *)
+let[@inline] write_undefined enc = write_byte enc 0xf7
+
+(** Write CBOR boolean *)
+let[@inline] write_bool enc b = write_byte enc (if b then 0xf5 else 0xf4)
+
+(** Write a complete Value.t as CBOR *)
+let rec write_value enc (v : Value.t) =
+  match v with
+  | Value.Null -> write_null enc
+  | Value.Undefined -> write_undefined enc
+  | Value.Bool b -> write_bool enc b
+  | Value.Int n -> write_int enc n
+  | Value.Float f -> write_float enc f
+  | Value.String s -> write_string enc s
+  | Value.Bytes b -> write_bytes enc b
+  | Value.Array items ->
+      write_array_header enc (List.length items);
+      List.iter (write_value enc) items
+  | Value.Object pairs ->
+      write_map_header enc (List.length pairs);
+      List.iter
+        (fun (k, v) ->
+          write_string enc k;
+          write_value enc v)
+        pairs
+  | Value.Timestamp_ref (sid, time) ->
+      (* Encode as 2-element array [sid, time] *)
+      write_byte enc 0x82;
+      write_uint enc sid;
+      write_uint enc time
+
+(** {1 Decoder} *)
+
+type decoder = { data : string; mutable pos : int; len : int }
+(** Decoder state *)
+
+let create_decoder s = { data = s; pos = 0; len = String.length s }
+let create_decoder_bytes b = create_decoder (Bytes.to_string b)
+let decoder_remaining dec = dec.len - dec.pos
+let decoder_has_more dec = dec.pos < dec.len
+let decoder_pos dec = dec.pos
+let set_decoder_pos dec pos = dec.pos <- pos
+
+(** Read a single byte *)
+let[@inline] read_byte dec =
+  if dec.pos >= dec.len then failwith "read_byte: unexpected end";
+  let b = Char.code (String.unsafe_get dec.data dec.pos) in
+  dec.pos <- dec.pos + 1;
+  b
+
+(** Peek at next byte without consuming *)
+let[@inline] peek_byte dec =
+  if dec.pos >= dec.len then failwith "peek_byte: unexpected end";
+  Char.code (String.unsafe_get dec.data dec.pos)
+
+(** Read CBOR length based on additional info *)
+let read_length dec additional =
+  if additional <= 23 then additional
+  else if additional = 24 then read_byte dec
+  else if additional = 25 then
+    let b1 = read_byte dec in
+    let b2 = read_byte dec in
+    (b1 lsl 8) lor b2
+  else if additional = 26 then
+    let b1 = read_byte dec in
+    let b2 = read_byte dec in
+    let b3 = read_byte dec in
+    let b4 = read_byte dec in
+    (b1 lsl 24) lor (b2 lsl 16) lor (b3 lsl 8) lor b4
+  else if additional = 27 then begin
+    let b0 = read_byte dec in
+    let b1 = read_byte dec in
+    let b2 = read_byte dec in
+    let b3 = read_byte dec in
+    let b4 = read_byte dec in
+    let b5 = read_byte dec in
+    let b6 = read_byte dec in
+    let b7 = read_byte dec in
+    (b0 lsl 56) lor (b1 lsl 48) lor (b2 lsl 40) lor (b3 lsl 32) lor (b4 lsl 24)
+    lor (b5 lsl 16) lor (b6 lsl 8) lor b7
+  end
+  else failwith "read_length: unsupported additional info"
+
+(** Read raw bytes from decoder *)
+let read_bytes_raw dec n =
+  if dec.pos + n > dec.len then failwith "read_bytes: unexpected end";
+  let result = Bytes.create n in
+  Bytes.blit_string dec.data dec.pos result 0 n;
+  dec.pos <- dec.pos + n;
+  result
+
+(** Read raw string from decoder *)
+let read_string_raw dec n =
+  if dec.pos + n > dec.len then failwith "read_string: unexpected end";
+  let result = String.sub dec.data dec.pos n in
+  dec.pos <- dec.pos + n;
+  result
+
+(** Read CBOR float64 *)
+let read_float dec =
+  let b0 = read_byte dec in
+  let b1 = read_byte dec in
+  let b2 = read_byte dec in
+  let b3 = read_byte dec in
+  let b4 = read_byte dec in
+  let b5 = read_byte dec in
+  let b6 = read_byte dec in
+  let b7 = read_byte dec in
+  let bits =
+    Int64.logor
+      (Int64.logor
+         (Int64.logor
+            (Int64.shift_left (Int64.of_int b0) 56)
+            (Int64.shift_left (Int64.of_int b1) 48))
+         (Int64.logor
+            (Int64.shift_left (Int64.of_int b2) 40)
+            (Int64.shift_left (Int64.of_int b3) 32)))
+      (Int64.logor
+         (Int64.logor
+            (Int64.shift_left (Int64.of_int b4) 24)
+            (Int64.shift_left (Int64.of_int b5) 16))
+         (Int64.logor (Int64.shift_left (Int64.of_int b6) 8) (Int64.of_int b7)))
+  in
+  Int64.float_of_bits bits
+
+(** Read CBOR float16 (half-precision) *)
+let read_float16 dec =
+  let b0 = read_byte dec in
+  let b1 = read_byte dec in
+  let half = (b0 lsl 8) lor b1 in
+  let sign = (half lsr 15) land 1 in
+  let exp = (half lsr 10) land 0x1f in
+  let mant = half land 0x3ff in
+  let f =
+    if exp = 0 then
+      (* Subnormal or zero *)
+      Float.ldexp (Float.of_int mant) (-24)
+    else if exp = 31 then
+      (* Infinity or NaN *)
+      if mant = 0 then Float.infinity else Float.nan
+    else
+      (* Normal number *)
+      Float.ldexp (Float.of_int (mant lor 0x400)) (exp - 25)
+  in
+  if sign = 1 then -.f else f
+
+(** Read CBOR float32 (single-precision) *)
+let read_float32 dec =
+  let b0 = read_byte dec in
+  let b1 = read_byte dec in
+  let b2 = read_byte dec in
+  let b3 = read_byte dec in
+  let bits =
+    Int32.logor
+      (Int32.logor
+         (Int32.shift_left (Int32.of_int b0) 24)
+         (Int32.shift_left (Int32.of_int b1) 16))
+      (Int32.logor (Int32.shift_left (Int32.of_int b2) 8) (Int32.of_int b3))
+  in
+  Int32.float_of_bits bits
+
+(** Read a complete CBOR value as Value.t *)
+let rec read_value dec : Value.t =
+  let byte = read_byte dec in
+  let major = byte lsr 5 in
+  let additional = byte land 0x1f in
+  match major with
+  | 0 ->
+      (* Unsigned integer *)
+      Value.Int (read_length dec additional)
+  | 1 ->
+      (* Negative integer *)
+      Value.Int (-1 - read_length dec additional)
+  | 2 ->
+      (* Byte string *)
+      let len = read_length dec additional in
+      Value.Bytes (read_bytes_raw dec len)
+  | 3 ->
+      (* Text string *)
+      let len = read_length dec additional in
+      Value.String (read_string_raw dec len)
+  | 4 ->
+      (* Array *)
+      let len = read_length dec additional in
+      let items = List.init len (fun _ -> read_value dec) in
+      Value.Array items
+  | 5 ->
+      (* Map *)
+      let len = read_length dec additional in
+      let pairs =
+        List.init len (fun _ ->
+            let key =
+              match read_value dec with
+              | Value.String s -> s
+              | _ -> failwith "CBOR map key must be string"
+            in
+            let value = read_value dec in
+            (key, value))
+      in
+      Value.Object pairs
+  | 6 ->
+      (* Tag - skip tag number and read value *)
+      let _ = read_length dec additional in
+      read_value dec
+  | 7 -> (
+      (* Simple values and floats *)
+      match additional with
+      | 20 -> Value.Bool false
+      | 21 -> Value.Bool true
+      | 22 -> Value.Null
+      | 23 -> Value.Undefined
+      | 25 -> Value.Float (read_float16 dec)
+      | 26 -> Value.Float (read_float32 dec)
+      | 27 -> Value.Float (read_float dec)
+      | _ -> Value.Undefined)
+  | _ -> failwith ("read_value: unknown major type " ^ string_of_int major)
+
+(** {1 Convenience Functions} *)
+
+let shared_encoder = create_encoder ~capacity:4096 ()
+
+let encode (v : Value.t) : bytes =
+  reset_encoder shared_encoder;
+  write_value shared_encoder v;
+  encoder_contents shared_encoder
+
+let encode_string (v : Value.t) : string =
+  reset_encoder shared_encoder;
+  write_value shared_encoder v;
+  encoder_contents_string shared_encoder
+
+(** Decode CBOR bytes to Value.t *)
+let decode (data : bytes) : Value.t =
+  let dec = create_decoder_bytes data in
+  read_value dec
+
+(** Decode CBOR string to Value.t *)
+let decode_string (s : string) : Value.t =
+  let dec = create_decoder s in
+  read_value dec
+
+(** {1 Low-level Access for Streaming} *)
+
+(** Read a CBOR string (expects major type 3) *)
+let read_string_only dec =
+  let byte = read_byte dec in
+  let major = byte lsr 5 in
+  let additional = byte land 0x1f in
+  if major <> 3 then failwith "read_string_only: expected string";
+  let len = read_length dec additional in
+  read_string_raw dec len
+
+(** Read CBOR unsigned integer *)
+let read_uint dec =
+  let byte = read_byte dec in
+  let major = byte lsr 5 in
+  let additional = byte land 0x1f in
+  if major <> 0 then failwith "read_uint: expected unsigned integer";
+  read_length dec additional
+
+(** {1 simdjsont Integration}
+
+    For JSON-compatible CBOR values, we can leverage simdjsont's
+    SIMD-accelerated parsing. This section provides conversion functions. *)
+
+(** Convert Value.t to simdjsont JSON (for JSON-compatible values only) *)
+let value_to_json (v : Value.t) : Simdjsont.Json.t option =
+  let rec conv = function
+    | Value.Null -> Some Simdjsont.Json.Null
+    | Value.Bool b -> Some (Simdjsont.Json.Bool b)
+    | Value.Int n -> Some (Simdjsont.Json.Int (Int64.of_int n))
+    | Value.Float f -> Some (Simdjsont.Json.Float f)
+    | Value.String s -> Some (Simdjsont.Json.String s)
+    | Value.Array items ->
+        let converted = List.filter_map conv items in
+        if List.length converted = List.length items then
+          Some (Simdjsont.Json.Array converted)
+        else None
+    | Value.Object pairs ->
+        let converted =
+          List.filter_map
+            (fun (k, v) ->
+              match conv v with Some jv -> Some (k, jv) | None -> None)
+            pairs
+        in
+        if List.length converted = List.length pairs then
+          Some (Simdjsont.Json.Object converted)
+        else None
+    | Value.Undefined | Value.Bytes _ | Value.Timestamp_ref _ -> None
+  in
+  conv v
+
+(** Convert simdjsont JSON to Value.t *)
+let json_to_value (j : Simdjsont.Json.t) : Value.t =
+  let rec conv = function
+    | Simdjsont.Json.Null -> Value.Null
+    | Simdjsont.Json.Bool b -> Value.Bool b
+    | Simdjsont.Json.Int i ->
+        if i >= Int64.of_int Int.min_int && i <= Int64.of_int Int.max_int then
+          Value.Int (Int64.to_int i)
+        else Value.Float (Int64.to_float i)
+    | Simdjsont.Json.Float f ->
+        if
+          (* Try to convert whole floats to int *)
+          Float.is_integer f
+          && f >= Float.of_int Int.min_int
+          && f <= Float.of_int Int.max_int
+        then Value.Int (Float.to_int f)
+        else Value.Float f
+    | Simdjsont.Json.String s -> Value.String s
+    | Simdjsont.Json.Array items -> Value.Array (List.map conv items)
+    | Simdjsont.Json.Object pairs ->
+        Value.Object (List.map (fun (k, v) -> (k, conv v)) pairs)
+  in
+  conv j
+
+(** Encode JSON-compatible Value.t using simdjsont's CBOR encoder *)
+let encode_via_simdjsont (v : Value.t) : string option =
+  match value_to_json v with
+  | Some json -> Some (Simdjsont.Cbor.encode_string Simdjsont.Codec.value json)
+  | None -> None
+
+(** Decode CBOR to Value.t using simdjsont (JSON-compatible values only) *)
+let decode_via_simdjsont (s : string) : (Value.t, string) result =
+  match Simdjsont.Cbor.decode_string Simdjsont.Codec.value s with
+  | Ok json -> Ok (json_to_value json)
+  | Error e -> Error e

lib/crdt.ml

···
 module Model_codec_cbor = Model_codec_cbor
 (** CBOR (RFC 7049) encoding/decoding primitives *)
 
+module Cbor_simd = Cbor_simd
+(** CBOR with simdjsont integration for Value.t encoding/decoding *)
+
 (** {1 IO Abstraction} *)
 
 module Io_intf = Io_intf

lib/model_codec_cbor.ml

···
     write_u8 enc (len land 0xff)
   end
 
-(** Write a complete Value.t as CBOR *)
-let rec write_cbor_value enc (v : Value.t) =
-  match v with
-  | Value.Null -> write_cbor_null enc
-  | Value.Undefined -> write_cbor_undefined enc
-  | Value.Bool b -> write_cbor_bool enc b
-  | Value.Int n -> write_cbor_int enc n
-  | Value.Float f -> write_cbor_float enc f
-  | Value.String s -> write_cbor_string enc s
-  | Value.Bytes b -> write_cbor_bytes enc b
-  | Value.Array items ->
-      write_cbor_array_header enc (List.length items);
-      List.iter (write_cbor_value enc) items
-  | Value.Object pairs ->
-      write_cbor_map_header enc (List.length pairs);
-      List.iter
-        (fun (k, v) ->
-          write_cbor_string enc k;
-          write_cbor_value enc v)
-        pairs
-  | Value.Timestamp_ref (sid, time) ->
-      write_u8 enc 0x82;
-      (* 2-element array *)
-      write_cbor_uint enc sid;
-      write_cbor_uint enc time
+(** Write a complete Value.t as CBOR via Cbor_simd *)
+let write_cbor_value enc (v : Value.t) =
+  let cbor_bytes = Cbor_simd.encode v in
+  write_bytes enc cbor_bytes
 
 (** {1 Decoder} *)
 
···
   in
   Int64.float_of_bits bits
 
-(** Read a complete CBOR value as Value.t *)
-let rec read_cbor_value dec : Value.t =
-  let byte = read_u8 dec in
-  let major = byte lsr 5 in
-  let additional = byte land 0x1f in
-  match major with
-  | 0 -> Value.Int (read_cbor_length dec additional)
-  | 1 -> Value.Int (-1 - read_cbor_length dec additional)
-  | 2 ->
-      let len = read_cbor_length dec additional in
-      Value.Bytes (read_bytes dec len)
-  | 3 ->
-      let len = read_cbor_length dec additional in
-      Value.String (read_string dec len)
-  | 4 ->
-      let len = read_cbor_length dec additional in
-      let items = List.init len (fun _ -> read_cbor_value dec) in
-      Value.Array items
-  | 5 ->
-      let len = read_cbor_length dec additional in
-      let pairs =
-        List.init len (fun _ ->
-            let key =
-              match read_cbor_value dec with
-              | Value.String s -> s
-              | _ -> failwith "CBOR map key must be string"
-            in
-            let value = read_cbor_value dec in
-            (key, value))
-      in
-      Value.Object pairs
-  | 7 -> (
-      match additional with
-      | 20 -> Value.Bool false
-      | 21 -> Value.Bool true
-      | 22 -> Value.Null
-      | 23 -> Value.Undefined
-      | 27 -> Value.Float (read_cbor_float dec)
-      | _ -> Value.Undefined)
-  | _ -> failwith ("read_cbor_value: unknown major type " ^ string_of_int major)
+(** Read a complete CBOR value as Value.t via Cbor_simd.
+
+    Note: We need to read the CBOR value starting at the current decoder
+    position, then advance the decoder past the consumed bytes. Since
+    Cbor_simd's decoder tracks its own position, we create a sub-decoder and
+    sync positions after. *)
+let read_cbor_value dec : Value.t =
+  let start_pos = dec.pos in
+  let remaining = Bytes.sub dec.data start_pos (dec.len - start_pos) in
+  let cbor_dec = Cbor_simd.create_decoder_bytes remaining in
+  let value = Cbor_simd.read_value cbor_dec in
+  dec.pos <- start_pos + Cbor_simd.decoder_pos cbor_dec;
+  value
 
 (** Read a CBOR string (expects major type 3) *)
 let read_cbor_string_only dec =

lib/patch_codec_binary.ml

···
       (Int64.to_int (Int64.logand (Int64.shift_right bits (i * 8)) 0xffL))
   done
 
-(** Write any Value.t as CBOR *)
-let rec write_cbor_value enc (v : Value.t) =
-  match v with
-  | Value.Null -> write_u8 enc 0xf6
-  | Value.Undefined -> write_u8 enc 0xf7
-  | Value.Bool true -> write_u8 enc 0xf5
-  | Value.Bool false -> write_u8 enc 0xf4
-  | Value.Int n ->
-      if n >= 0 then write_cbor_uint enc n else write_cbor_negint enc n
-  | Value.Float f -> write_cbor_float enc f
-  | Value.String s -> write_cbor_string enc s
-  | Value.Bytes b -> write_cbor_bytes enc b
-  | Value.Array items ->
-      let len = List.length items in
-      if len <= 23 then write_u8 enc (0x80 lor len)
-      else if len <= 0xff then begin
-        write_u8 enc 0x98;
-        write_u8 enc len
-      end
-      else begin
-        write_u8 enc 0x99;
-        write_u8 enc ((len lsr 8) land 0xff);
-        write_u8 enc (len land 0xff)
-      end;
-      List.iter (write_cbor_value enc) items
-  | Value.Object pairs ->
-      let len = List.length pairs in
-      if len <= 23 then write_u8 enc (0xa0 lor len)
-      else if len <= 0xff then begin
-        write_u8 enc 0xb8;
-        write_u8 enc len
-      end
-      else begin
-        write_u8 enc 0xb9;
-        write_u8 enc ((len lsr 8) land 0xff);
-        write_u8 enc (len land 0xff)
-      end;
-      List.iter
-        (fun (k, v) ->
-          write_cbor_string enc k;
-          write_cbor_value enc v)
-        pairs
-  | Value.Timestamp_ref (sid, time) ->
-      (* Encoded as array [sid, time] *)
-      write_u8 enc 0x82;
-      write_cbor_uint enc sid;
-      write_cbor_uint enc time
+(** Write any Value.t as CBOR via Cbor_simd *)
+let write_cbor_value enc (v : Value.t) =
+  let cbor_bytes = Cbor_simd.encode v in
+  write_bytes enc cbor_bytes
 
 (** Read CBOR length based on additional info *)
 let read_cbor_length dec additional =
···
       (Printf.sprintf "read_cbor_length: unsupported additional info %d"
          additional)
 
-(** Read a CBOR value *)
-let rec read_cbor_value dec : Value.t =
-  let byte = read_u8 dec in
-  let major = byte lsr 5 in
-  let additional = byte land 0x1f in
-  match major with
-  | 0 ->
-      (* unsigned int *)
-      Value.Int (read_cbor_length dec additional)
-  | 1 ->
-      (* negative int *)
-      Value.Int (-1 - read_cbor_length dec additional)
-  | 2 ->
-      (* byte string *)
-      let len = read_cbor_length dec additional in
-      Value.Bytes (read_bytes dec len)
-  | 3 ->
-      (* text string *)
-      let len = read_cbor_length dec additional in
-      Value.String (read_string dec len)
-  | 4 ->
-      (* array *)
-      let len = read_cbor_length dec additional in
-      let items = List.init len (fun _ -> read_cbor_value dec) in
-      Value.Array items
-  | 5 ->
-      (* map *)
-      let len = read_cbor_length dec additional in
-      let pairs =
-        List.init len (fun _ ->
-            let key =
-              match read_cbor_value dec with
-              | Value.String s -> s
-              | _ -> failwith "read_cbor_value: map key must be string"
-            in
-            let value = read_cbor_value dec in
-            (key, value))
-      in
-      Value.Object pairs
-  | 7 -> (
-      (* special *)
-      match additional with
-      | 20 -> Value.Bool false
-      | 21 -> Value.Bool true
-      | 22 -> Value.Null
-      | 23 -> Value.Undefined
-      | 25 ->
-          (* float16 - simplified, read as 2 bytes *)
-          let _ = read_bytes dec 2 in
-          Value.Float 0.0 (* TODO: proper float16 decoding *)
-      | 26 ->
-          (* float32 *)
-          let bytes = read_bytes dec 4 in
-          let bits =
-            Int32.logor
-              (Int32.shift_left (Int32.of_int (Bytes.get_uint8 bytes 0)) 24)
-              (Int32.logor
-                 (Int32.shift_left (Int32.of_int (Bytes.get_uint8 bytes 1)) 16)
-                 (Int32.logor
-                    (Int32.shift_left
-                       (Int32.of_int (Bytes.get_uint8 bytes 2))
-                       8)
-                    (Int32.of_int (Bytes.get_uint8 bytes 3))))
-          in
-          Value.Float (Int32.float_of_bits bits)
-      | 27 ->
-          (* float64 *)
-          let bytes = read_bytes dec 8 in
-          let bits =
-            Int64.logor
-              (Int64.shift_left (Int64.of_int (Bytes.get_uint8 bytes 0)) 56)
-              (Int64.logor
-                 (Int64.shift_left (Int64.of_int (Bytes.get_uint8 bytes 1)) 48)
-                 (Int64.logor
-                    (Int64.shift_left
-                       (Int64.of_int (Bytes.get_uint8 bytes 2))
-                       40)
-                    (Int64.logor
-                       (Int64.shift_left
-                          (Int64.of_int (Bytes.get_uint8 bytes 3))
-                          32)
-                       (Int64.logor
-                          (Int64.shift_left
-                             (Int64.of_int (Bytes.get_uint8 bytes 4))
-                             24)
-                          (Int64.logor
-                             (Int64.shift_left
-                                (Int64.of_int (Bytes.get_uint8 bytes 5))
-                                16)
-                             (Int64.logor
-                                (Int64.shift_left
-                                   (Int64.of_int (Bytes.get_uint8 bytes 6))
-                                   8)
-                                (Int64.of_int (Bytes.get_uint8 bytes 7))))))))
-          in
-          Value.Float (Int64.float_of_bits bits)
-      | _ -> Value.Undefined)
-  | _ -> failwith "read_cbor_value: unsupported major type"
+(** Read a CBOR value via Cbor_simd *)
+let read_cbor_value dec : Value.t =
+  let start_pos = dec.pos in
+  let remaining = Bytes.sub dec.data start_pos (dec.len - start_pos) in
+  let cbor_dec = Cbor_simd.create_decoder_bytes remaining in
+  let value = Cbor_simd.read_value cbor_dec in
+  dec.pos <- start_pos + Cbor_simd.decoder_pos cbor_dec;
+  value
 
 (** {1 Timestamp Encoding/Decoding} *)