Fix compact codec conformance after simdjsont migration

.beads/issues.jsonl

···
 {"id":"automerge-P8","title":"Phase 8: Conformance testing","description":"Implement full conformance test suite using json-crdt-traces fixtures plus fuzzing/property tests.","status":"open","priority":1,"issue_type":"epic","created_at":"2025-12-26T11:45:05.443231113+01:00","updated_at":"2025-12-26T11:45:05.443231113+01:00","labels":["conformance","epic","phase-8","testing"],"dependencies":[{"issue_id":"automerge-P8","depends_on_id":"automerge-P7","type":"parent-child","created_at":"2025-12-26T13:51:16.084904641+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-4pq","title":"Fix RGA concurrent insert ordering for json-joy compatibility","description":"The RGA algorithm's tie-breaking for concurrent inserts doesn't match json-joy's implementation. When two replicas insert at the same position concurrently, the resulting order differs.\n\nEvidence from conformance tests:\n- Expected: \"An epic synopsis\"  \n- Got: \"A synepic nopsis\" (the \"n\" from \"An\" appears in wrong position)\n\nNeed to analyze json-joy's RGA implementation and match its ordering rules:\n- Understand how json-joy determines concurrent inserts\n- Match tie-breaking logic for timestamp comparison\n- May need to track causal dependencies to determine concurrency","status":"closed","priority":1,"issue_type":"bug","assignee":"claude","created_at":"2025-12-26T17:19:31.628018647+01:00","updated_at":"2025-12-26T17:45:10.110299973+01:00","closed_at":"2025-12-26T17:45:10.110299973+01:00","labels":["conformance","crdt","json-joy","rga"]}
 {"id":"crdt-4ra","title":"Reduce binary codec output size (currently 4x larger than json-joy)","description":"Binary output is 4.9KB vs json-joy's ~1.2KB for 1K chars.\nInvestigate:\n1. Timestamp encoding efficiency (delta encoding?)\n2. RGA chunk representation\n3. Node type encoding overhead\n4. Compare byte-by-byte with json-joy format","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-27T00:34:56.319523298+01:00","updated_at":"2025-12-27T09:29:04.871828606+01:00","closed_at":"2025-12-27T09:29:04.871828606+01:00","labels":["binary-codec","optimization","performance","size"],"dependencies":[{"issue_id":"crdt-4ra","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:56.320955254+01:00","created_by":"gdiazlo"}]}
+{"id":"crdt-68q","title":"Fix compact codec failing tests (friendsforever_flat)","description":"","status":"in_progress","priority":0,"issue_type":"bug","created_at":"2026-01-02T12:15:25.878861438+01:00","updated_at":"2026-01-02T12:15:34.21425901+01:00"}
+{"id":"crdt-6rt","title":"Fix remaining test failures after simdjsont migration","description":"","status":"in_progress","priority":0,"issue_type":"bug","assignee":"gdiazlo","created_at":"2026-01-02T11:36:44.354508505+01:00","updated_at":"2026-01-02T11:36:52.177356478+01:00"}
 {"id":"crdt-7f0","title":"Optimize RGA sequential insert (O(n²) -\u003e O(n log n))","description":"Sequential insert of 10K chars takes 284ms - this is O(n²) behavior.\nOptions:\n1. Use tree-based structure (AVL, finger tree) instead of list\n2. Add index for fast position lookup\n3. Consider json-joy's B+tree approach\n\nTarget: \u003c 50ms for 10K sequential inserts","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:35:00.551809524+01:00","updated_at":"2025-12-27T00:46:27.873263358+01:00","closed_at":"2025-12-27T00:46:27.873263358+01:00","labels":["optimization","performance","rga"],"dependencies":[{"issue_id":"crdt-7f0","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:35:00.557418209+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-9h3","title":"Optimize binary encoding performance (currently 3x slower than json-joy)","description":"Binary encoding is ~21K ops/sec vs json-joy's ~108K ops/sec.\nInvestigate:\n1. Buffer allocation strategy\n2. Varint encoding efficiency\n3. CBOR encoding overhead\n4. Consider pre-allocating buffers based on model size","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:34:52.454913078+01:00","updated_at":"2025-12-27T00:41:24.590935842+01:00","closed_at":"2025-12-27T00:41:24.590935842+01:00","labels":["binary-codec","optimization","performance"],"dependencies":[{"issue_id":"crdt-9h3","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:52.456412445+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-9ry","title":"Run final benchmarks and compare with json-joy","description":"After all optimizations:\n1. Run full benchmark suite\n2. Verify all tests pass\n3. Document comparison with json-joy\n4. Target: exceed json-joy performance across all metrics","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-27T00:35:14.61471182+01:00","updated_at":"2025-12-27T00:46:58.828283923+01:00","closed_at":"2025-12-27T00:46:58.828283923+01:00","labels":["benchmarks","documentation"],"dependencies":[{"issue_id":"crdt-9ry","depends_on_id":"crdt-apw","type":"blocks","created_at":"2025-12-27T00:35:14.620794117+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-9h3","type":"blocks","created_at":"2025-12-27T00:35:14.621445689+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-4ra","type":"blocks","created_at":"2025-12-27T00:35:14.621869631+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-7f0","type":"blocks","created_at":"2025-12-27T00:35:14.622264163+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-z3n","type":"blocks","created_at":"2025-12-27T00:35:14.622793455+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-apw","title":"Investigate binary decode performance (35M ops/sec seems wrong)","description":"Binary decode shows 35M ops/sec which is suspiciously fast. Need to verify:\n1. The decode is actually doing work (not returning cached/memoized result)\n2. The decoded model is correct and usable\n3. Add validation that decoded model matches original","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:34:47.948086278+01:00","updated_at":"2025-12-27T00:38:53.472587773+01:00","closed_at":"2025-12-27T00:38:53.472587773+01:00","labels":["binary-codec","investigation","performance"],"dependencies":[{"issue_id":"crdt-apw","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:47.954081564+01:00","created_by":"gdiazlo"}]}
+{"id":"crdt-bwe","title":"Fix A decode_timestamp","description":"","status":"open","priority":1,"issue_type":"bug","created_at":"2026-01-02T12:06:12.866717163+01:00","updated_at":"2026-01-02T12:06:12.866717163+01:00"}
 {"id":"crdt-icx","title":"Investigate and optimize benchmark performance issues","description":"Investigation and optimization of CRDT library performance based on benchmark comparison with json-joy.\n\nKey findings from initial benchmarks:\n1. Binary decode shows suspiciously fast results (35M ops/sec) - needs verification\n2. Binary encoding is 3x slower than json-joy\n3. Binary codec produces 4x larger output than json-joy\n4. RGA sequential insert is O(n²) - 284ms for 10K chars\n\nTarget: Match or exceed json-joy performance given our more capable CPU.","status":"closed","priority":1,"issue_type":"epic","created_at":"2025-12-27T00:34:36.713327259+01:00","updated_at":"2025-12-27T00:47:00.530534521+01:00","closed_at":"2025-12-27T00:47:00.530534521+01:00","labels":["benchmarks","optimization","performance"]}
 {"id":"crdt-z3n","title":"Add benchmark validation to ensure correctness","description":"Add validation steps to benchmarks:\n1. Verify encode/decode round-trip produces identical model\n2. Verify model view matches expected content\n3. Add checksums/hashes to detect corruption","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:35:03.801590973+01:00","updated_at":"2025-12-27T00:38:54.776020436+01:00","closed_at":"2025-12-27T00:38:54.776020436+01:00","labels":["benchmarks","testing"],"dependencies":[{"issue_id":"crdt-z3n","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:35:03.802861658+01:00","created_by":"gdiazlo"}]}

lib/json_compat.ml

···
+module J = Simdjsont.Json
+
+type json = J.t
+type obj = (string * json) list
+type meta = unit
+
+let meta : meta = ()
+let null : json = J.Null
+let bool (b : bool) : json = J.Bool b
+let number (f : float) : json = J.Float f
+let string (s : string) : json = J.String s
+let array (xs : json list) : json = J.Array xs
+let object_ (fields : obj) : json = J.Object fields
+let to_string (j : json) : string = J.to_string j
+let pp fmt j = Format.pp_print_string fmt (to_string j)
+
+let decode_string (s : string) : (json, string) result =
+  Simdjsont.Decode.decode_string Simdjsont.Decode.value s
+
+let max_safe_int = 9007199254740991L
+let min_safe_int = -9007199254740991L
+
+let int_to_number (i : int) : json =
+  let i64 = Int64.of_int i in
+  if i64 >= min_safe_int && i64 <= max_safe_int then number (Float.of_int i)
+  else J.Int i64
+
+let int64_to_number (i : int64) : json =
+  if i >= min_safe_int && i <= max_safe_int then number (Int64.to_float i)
+  else J.Int i
+
+let float_to_int_opt (f : float) : int option =
+  if
+    Float.is_integer f
+    && f >= Float.of_int Int.min_int
+    && f <= Float.of_int Int.max_int
+  then Some (Float.to_int f)
+  else None
+
+let get_number = function
+  | J.Float f -> Ok f
+  | J.Int i -> Ok (Int64.to_float i)
+  | _ -> Error "expected number"
+
+let get_int = function
+  | J.Float f -> (
+      match float_to_int_opt f with
+      | Some i -> Ok i
+      | None -> Error "expected integer")
+  | J.Int i ->
+      if i >= Int64.of_int Int.min_int && i <= Int64.of_int Int.max_int then
+        Ok (Int64.to_int i)
+      else Error "integer out of range"
+  | _ -> Error "expected integer"
+
+let get_string = function J.String s -> Ok s | _ -> Error "expected string"
+let get_bool = function J.Bool b -> Ok b | _ -> Error "expected bool"
+let get_array = function J.Array xs -> Ok xs | _ -> Error "expected array"
+
+let get_object = function
+  | J.Object fields -> Ok fields
+  | _ -> Error "expected object"
+
+let obj_find (key : string) (fields : obj) : json option =
+  List.find_map (fun (k, v) -> if k = key then Some v else None) fields

lib/model_codec_compact.ml

···
     - 5: bin (binary)
     - 6: arr (array) *)
 
-let meta = Jsont.Meta.none
+module J = Simdjsont.Json
 
-(** Node type codes for compact format *)
 let type_code_con = 0
-
 let type_code_val = 1
 let type_code_obj = 2
 let type_code_vec = 3
 let type_code_str = 4
 let type_code_bin = 5
 let type_code_arr = 6
+let string_span (s : string) : int = String.length s
+let bytes_span (b : bytes) : int = Bytes.length b
 
 type sid_table = {
-  mutable sids : int list; (* List of session IDs in order *)
-  mutable sid_to_idx : (int, int) Hashtbl.t; (* sid -> index (1-based) *)
+  mutable sids : int list;
+  mutable sid_to_idx : (int, int) Hashtbl.t;
 }
-(** Session ID table for relative encoding. Maps session IDs to their index
-    (1-based, negated for encoding). *)
 
 let create_sid_table () = { sids = []; sid_to_idx = Hashtbl.create 16 }
 
···
       Hashtbl.add table.sid_to_idx sid idx;
       idx
 
-(** Encode a timestamp as [relative_sid_index, time]. The sid index is negated
-    for the compact format. *)
-let encode_timestamp table (ts : Clock.timestamp) : Jsont.json =
+let encode_timestamp table (ts : Clock.timestamp) : J.t =
   let idx = get_or_add_sid table ts.sid in
-  Jsont.Array
-    ( [
-        Jsont.Number (Float.of_int (-idx), meta);
-        Jsont.Number (Float.of_int ts.time, meta);
-      ],
-      meta )
+  J.Array [ J.Int (Int64.of_int (-idx)); J.Int (Int64.of_int ts.time) ]
 
-(** Encode a Value.t to JSON for compact format *)
-let rec encode_value (v : Value.t) : Jsont.json =
+let rec encode_value (v : Value.t) : J.t =
   match v with
-  | Value.Null -> Jsont.Null ((), meta)
-  | Value.Undefined ->
-      Jsont.Number (0., meta) (* undefined encoded as 0 in compact con nodes *)
-  | Value.Bool b -> Jsont.Bool (b, meta)
-  | Value.Int i -> Jsont.Number (Float.of_int i, meta)
-  | Value.Float f -> Jsont.Number (f, meta)
-  | Value.String s -> Jsont.String (s, meta)
-  | Value.Bytes b ->
-      Jsont.String (Base64.encode_string (Bytes.to_string b), meta)
-  | Value.Array arr -> Jsont.Array (List.map encode_value arr, meta)
+  | Value.Null -> J.Null
+  | Value.Undefined -> J.Int 0L
+  | Value.Bool b -> J.Bool b
+  | Value.Int i -> J.Int (Int64.of_int i)
+  | Value.Float f -> J.Float f
+  | Value.String s -> J.String s
+  | Value.Bytes b -> J.String (Base64.encode_string (Bytes.to_string b))
+  | Value.Array arr -> J.Array (List.map encode_value arr)
   | Value.Object pairs ->
-      Jsont.Object
-        (List.map (fun (k, v) -> ((k, meta), encode_value v)) pairs, meta)
+      J.Object (List.map (fun (k, v) -> (k, encode_value v)) pairs)
   | Value.Timestamp_ref (sid, time) ->
-      (* Timestamp refs in values - just encode as array *)
-      Jsont.Array
-        ( [
-            Jsont.Number (Float.of_int sid, meta);
-            Jsont.Number (Float.of_int time, meta);
-          ],
-          meta )
+      J.Array [ J.Int (Int64.of_int sid); J.Int (Int64.of_int time) ]
 
-(** Encode string RGA chunks for compact format. Each chunk is
-    [[relative_id, time], value_or_span] *)
-let encode_str_chunks table (rga : string Rga.t) : Jsont.json =
+let encode_str_chunks table (rga : string Rga.t) : J.t =
   let chunks =
     Rga.fold
       (fun acc (chunk : string Rga.chunk) ->
         let id_json = encode_timestamp table chunk.id in
         let chunk_arr =
           if chunk.deleted then
-            (* Deleted chunk: [id, span] *)
-            Jsont.Array
-              ([ id_json; Jsont.Number (Float.of_int chunk.span, meta) ], meta)
-          else
-            (* Active chunk: [id, value] *)
-            Jsont.Array ([ id_json; Jsont.String (chunk.data, meta) ], meta)
+            J.Array [ id_json; J.Float (Float.of_int chunk.span) ]
+          else J.Array [ id_json; J.String chunk.data ]
         in
         chunk_arr :: acc)
       [] rga
   in
-  Jsont.Array (List.rev chunks, meta)
+  J.Array (List.rev chunks)
 
-(** Encode binary RGA chunks for compact format *)
-let encode_bin_chunks table (rga : bytes Rga.t) : Jsont.json =
+let encode_bin_chunks table (rga : bytes Rga.t) : J.t =
   let chunks =
     Rga.fold
       (fun acc (chunk : bytes Rga.chunk) ->
         let id_json = encode_timestamp table chunk.id in
         let chunk_arr =
           if chunk.deleted then
-            Jsont.Array
-              ([ id_json; Jsont.Number (Float.of_int chunk.span, meta) ], meta)
+            J.Array [ id_json; J.Float (Float.of_int chunk.span) ]
           else
             let b64 = Base64.encode_string (Bytes.to_string chunk.data) in
-            Jsont.Array ([ id_json; Jsont.String (b64, meta) ], meta)
+            J.Array [ id_json; J.String b64 ]
         in
         chunk_arr :: acc)
       [] rga
   in
-  Jsont.Array (List.rev chunks, meta)
+  J.Array (List.rev chunks)
 
-(** Encode array RGA chunks for compact format *)
-let rec encode_arr_chunks table model (rga : Clock.timestamp Rga.t) : Jsont.json
-    =
+let rec encode_arr_chunks table model (rga : Clock.timestamp Rga.t) : J.t =
   let chunks =
     Rga.fold
       (fun acc (chunk : Clock.timestamp Rga.chunk) ->
         let id_json = encode_timestamp table chunk.id in
         let chunk_arr =
           if chunk.deleted then
-            Jsont.Array
-              ([ id_json; Jsont.Number (Float.of_int chunk.span, meta) ], meta)
+            J.Array [ id_json; J.Float (Float.of_int chunk.span) ]
           else
-            (* Encode the referenced node inline *)
             match Model.get_node model chunk.data with
             | Some node ->
                 let node_json = encode_node table model node in
-                Jsont.Array
-                  ([ id_json; Jsont.Array ([ node_json ], meta) ], meta)
-            | None -> Jsont.Array ([ id_json; Jsont.Array ([], meta) ], meta)
+                J.Array [ id_json; J.Array [ node_json ] ]
+            | None -> J.Array [ id_json; J.Array [] ]
         in
         chunk_arr :: acc)
       [] rga
   in
-  Jsont.Array (List.rev chunks, meta)
+  J.Array (List.rev chunks)
 
-(** Encode a single node to compact format *)
-and encode_node table model (node : Node.t) : Jsont.json =
+and encode_node table model (node : Node.t) : J.t =
   let id = Node.id node in
   let id_json = encode_timestamp table id in
   match node with
   | Node.Node_con { con_value; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_con, meta) in
+      let type_code = J.Int (Int64.of_int type_code_con) in
       let value_json = encode_value con_value in
-      (* con node: [0, id, value, 0] - the trailing 0 seems to be a flag *)
       let is_undefined =
         match con_value with Value.Undefined -> true | _ -> false
       in
-      if is_undefined then
-        Jsont.Array
-          ( [
-              type_code;
-              id_json;
-              Jsont.Number (0., meta);
-              Jsont.Number (0., meta);
-            ],
-            meta )
-      else Jsont.Array ([ type_code; id_json; value_json ], meta)
+      if is_undefined then J.Array [ type_code; id_json; J.Int 0L; J.Int 0L ]
+      else J.Array [ type_code; id_json; value_json ]
   | Node.Node_val { val_ref; _ } -> (
-      let type_code = Jsont.Number (Float.of_int type_code_val, meta) in
+      let type_code = J.Int (Int64.of_int type_code_val) in
       match val_ref with
-      | None -> Jsont.Array ([ type_code; id_json ], meta)
+      | None -> J.Array [ type_code; id_json ]
       | Some ref_ts -> (
           match Model.get_node model ref_ts with
           | Some ref_node ->
               let ref_json = encode_node table model ref_node in
-              Jsont.Array ([ type_code; id_json; ref_json ], meta)
-          | None -> Jsont.Array ([ type_code; id_json ], meta)))
+              J.Array [ type_code; id_json; ref_json ]
+          | None -> J.Array [ type_code; id_json ]))
   | Node.Node_obj { obj_entries; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_obj, meta) in
+      let type_code = J.Int (Int64.of_int type_code_obj) in
       let map_entries =
         List.filter_map
           (fun (entry : Node.obj_entry) ->
             match Model.get_node model entry.obj_value with
             | Some value_node ->
                 let value_json = encode_node table model value_node in
-                Some ((entry.obj_key, meta), value_json)
+                Some (entry.obj_key, value_json)
             | None -> None)
           obj_entries
       in
-      Jsont.Array
-        ([ type_code; id_json; Jsont.Object (map_entries, meta) ], meta)
+      J.Array [ type_code; id_json; J.Object map_entries ]
   | Node.Node_vec { vec_slots; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_vec, meta) in
+      let type_code = J.Int (Int64.of_int type_code_vec) in
       let max_idx =
         List.fold_left
           (fun acc (s : Node.vec_slot) -> max acc s.vec_idx)
···
       let slots_arr =
         if max_idx < 0 then []
         else begin
-          let arr = Array.make (max_idx + 1) (Jsont.Null ((), meta)) in
+          let arr = Array.make (max_idx + 1) J.Null in
           List.iter
             (fun (s : Node.vec_slot) ->
               match Model.get_node model s.vec_value with
···
           Array.to_list arr
         end
       in
-      Jsont.Array ([ type_code; id_json; Jsont.Array (slots_arr, meta) ], meta)
+      J.Array [ type_code; id_json; J.Array slots_arr ]
   | Node.Node_str { str_rga; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_str, meta) in
-      Jsont.Array ([ type_code; id_json; encode_str_chunks table str_rga ], meta)
+      let type_code = J.Int (Int64.of_int type_code_str) in
+      J.Array [ type_code; id_json; encode_str_chunks table str_rga ]
   | Node.Node_bin { bin_rga; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_bin, meta) in
-      Jsont.Array ([ type_code; id_json; encode_bin_chunks table bin_rga ], meta)
+      let type_code = J.Int (Int64.of_int type_code_bin) in
+      J.Array [ type_code; id_json; encode_bin_chunks table bin_rga ]
   | Node.Node_arr { arr_rga; _ } ->
-      let type_code = Jsont.Number (Float.of_int type_code_arr, meta) in
-      Jsont.Array
-        ([ type_code; id_json; encode_arr_chunks table model arr_rga ], meta)
+      let type_code = J.Int (Int64.of_int type_code_arr) in
+      J.Array [ type_code; id_json; encode_arr_chunks table model arr_rga ]
 
-(** Encode the clock vector as flat array [sid1, time1, sid2, time2, ...] *)
-let encode_clock_from_table table (cv : Clock.clock_vector) : Jsont.json =
-  (* Add local clock to table first *)
+let encode_clock_from_table table (cv : Clock.clock_vector) : J.t =
   let _ = get_or_add_sid table cv.local.clock_sid in
-  (* Add all peers *)
   List.iter
     (fun (sid, _) ->
       let _ = get_or_add_sid table sid in
       ())
     cv.peers;
-  (* Now encode: for each sid in table order, find its time *)
   let entries =
     List.concat_map
       (fun sid ->
···
           if sid = cv.local.clock_sid then cv.local.clock_time
           else match List.assoc_opt sid cv.peers with Some t -> t | None -> 0
         in
-        [
-          Jsont.Number (Float.of_int sid, meta);
-          Jsont.Number (Float.of_int time, meta);
-        ])
+        [ J.Int (Int64.of_int sid); J.Int (Int64.of_int time) ])
       table.sids
   in
-  Jsont.Array (entries, meta)
+  J.Array entries
 
-(** Encode a complete model to compact JSON. Returns
-    [clock_array, root_content_node] (root val is implicit) *)
-let encode (model : Model.t) : Jsont.json =
+let encode (model : Model.t) : J.t =
   let table = create_sid_table () in
-  (* First encode the content (to populate the sid table) *)
   let content_json =
     match model.root with
     | Node.Node_val { val_ref = Some ref_ts; _ } -> (
         match Model.get_node model ref_ts with
         | Some content_node -> encode_node table model content_node
-        | None -> Jsont.Null ((), meta))
-    | _ -> Jsont.Null ((), meta)
+        | None -> J.Null)
+    | _ -> J.Null
   in
-  (* Now encode the clock with all SIDs that were referenced *)
   let clock_json = encode_clock_from_table table model.clock in
-  Jsont.Array ([ clock_json; content_json ], meta)
+  J.Array [ clock_json; content_json ]
 
-(** Encode to JSON string *)
 let encode_string ?(minify = true) model =
   let json = encode model in
-  if minify then Format.asprintf "%a" Jsont.pp_json json
-  else Format.asprintf "%a" (Jsont.pp_json' ()) json
+  let _ = minify in
+  J.to_string json
 
-(** {1 Compact Decoding} *)
-
-(** Decode a timestamp from [relative_sid_index, time] given the sid array *)
-let decode_timestamp sids (json : Jsont.json) : Clock.timestamp option =
+let decode_timestamp sids (json : J.t) : Clock.timestamp option =
+  let int_of_json (json : J.t) : int option =
+    match json with
+    | J.Int i -> Some (Int64.to_int i)
+    | J.Float f -> Some (Float.to_int f)
+    | _ -> None
+  in
   match json with
-  | Jsont.Array ([ Jsont.Number (idx_f, _); Jsont.Number (time_f, _) ], _) ->
-      let idx = Float.to_int idx_f in
-      let time = Float.to_int time_f in
-      (* Index is negative in compact format, 1-based *)
-      let sid_idx = -idx - 1 in
-      if sid_idx >= 0 && sid_idx < Array.length sids then
-        Some { Clock.sid = sids.(sid_idx); time }
-      else None
+  | J.Array [ idx_json; time_json ] -> (
+      match (int_of_json idx_json, int_of_json time_json) with
+      | Some idx, Some time ->
+          if idx < 0 then
+            let sid_idx = -idx - 1 in
+            if sid_idx >= 0 && sid_idx < Array.length sids then
+              Some { Clock.sid = sids.(sid_idx); time }
+            else None
+          else Some { Clock.sid = idx; time }
+      | _ -> None)
   | _ -> None
 
-(** Decode the clock vector from flat array [sid1, time1, sid2, time2, ...] *)
-let decode_clock (json : Jsont.json) : (int array * Clock.clock_vector) option =
+let decode_clock (json : J.t) : (int array * Clock.clock_vector) option =
   match json with
-  | Jsont.Array (entries, _) -> (
+  | J.Array entries -> (
       let rec parse_pairs acc = function
         | [] -> Some (List.rev acc)
-        | Jsont.Number (sid_f, _) :: Jsont.Number (time_f, _) :: rest ->
+        | J.Float sid_f :: J.Float time_f :: rest ->
             parse_pairs ((Float.to_int sid_f, Float.to_int time_f) :: acc) rest
+        | J.Int sid_i :: J.Int time_i :: rest ->
+            parse_pairs ((Int64.to_int sid_i, Int64.to_int time_i) :: acc) rest
         | _ -> None
       in
       match parse_pairs [] entries with
···
       | None -> None)
   | _ -> None
 
-(** Decode a Value.t from compact JSON *)
-let rec decode_value (json : Jsont.json) : Value.t =
+let rec decode_value (json : J.t) : Value.t =
   match json with
-  | Jsont.Null _ -> Value.Null
-  | Jsont.Bool (b, _) -> Value.Bool b
-  | Jsont.Number (f, _) ->
+  | J.Null -> Value.Null
+  | J.Bool b -> Value.Bool b
+  | J.Float f ->
       if Float.is_integer f && Float.abs f < Float.of_int Int.max_int then
         Value.Int (Float.to_int f)
       else Value.Float f
-  | Jsont.String (s, _) -> Value.String s
-  | Jsont.Array (items, _) -> Value.Array (List.map decode_value items)
-  | Jsont.Object (pairs, _) ->
-      Value.Object (List.map (fun ((k, _), v) -> (k, decode_value v)) pairs)
+  | J.Int i ->
+      if Int64.equal i 0L then Value.Undefined else Value.Int (Int64.to_int i)
+  | J.String s -> Value.String s
+  | J.Array items -> Value.Array (List.map decode_value items)
+  | J.Object pairs ->
+      Value.Object (List.map (fun (k, v) -> (k, decode_value v)) pairs)
 
-(** Decode a node from compact format and add to model *)
-let rec decode_node sids model (json : Jsont.json) : Clock.timestamp option =
+let rec decode_node sids model (json : J.t) : Clock.timestamp option =
+  let int_of_json (json : J.t) : int option =
+    match json with
+    | J.Int i -> Some (Int64.to_int i)
+    | J.Float f -> Some (Float.to_int f)
+    | _ -> None
+  in
+  let decode_con id rest =
+    let value =
+      match rest with
+      | [] -> Value.Undefined
+      | [ J.Int 0L; J.Int 0L ] -> Value.Undefined
+      | [ J.Float 0.; J.Float 0. ] -> Value.Undefined
+      | [ J.Int 0L ] -> Value.Undefined
+      | [ J.Float 0. ] -> Value.Undefined
+      | [ v ] -> decode_value v
+      | v :: _ -> decode_value v
+    in
+    let node = Node.make_con ~id ~value in
+    Model.add_node model node;
+    Some id
+  in
+  let decode_val id rest =
+    let node = Node.make_val ~id in
+    Model.add_node model node;
+    (match rest with
+    | [ value_json ] -> (
+        match decode_node sids model value_json with
+        | Some ref_id -> Node.set_val node ~value:ref_id
+        | None -> ())
+    | _ -> ());
+    Some id
+  in
+  let decode_obj id rest =
+    let node = Node.make_obj ~id in
+    Model.add_node model node;
+    (match rest with
+    | [ J.Object entries ] ->
+        List.iter
+          (fun (key, value_json) ->
+            match decode_node sids model value_json with
+            | Some value_id ->
+                Node.set_obj_key node ~key ~value:value_id ~write_ts:value_id
+            | None -> ())
+          entries
+    | _ -> ());
+    Some id
+  in
+  let decode_vec id rest =
+    let node = Node.make_vec ~id in
+    Model.add_node model node;
+    (match rest with
+    | [ J.Array slots ] ->
+        List.iteri
+          (fun idx slot_json ->
+            match slot_json with
+            | J.Null -> ()
+            | _ -> (
+                match decode_node sids model slot_json with
+                | Some value_id ->
+                    Node.set_vec_slot node ~idx ~value:value_id
+                      ~write_ts:value_id
+                | None -> ()))
+          slots
+    | _ -> ());
+    Some id
+  in
+  let decode_str id rest =
+    let rec build_chunks acc parent = function
+      | [] -> List.rev acc
+      | J.Array [ chunk_id_json; value_or_span ] :: rest_chunks -> (
+          match decode_timestamp sids chunk_id_json with
+          | None -> build_chunks acc parent rest_chunks
+          | Some chunk_id -> (
+              match value_or_span with
+              | J.String text ->
+                  let span = String.length text in
+                  let chunk : string Rga.chunk =
+                    {
+                      id = chunk_id;
+                      span;
+                      data = text;
+                      deleted = false;
+                      parent;
+                    }
+                  in
+                  let last =
+                    Some
+                      {
+                        chunk_id with
+                        Clock.time = chunk_id.Clock.time + span - 1;
+                      }
+                  in
+                  build_chunks (chunk :: acc) last rest_chunks
+              | _ -> (
+                  match int_of_json value_or_span with
+                  | None -> build_chunks acc parent rest_chunks
+                  | Some span ->
+                      let chunk : string Rga.chunk =
+                        {
+                          id = chunk_id;
+                          span;
+                          data = String.make span '\x00';
+                          deleted = true;
+                          parent;
+                        }
+                      in
+                      let last =
+                        Some
+                          {
+                            chunk_id with
+                            Clock.time = chunk_id.Clock.time + span - 1;
+                          }
+                      in
+                      build_chunks (chunk :: acc) last rest_chunks)))
+      | _ :: rest_chunks -> build_chunks acc parent rest_chunks
+    in
+    let str_rga =
+      match rest with
+      | [ J.Array chunks ] -> Rga.from_chunks (build_chunks [] None chunks)
+      | _ -> Rga.empty ()
+    in
+    let node = Node.Node_str { str_id = id; str_rga } in
+    Model.add_node model node;
+    Some id
+  in
+  let decode_bin id rest =
+    let rec build_chunks acc parent = function
+      | [] -> List.rev acc
+      | J.Array [ chunk_id_json; value_or_span ] :: rest_chunks -> (
+          match decode_timestamp sids chunk_id_json with
+          | None -> build_chunks acc parent rest_chunks
+          | Some chunk_id -> (
+              match value_or_span with
+              | J.String s -> (
+                  match Base64.decode s with
+                  | Error _ -> build_chunks acc parent rest_chunks
+                  | Ok decoded ->
+                      let data = Bytes.of_string decoded in
+                      let span = Bytes.length data in
+                      let chunk : bytes Rga.chunk =
+                        { id = chunk_id; span; data; deleted = false; parent }
+                      in
+                      let last =
+                        Some
+                          {
+                            chunk_id with
+                            Clock.time = chunk_id.Clock.time + span - 1;
+                          }
+                      in
+                      build_chunks (chunk :: acc) last rest_chunks)
+              | _ -> (
+                  match int_of_json value_or_span with
+                  | None -> build_chunks acc parent rest_chunks
+                  | Some span ->
+                      let chunk : bytes Rga.chunk =
+                        {
+                          id = chunk_id;
+                          span;
+                          data = Bytes.make span '\x00';
+                          deleted = true;
+                          parent;
+                        }
+                      in
+                      let last =
+                        Some
+                          {
+                            chunk_id with
+                            Clock.time = chunk_id.Clock.time + span - 1;
+                          }
+                      in
+                      build_chunks (chunk :: acc) last rest_chunks)))
+      | _ :: rest_chunks -> build_chunks acc parent rest_chunks
+    in
+    let bin_rga =
+      match rest with
+      | [ J.Array chunks ] -> Rga.from_chunks (build_chunks [] None chunks)
+      | _ -> Rga.empty ()
+    in
+    let node = Node.Node_bin { bin_id = id; bin_rga } in
+    Model.add_node model node;
+    Some id
+  in
+  let decode_arr id rest =
+    let node = Node.make_arr ~id in
+    Model.add_node model node;
+    (match rest with
+    | [ J.Array chunks ] ->
+        List.iter
+          (fun chunk_json ->
+            match chunk_json with
+            | J.Array [ chunk_id_json; value_json ] -> (
+                match decode_timestamp sids chunk_id_json with
+                | Some chunk_id -> (
+                    match value_json with
+                    | J.Array [ elem_json ] -> (
+                        match decode_node sids model elem_json with
+                        | Some elem_id ->
+                            let after =
+                              match node with
+                              | Node.Node_arr { arr_rga; _ } ->
+                                  Rga.find_last_id arr_rga
+                              | _ -> None
+                            in
+                            Node.insert_arr node ~after ~chunk_id ~value:elem_id
+                        | None -> ())
+                    | J.Array elements ->
+                        List.iteri
+                          (fun i elem_json ->
+                            match decode_node sids model elem_json with
+                            | Some elem_id ->
+                                let after =
+                                  match node with
+                                  | Node.Node_arr { arr_rga; _ } ->
+                                      Rga.find_last_id arr_rga
+                                  | _ -> None
+                                in
+                                let slot_id =
+                                  {
+                                    chunk_id with
+                                    Clock.time = chunk_id.Clock.time + i;
+                                  }
+                                in
+                                Node.insert_arr node ~after ~chunk_id:slot_id
+                                  ~value:elem_id
+                            | None -> ())
+                          elements
+                    | span_json -> (
+                        match int_of_json span_json with
+                        | Some span ->
+                            Node.delete_range node
+                              ~spans:
+                                [
+                                  {
+                                    sid = chunk_id.sid;
+                                    time = chunk_id.time;
+                                    span;
+                                  };
+                                ]
+                        | None -> ()))
+                | None -> ())
+            | _ -> ())
+          chunks
+    | _ -> ());
+    Some id
+  in
   match json with
-  | Jsont.Array (Jsont.Number (type_code_f, _) :: id_json :: rest, _) -> (
-      let type_code = Float.to_int type_code_f in
-      match decode_timestamp sids id_json with
-      | Some id -> (
+  | J.Array (type_code_json :: id_json :: rest) -> (
+      match (int_of_json type_code_json, decode_timestamp sids id_json) with
+      | Some type_code, Some id -> (
           match type_code with
-          | 0 ->
-              (* con *)
-              let value =
-                match rest with
-                | [] -> Value.Undefined
-                | [ Jsont.Number (0., _); Jsont.Number (0., _) ] ->
-                    Value.Undefined
-                | [ Jsont.Number (0., _) ] -> Value.Undefined
-                | [ v ] -> decode_value v
-                | v :: _ -> decode_value v
-              in
-              let node = Node.make_con ~id ~value in
-              Model.add_node model node;
-              Some id
-          | 1 ->
-              (* val *)
-              let node = Node.make_val ~id in
-              Model.add_node model node;
-              (match rest with
-              | [ value_json ] -> (
-                  match decode_node sids model value_json with
-                  | Some ref_id -> Node.set_val node ~value:ref_id
-                  | None -> ())
-              | _ -> ());
-              Some id
-          | 2 ->
-              (* obj *)
-              let node = Node.make_obj ~id in
-              Model.add_node model node;
-              (match rest with
-              | [ Jsont.Object (entries, _) ] ->
-                  List.iter
-                    (fun ((key, _), value_json) ->
-                      match decode_node sids model value_json with
-                      | Some value_id ->
-                          Node.set_obj_key node ~key ~value:value_id
-                            ~write_ts:value_id
-                      | None -> ())
-                    entries
-              | _ -> ());
-              Some id
-          | 3 ->
-              (* vec *)
-              let node = Node.make_vec ~id in
-              Model.add_node model node;
-              (match rest with
-              | [ Jsont.Array (slots, _) ] ->
-                  List.iteri
-                    (fun idx slot_json ->
-                      match slot_json with
-                      | Jsont.Null _ -> ()
-                      | _ -> (
-                          match decode_node sids model slot_json with
-                          | Some value_id ->
-                              Node.set_vec_slot node ~idx ~value:value_id
-                                ~write_ts:value_id
-                          | None -> ()))
-                    slots
-              | _ -> ());
-              Some id
-          | 4 ->
-              (* str - build chunks directly from list *)
-              let str_rga =
-                match rest with
-                | [ Jsont.Array (chunks, _) ] ->
-                    let decoded_chunks =
-                      List.filter_map
-                        (fun chunk_json ->
-                          match chunk_json with
-                          | Jsont.Array ([ chunk_id_json; value_or_span ], _)
-                            -> (
-                              match decode_timestamp sids chunk_id_json with
-                              | Some chunk_id -> (
-                                  match value_or_span with
-                                  | Jsont.String (s, _) ->
-                                      Some
-                                        {
-                                          Rga.id = chunk_id;
-                                          span = String.length s;
-                                          data = s;
-                                          deleted = false;
-                                          parent = None;
-                                        }
-                                  | Jsont.Number (span_f, _) ->
-                                      let span = Float.to_int span_f in
-                                      Some
-                                        {
-                                          Rga.id = chunk_id;
-                                          span;
-                                          data = String.make span ' ';
-                                          deleted = true;
-                                          parent = None;
-                                        }
-                                  | _ -> None)
-                              | None -> None)
-                          | _ -> None)
-                        chunks
-                    in
-                    Rga.from_chunks decoded_chunks
-                | _ -> Rga.empty ()
-              in
-              let node = Node.Node_str { str_id = id; str_rga } in
-              Model.add_node model node;
-              Some id
-          | 5 ->
-              (* bin - build chunks directly from list *)
-              let bin_rga =
-                match rest with
-                | [ Jsont.Array (chunks, _) ] ->
-                    let decoded_chunks =
-                      List.filter_map
-                        (fun chunk_json ->
-                          match chunk_json with
-                          | Jsont.Array ([ chunk_id_json; value_or_span ], _)
-                            -> (
-                              match decode_timestamp sids chunk_id_json with
-                              | Some chunk_id -> (
-                                  match value_or_span with
-                                  | Jsont.String (s, _) -> (
-                                      match Base64.decode s with
-                                      | Ok decoded ->
-                                          let data = Bytes.of_string decoded in
-                                          Some
-                                            {
-                                              Rga.id = chunk_id;
-                                              span = Bytes.length data;
-                                              data;
-                                              deleted = false;
-                                              parent = None;
-                                            }
-                                      | Error _ -> None)
-                                  | Jsont.Number (span_f, _) ->
-                                      let span = Float.to_int span_f in
-                                      Some
-                                        {
-                                          Rga.id = chunk_id;
-                                          span;
-                                          data = Bytes.make span '\x00';
-                                          deleted = true;
-                                          parent = None;
-                                        }
-                                  | _ -> None)
-                              | None -> None)
-                          | _ -> None)
-                        chunks
-                    in
-                    Rga.from_chunks decoded_chunks
-                | _ -> Rga.empty ()
-              in
-              let node = Node.Node_bin { bin_id = id; bin_rga } in
-              Model.add_node model node;
-              Some id
-          | 6 ->
-              (* arr *)
-              let node = Node.make_arr ~id in
-              Model.add_node model node;
-              (match rest with
-              | [ Jsont.Array (chunks, _) ] ->
-                  List.iter
-                    (fun chunk_json ->
-                      match chunk_json with
-                      | Jsont.Array ([ chunk_id_json; value_json ], _) -> (
-                          match decode_timestamp sids chunk_id_json with
-                          | Some chunk_id -> (
-                              match value_json with
-                              | Jsont.Array ([ elem_json ], _) -> (
-                                  (* Single element in value array *)
-                                  match decode_node sids model elem_json with
-                                  | Some elem_id ->
-                                      let after =
-                                        match node with
-                                        | Node.Node_arr { arr_rga; _ } ->
-                                            Rga.find_last_id arr_rga
-                                        | _ -> None
-                                      in
-                                      Node.insert_arr node ~after ~chunk_id
-                                        ~value:elem_id
-                                  | None -> ())
-                              | Jsont.Array (elements, _) ->
-                                  (* Multiple elements *)
-                                  List.iteri
-                                    (fun i elem_json ->
-                                      match
-                                        decode_node sids model elem_json
-                                      with
-                                      | Some elem_id ->
-                                          let after =
-                                            match node with
-                                            | Node.Node_arr { arr_rga; _ } ->
-                                                Rga.find_last_id arr_rga
-                                            | _ -> None
-                                          in
-                                          let slot_id =
-                                            {
-                                              chunk_id with
-                                              Clock.time =
-                                                chunk_id.Clock.time + i;
-                                            }
-                                          in
-                                          Node.insert_arr node ~after
-                                            ~chunk_id:slot_id ~value:elem_id
-                                      | None -> ())
-                                    elements
-                              | Jsont.Number (span_f, _) ->
-                                  (* Deleted chunk *)
-                                  let span = Float.to_int span_f in
-                                  let after =
-                                    match node with
-                                    | Node.Node_arr { arr_rga; _ } ->
-                                        Rga.find_last_id arr_rga
-                                    | _ -> None
-                                  in
-                                  Node.insert_arr node ~after ~chunk_id
-                                    ~value:chunk_id;
-                                  Node.delete_range node
-                                    ~spans:
-                                      [
-                                        {
-                                          sid = chunk_id.sid;
-                                          time = chunk_id.time;
-                                          span;
-                                        };
-                                      ]
-                              | _ -> ())
-                          | None -> ())
-                      | _ -> ())
-                    chunks
-              | _ -> ());
-              Some id
+          | 0 -> decode_con id rest
+          | 1 -> decode_val id rest
+          | 2 -> decode_obj id rest
+          | 3 -> decode_vec id rest
+          | 4 -> decode_str id rest
+          | 5 -> decode_bin id rest
+          | 6 -> decode_arr id rest
           | _ -> None)
-      | None -> None)
+      | _ -> None)
   | _ -> None
 
-(** Decode a complete model from compact JSON *)
-let decode (json : Jsont.json) : Model.t option =
+let decode (json : J.t) : Model.t option =
   match json with
-  | Jsont.Array ([ clock_json; content_json ], _) -> (
+  | J.Array [ clock_json; content_json ] -> (
       match decode_clock clock_json with
       | Some (sids, clock) ->
           let model = Model.create clock.local.clock_sid in
           model.clock.local.clock_time <- clock.local.clock_time;
           model.clock.peers <- clock.peers;
-          (* Decode the content node and set as root's value *)
-          (match decode_node sids model content_json with
-          | Some ref_id -> Node.set_val model.root ~value:ref_id
-          | None -> ());
+          (match content_json with
+          | J.Null -> ()
+          | _ -> (
+              match decode_node sids model content_json with
+              | Some content_id -> Node.set_val model.root ~value:content_id
+              | None -> ()));
           Some model
       | None -> None)
   | _ -> None
 
-(** Decode from JSON string *)
 let decode_string s =
-  match Jsont_bytesrw.decode_string Jsont.json s with
+  match Simdjsont.Decode.decode_string Simdjsont.Decode.value s with
   | Ok json -> decode json
   | Error e ->
       Printf.eprintf "JSON parse error: %s\n" e;

lib/patch_codec_compact.ml

···
     - 16: del
     - 17: nop *)
 
-(** {1 Compact Opcodes} *)
+module J = Simdjsont.Json
 
-(** Compact opcode values (different from verbose op names!) *)
 let compact_opcode_of_op = function
   | Op.Op_new_con _ -> 0
   | Op.Op_new_val -> 1
···
   | Op.Op_del _ -> 16
   | Op.Op_nop _ -> 17
 
-(** {1 Helpers} *)
-
-let meta = Jsont.Meta.none
+let encode_ts ~patch_sid (ts : Clock.timestamp) : J.t =
+  if ts.sid = patch_sid then J.Float (Float.of_int ts.time)
+  else J.Array [ J.Float (Float.of_int ts.sid); J.Float (Float.of_int ts.time) ]
 
-(** Encode a timestamp. If session matches patch session, just encode time.
-    Otherwise encode as [sid, time]. *)
-let encode_ts ~patch_sid (ts : Clock.timestamp) : Jsont.json =
-  if ts.sid = patch_sid then Jsont.Number (Float.of_int ts.time, meta)
-  else
-    Jsont.Array
-      ( [
-          Jsont.Number (Float.of_int ts.sid, meta);
-          Jsont.Number (Float.of_int ts.time, meta);
-        ],
-        meta )
-
-(** Encode a timespan as [time, span] or [[sid, time], span] *)
-let encode_timespan ~patch_sid (ts : Clock.timespan) : Jsont.json =
+let encode_timespan ~patch_sid (ts : Clock.timespan) : J.t =
   if ts.sid = patch_sid then
-    Jsont.Array
-      ( [
-          Jsont.Number (Float.of_int ts.time, meta);
-          Jsont.Number (Float.of_int ts.span, meta);
-        ],
-        meta )
+    J.Array [ J.Float (Float.of_int ts.time); J.Float (Float.of_int ts.span) ]
   else
-    Jsont.Array
-      ( [
-          Jsont.Array
-            ( [
-                Jsont.Number (Float.of_int ts.sid, meta);
-                Jsont.Number (Float.of_int ts.time, meta);
-              ],
-              meta );
-          Jsont.Number (Float.of_int ts.span, meta);
-        ],
-        meta )
+    J.Array
+      [
+        J.Array
+          [ J.Float (Float.of_int ts.sid); J.Float (Float.of_int ts.time) ];
+        J.Float (Float.of_int ts.span);
+      ]
 
-(** Encode a value for new_con *)
-let encode_con_value (v : Value.t) : Jsont.json =
+let encode_con_value (v : Value.t) : J.t =
   match v with
-  | Value.Null -> Jsont.Null ((), meta)
-  | Value.Bool b -> Jsont.Bool (b, meta)
-  | Value.Int n -> Jsont.Number (Float.of_int n, meta)
-  | Value.Float f -> Jsont.Number (f, meta)
-  | Value.String s -> Jsont.String (s, meta)
-  | _ -> Jsont.Null ((), meta)
-
-(** {1 Operation Encoding} *)
+  | Value.Null -> J.Null
+  | Value.Bool b -> J.Bool b
+  | Value.Int n -> J.Float (Float.of_int n)
+  | Value.Float f -> J.Float f
+  | Value.String s -> J.String s
+  | _ -> J.Null
 
-(** Encode an operation in compact format *)
-let encode_op ~patch_sid (op : Op.op_data) : Jsont.json =
-  let opcode = Jsont.Number (Float.of_int (compact_opcode_of_op op), meta) in
+let encode_op ~patch_sid (op : Op.op_data) : J.t =
+  let opcode = J.Float (Float.of_int (compact_opcode_of_op op)) in
   match op with
   | Op.Op_new_con { con_value } ->
-      Jsont.Array ([ opcode; encode_con_value con_value ], meta)
+      J.Array [ opcode; encode_con_value con_value ]
   | Op.Op_new_val | Op.Op_new_obj | Op.Op_new_vec | Op.Op_new_str
   | Op.Op_new_bin | Op.Op_new_arr ->
-      Jsont.Array ([ opcode ], meta)
+      J.Array [ opcode ]
   | Op.Op_ins_val { ins_val_obj; ins_val_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid ins_val_obj;
-            encode_ts ~patch_sid ins_val_value;
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid ins_val_obj;
+          encode_ts ~patch_sid ins_val_value;
+        ]
   | Op.Op_ins_obj { ins_obj_obj; ins_obj_value } ->
       let entries =
         List.map
-          (fun (key, ts) ->
-            Jsont.Array
-              ([ Jsont.String (key, meta); encode_ts ~patch_sid ts ], meta))
+          (fun (key, ts) -> J.Array [ J.String key; encode_ts ~patch_sid ts ])
           ins_obj_value
       in
-      Jsont.Array
-        ( [
-            opcode; encode_ts ~patch_sid ins_obj_obj; Jsont.Array (entries, meta);
-          ],
-          meta )
+      J.Array [ opcode; encode_ts ~patch_sid ins_obj_obj; J.Array entries ]
   | Op.Op_ins_vec { ins_vec_obj; ins_vec_idx; ins_vec_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid ins_vec_obj;
-            Jsont.Number (Float.of_int ins_vec_idx, meta);
-            encode_ts ~patch_sid ins_vec_value;
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid ins_vec_obj;
+          J.Float (Float.of_int ins_vec_idx);
+          encode_ts ~patch_sid ins_vec_value;
+        ]
   | Op.Op_ins_str { ins_str_obj; ins_str_after; ins_str_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid ins_str_obj;
-            encode_ts ~patch_sid ins_str_after;
-            Jsont.String (ins_str_value, meta);
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid ins_str_obj;
+          encode_ts ~patch_sid ins_str_after;
+          J.String ins_str_value;
+        ]
   | Op.Op_ins_bin { ins_bin_obj; ins_bin_after; ins_bin_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid ins_bin_obj;
-            encode_ts ~patch_sid ins_bin_after;
-            Jsont.String
-              (Base64.encode_string (Bytes.to_string ins_bin_value), meta);
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid ins_bin_obj;
+          encode_ts ~patch_sid ins_bin_after;
+          J.String (Base64.encode_string (Bytes.to_string ins_bin_value));
+        ]
   | Op.Op_ins_arr { ins_arr_obj; ins_arr_after; ins_arr_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid ins_arr_obj;
-            encode_ts ~patch_sid ins_arr_after;
-            encode_ts ~patch_sid ins_arr_value;
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid ins_arr_obj;
+          encode_ts ~patch_sid ins_arr_after;
+          encode_ts ~patch_sid ins_arr_value;
+        ]
   | Op.Op_upd_arr { upd_arr_obj; upd_arr_pos; upd_arr_value } ->
-      Jsont.Array
-        ( [
-            opcode;
-            encode_ts ~patch_sid upd_arr_obj;
-            encode_ts ~patch_sid upd_arr_pos;
-            encode_ts ~patch_sid upd_arr_value;
-          ],
-          meta )
+      J.Array
+        [
+          opcode;
+          encode_ts ~patch_sid upd_arr_obj;
+          encode_ts ~patch_sid upd_arr_pos;
+          encode_ts ~patch_sid upd_arr_value;
+        ]
   | Op.Op_del { del_obj; del_what } ->
       let spans = List.map (encode_timespan ~patch_sid) del_what in
-      Jsont.Array
-        ( [ opcode; encode_ts ~patch_sid del_obj; Jsont.Array (spans, meta) ],
-          meta )
+      J.Array [ opcode; encode_ts ~patch_sid del_obj; J.Array spans ]
   | Op.Op_nop { nop_len } ->
-      if nop_len = 1 then Jsont.Array ([ opcode ], meta)
-      else
-        Jsont.Array ([ opcode; Jsont.Number (Float.of_int nop_len, meta) ], meta)
+      if nop_len = 1 then J.Array [ opcode ]
+      else J.Array [ opcode; J.Float (Float.of_int nop_len) ]
 
-(** {1 Patch Encoding} *)
-
-(** Encode a patch to compact JSON *)
-let encode_patch_json (patch : Patch.t) : Jsont.json =
+let encode_patch_json (patch : Patch.t) : J.t =
   let patch_sid = patch.id.sid in
   let id_json =
-    Jsont.Array
-      ( [
-          Jsont.Array
-            ( [
-                Jsont.Number (Float.of_int patch.id.sid, meta);
-                Jsont.Number (Float.of_int patch.id.time, meta);
-              ],
-              meta );
-        ],
-        meta )
+    J.Array
+      [
+        J.Array
+          [
+            J.Float (Float.of_int patch.id.sid);
+            J.Float (Float.of_int patch.id.time);
+          ];
+      ]
   in
   let ops_json = List.map (encode_op ~patch_sid) patch.ops in
-  Jsont.Array (id_json :: ops_json, meta)
+  J.Array (id_json :: ops_json)
 
-(** Encode a patch to a compact JSON string *)
 let encode (patch : Patch.t) : string =
   let json = encode_patch_json patch in
-  Format.asprintf "%a" Jsont.pp_json json
+  J.to_string json
 
-(** Encode a patch to a pretty-printed JSON string *)
 let encode_pretty (patch : Patch.t) : string =
   let json = encode_patch_json patch in
-  Format.asprintf "%a" (Jsont.pp_json' ()) json
-
-(** {1 Decoding Helpers} *)
+  J.to_string json
 
-(** Decode a timestamp. Can be either just a number (time) or [sid, time] array.
-*)
-let decode_ts ~patch_sid (json : Jsont.json) : Clock.timestamp option =
+let decode_ts ~patch_sid (json : J.t) : Clock.timestamp option =
   match json with
-  | Jsont.Number (time, _) -> Some { sid = patch_sid; time = Float.to_int time }
-  | Jsont.Array ([ Jsont.Number (sid, _); Jsont.Number (time, _) ], _) ->
+  | J.Float time -> Some { sid = patch_sid; time = Float.to_int time }
+  | J.Int time -> Some { sid = patch_sid; time = Int64.to_int time }
+  | J.Array [ J.Float sid; J.Float time ] ->
       Some { sid = Float.to_int sid; time = Float.to_int time }
+  | J.Array [ J.Int sid; J.Int time ] ->
+      Some { sid = Int64.to_int sid; time = Int64.to_int time }
   | _ -> None
 
-(** Decode a timespan. Can be:
-    - [time, span] (same session)
-    - [[sid, time], span] (different session, nested)
-    - [sid, time, span] (different session, flat) *)
-let decode_timespan ~patch_sid (json : Jsont.json) : Clock.timespan option =
+let decode_timespan ~patch_sid (json : J.t) : Clock.timespan option =
   match json with
-  | Jsont.Array ([ Jsont.Number (time, _); Jsont.Number (span, _) ], _) ->
+  | J.Array [ J.Float time; J.Float span ] ->
       Some
         { sid = patch_sid; time = Float.to_int time; span = Float.to_int span }
-  | Jsont.Array
-      ( [
-          Jsont.Array ([ Jsont.Number (sid, _); Jsont.Number (time, _) ], _);
-          Jsont.Number (span, _);
-        ],
-        _ ) ->
+  | J.Array [ J.Int time; J.Int span ] ->
+      Some
+        { sid = patch_sid; time = Int64.to_int time; span = Int64.to_int span }
+  | J.Array [ J.Array [ J.Float sid; J.Float time ]; J.Float span ] ->
       Some
         {
           sid = Float.to_int sid;
           time = Float.to_int time;
           span = Float.to_int span;
         }
-  | Jsont.Array
-      ( [ Jsont.Number (sid, _); Jsont.Number (time, _); Jsont.Number (span, _) ],
-        _ ) ->
-      (* Flat format: [sid, time, span] *)
+  | J.Array [ J.Array [ J.Int sid; J.Int time ]; J.Int span ] ->
+      Some
+        {
+          sid = Int64.to_int sid;
+          time = Int64.to_int time;
+          span = Int64.to_int span;
+        }
+  | J.Array [ J.Float sid; J.Float time; J.Float span ] ->
       Some
         {
           sid = Float.to_int sid;
           time = Float.to_int time;
           span = Float.to_int span;
         }
+  | J.Array [ J.Int sid; J.Int time; J.Int span ] ->
+      Some
+        {
+          sid = Int64.to_int sid;
+          time = Int64.to_int time;
+          span = Int64.to_int span;
+        }
   | _ -> None
 
-(** Decode a Value.t from compact JSON *)
-let decode_con_value (json : Jsont.json) : Value.t =
+let decode_con_value (json : J.t) : Value.t =
   match json with
-  | Jsont.Null _ -> Value.Null
-  | Jsont.Bool (b, _) -> Value.Bool b
-  | Jsont.Number (f, _) ->
+  | J.Null -> Value.Null
+  | J.Bool b -> Value.Bool b
+  | J.Float f ->
       if Float.is_integer f then Value.Int (Float.to_int f) else Value.Float f
-  | Jsont.String (s, _) -> Value.String s
+  | J.Int i -> Value.Int (Int64.to_int i)
+  | J.String s -> Value.String s
   | _ -> Value.Null
 
-(** {1 Operation Decoding} *)
-
-(** Get an element from a JSON array at index *)
 let get_arr_elem arr idx =
   if idx < List.length arr then Some (List.nth arr idx) else None
 
-(** Decode an operation from compact format *)
-let decode_op ~patch_sid (json : Jsont.json) : (Op.op_data, string) result =
+let _ = get_arr_elem
+
+let decode_op ~patch_sid (json : J.t) : (Op.op_data, string) result =
   match json with
-  | Jsont.Array (elems, _) -> (
+  | J.Array elems -> (
       match elems with
       | [] -> Error "empty operation array"
-      | Jsont.Number (opcode_f, _) :: args -> (
+      | J.Float opcode_f :: args -> (
           let opcode = Float.to_int opcode_f in
           match opcode with
           | 0 -> (
-              (* new_con - value can be missing (undefined) or present *)
+              match args with
+              | [] -> Ok (Op.Op_new_con { con_value = Value.Undefined })
+              | [ value_json ] ->
+                  Ok (Op.Op_new_con { con_value = decode_con_value value_json })
+              | _ -> Error "new_con: unexpected arguments")
+          | 1 -> Ok Op.Op_new_val
+          | 2 -> Ok Op.Op_new_obj
+          | 3 -> Ok Op.Op_new_vec
+          | 4 -> Ok Op.Op_new_str
+          | 5 -> Ok Op.Op_new_bin
+          | 6 -> Ok Op.Op_new_arr
+          | 9 -> (
+              match args with
+              | [ obj_json; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some value ->
+                      Ok
+                        (Op.Op_ins_val
+                           { ins_val_obj = obj; ins_val_value = value })
+                  | _ -> Error "ins_val: invalid timestamp")
+              | _ -> Error "ins_val: expected obj, value")
+          | 10 -> (
+              match args with
+              | [ obj_json; J.Array entries ] -> (
+                  match decode_ts ~patch_sid obj_json with
+                  | Some obj ->
+                      let decode_entry json =
+                        match json with
+                        | J.Array [ J.String key; ts_json ] -> (
+                            match decode_ts ~patch_sid ts_json with
+                            | Some ts -> Some (key, ts)
+                            | None -> None)
+                        | _ -> None
+                      in
+                      let decoded = List.filter_map decode_entry entries in
+                      if List.length decoded = List.length entries then
+                        Ok
+                          (Op.Op_ins_obj
+                             { ins_obj_obj = obj; ins_obj_value = decoded })
+                      else Error "ins_obj: invalid entry format"
+                  | None -> Error "ins_obj: invalid obj timestamp")
+              | _ -> Error "ins_obj: expected obj, entries")
+          | 11 -> (
+              match args with
+              | [ obj_json; J.Float idx_f; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some value ->
+                      Ok
+                        (Op.Op_ins_vec
+                           {
+                             ins_vec_obj = obj;
+                             ins_vec_idx = Float.to_int idx_f;
+                             ins_vec_value = value;
+                           })
+                  | _ -> Error "ins_vec: invalid timestamp")
+              | [ obj_json; J.Int idx_i; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some value ->
+                      Ok
+                        (Op.Op_ins_vec
+                           {
+                             ins_vec_obj = obj;
+                             ins_vec_idx = Int64.to_int idx_i;
+                             ins_vec_value = value;
+                           })
+                  | _ -> Error "ins_vec: invalid timestamp")
+              | _ -> Error "ins_vec: expected obj, idx, value")
+          | 12 -> (
+              match args with
+              | [ obj_json; after_json; J.String value ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid after_json )
+                  with
+                  | Some obj, Some after ->
+                      Ok
+                        (Op.Op_ins_str
+                           {
+                             ins_str_obj = obj;
+                             ins_str_after = after;
+                             ins_str_value = value;
+                           })
+                  | _ -> Error "ins_str: invalid timestamp")
+              | _ -> Error "ins_str: expected obj, after, value")
+          | 13 -> (
+              match args with
+              | [ obj_json; after_json; J.String b64_value ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid after_json )
+                  with
+                  | Some obj, Some after -> (
+                      match Base64.decode b64_value with
+                      | Ok decoded ->
+                          Ok
+                            (Op.Op_ins_bin
+                               {
+                                 ins_bin_obj = obj;
+                                 ins_bin_after = after;
+                                 ins_bin_value = Bytes.of_string decoded;
+                               })
+                      | Error _ -> Error "ins_bin: invalid base64")
+                  | _ -> Error "ins_bin: invalid timestamp")
+              | _ -> Error "ins_bin: expected obj, after, value")
+          | 14 -> (
+              match args with
+              | [ obj_json; after_json; J.Array values_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid after_json )
+                  with
+                  | Some obj, Some after -> (
+                      match values_json with
+                      | [ first_value ] -> (
+                          match decode_ts ~patch_sid first_value with
+                          | Some value ->
+                              Ok
+                                (Op.Op_ins_arr
+                                   {
+                                     ins_arr_obj = obj;
+                                     ins_arr_after = after;
+                                     ins_arr_value = value;
+                                   })
+                          | None -> Error "ins_arr: invalid value timestamp")
+                      | _ -> (
+                          let decoded_values =
+                            List.filter_map (decode_ts ~patch_sid) values_json
+                          in
+                          match decoded_values with
+                          | value :: _ ->
+                              Ok
+                                (Op.Op_ins_arr
+                                   {
+                                     ins_arr_obj = obj;
+                                     ins_arr_after = after;
+                                     ins_arr_value = value;
+                                   })
+                          | [] -> Error "ins_arr: no valid value timestamps"))
+                  | _ -> Error "ins_arr: invalid obj/after timestamp")
+              | [ obj_json; after_json; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid after_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some after, Some value ->
+                      Ok
+                        (Op.Op_ins_arr
+                           {
+                             ins_arr_obj = obj;
+                             ins_arr_after = after;
+                             ins_arr_value = value;
+                           })
+                  | _ -> Error "ins_arr: invalid timestamp")
+              | _ -> Error "ins_arr: expected obj, after, value")
+          | 15 -> (
+              match args with
+              | [ obj_json; pos_json; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid pos_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some pos, Some value ->
+                      Ok
+                        (Op.Op_upd_arr
+                           {
+                             upd_arr_obj = obj;
+                             upd_arr_pos = pos;
+                             upd_arr_value = value;
+                           })
+                  | _ -> Error "upd_arr: invalid timestamp")
+              | _ -> Error "upd_arr: expected obj, pos, value")
+          | 16 -> (
+              match args with
+              | [ obj_json; J.Array spans_json ] -> (
+                  match decode_ts ~patch_sid obj_json with
+                  | Some obj ->
+                      let decoded =
+                        List.filter_map (decode_timespan ~patch_sid) spans_json
+                      in
+                      if List.length decoded = List.length spans_json then
+                        Ok (Op.Op_del { del_obj = obj; del_what = decoded })
+                      else Error "del: invalid timespan format"
+                  | None -> Error "del: invalid obj timestamp")
+              | _ -> Error "del: expected obj, spans")
+          | 17 -> (
+              match args with
+              | [] -> Ok (Op.Op_nop { nop_len = 1 })
+              | [ J.Float len ] -> Ok (Op.Op_nop { nop_len = Float.to_int len })
+              | [ J.Int len ] -> Ok (Op.Op_nop { nop_len = Int64.to_int len })
+              | _ -> Error "nop: invalid format")
+          | _ -> Error (Printf.sprintf "unknown compact opcode: %d" opcode))
+      | J.Int opcode_i :: args -> (
+          let opcode = Int64.to_int opcode_i in
+          match opcode with
+          | 0 -> (
               match args with
               | [] -> Ok (Op.Op_new_con { con_value = Value.Undefined })
               | [ value_json ] ->
···
           | 5 -> Ok Op.Op_new_bin
           | 6 -> Ok Op.Op_new_arr
           | 9 -> (
-              (* ins_val *)
               match args with
               | [ obj_json; value_json ] -> (
                   match
···
                   | _ -> Error "ins_val: invalid timestamp")
               | _ -> Error "ins_val: expected obj, value")
           | 10 -> (
-              (* ins_obj *)
               match args with
-              | [ obj_json; Jsont.Array (entries, _) ] -> (
+              | [ obj_json; J.Array entries ] -> (
                   match decode_ts ~patch_sid obj_json with
                   | Some obj ->
                       let decode_entry json =
                         match json with
-                        | Jsont.Array ([ Jsont.String (key, _); ts_json ], _)
-                          -> (
+                        | J.Array [ J.String key; ts_json ] -> (
                             match decode_ts ~patch_sid ts_json with
                             | Some ts -> Some (key, ts)
                             | None -> None)
···
                   | None -> Error "ins_obj: invalid obj timestamp")
               | _ -> Error "ins_obj: expected obj, entries")
           | 11 -> (
-              (* ins_vec *)
               match args with
-              | [ obj_json; Jsont.Number (idx_f, _); value_json ] -> (
+              | [ obj_json; J.Float idx_f; value_json ] -> (
                   match
                     ( decode_ts ~patch_sid obj_json,
                       decode_ts ~patch_sid value_json )
···
                            {
                              ins_vec_obj = obj;
                              ins_vec_idx = Float.to_int idx_f;
+                             ins_vec_value = value;
+                           })
+                  | _ -> Error "ins_vec: invalid timestamp")
+              | [ obj_json; J.Int idx_i; value_json ] -> (
+                  match
+                    ( decode_ts ~patch_sid obj_json,
+                      decode_ts ~patch_sid value_json )
+                  with
+                  | Some obj, Some value ->
+                      Ok
+                        (Op.Op_ins_vec
+                           {
+                             ins_vec_obj = obj;
+                             ins_vec_idx = Int64.to_int idx_i;
                              ins_vec_value = value;
                            })
                   | _ -> Error "ins_vec: invalid timestamp")
               | _ -> Error "ins_vec: expected obj, idx, value")
           | 12 -> (
-              (* ins_str *)
               match args with
-              | [ obj_json; after_json; Jsont.String (value, _) ] -> (
+              | [ obj_json; after_json; J.String value ] -> (
                   match
                     ( decode_ts ~patch_sid obj_json,
                       decode_ts ~patch_sid after_json )
···
                   | _ -> Error "ins_str: invalid timestamp")
               | _ -> Error "ins_str: expected obj, after, value")
           | 13 -> (
-              (* ins_bin *)
               match args with
-              | [ obj_json; after_json; Jsont.String (b64_value, _) ] -> (
+              | [ obj_json; after_json; J.String b64_value ] -> (
                   match
                     ( decode_ts ~patch_sid obj_json,
                       decode_ts ~patch_sid after_json )
···
                   | _ -> Error "ins_bin: invalid timestamp")
               | _ -> Error "ins_bin: expected obj, after, value")
           | 14 -> (
-              (* ins_arr - value is an array of timestamps, we take the first one *)
               match args with
-              | [ obj_json; after_json; Jsont.Array (values_json, _) ] -> (
+              | [ obj_json; after_json; J.Array values_json ] -> (
                   match
                     ( decode_ts ~patch_sid obj_json,
                       decode_ts ~patch_sid after_json )
                   with
                   | Some obj, Some after -> (
-                      (* Decode array of value timestamps *)
                       match values_json with
                       | [ first_value ] -> (
                           match decode_ts ~patch_sid first_value with
···
                                    })
                           | None -> Error "ins_arr: invalid value timestamp")
                       | _ -> (
-                          (* Multiple values - for now just take first if available *)
                           let decoded_values =
                             List.filter_map (decode_ts ~patch_sid) values_json
                           in
···
                           | [] -> Error "ins_arr: no valid value timestamps"))
                   | _ -> Error "ins_arr: invalid obj/after timestamp")
               | [ obj_json; after_json; value_json ] -> (
-                  (* Fallback: value might be a single timestamp *)
                   match
                     ( decode_ts ~patch_sid obj_json,
                       decode_ts ~patch_sid after_json,
···
                   | _ -> Error "ins_arr: invalid timestamp")
               | _ -> Error "ins_arr: expected obj, after, value")
           | 15 -> (
-              (* upd_arr *)
               match args with
               | [ obj_json; pos_json; value_json ] -> (
                   match
···
                   | _ -> Error "upd_arr: invalid timestamp")
               | _ -> Error "upd_arr: expected obj, pos, value")
           | 16 -> (
-              (* del *)
               match args with
-              | [ obj_json; Jsont.Array (spans_json, _) ] -> (
+              | [ obj_json; J.Array spans_json ] -> (
                   match decode_ts ~patch_sid obj_json with
                   | Some obj ->
                       let decoded =
···
                   | None -> Error "del: invalid obj timestamp")
               | _ -> Error "del: expected obj, spans")
           | 17 -> (
-              (* nop *)
               match args with
               | [] -> Ok (Op.Op_nop { nop_len = 1 })
-              | [ Jsont.Number (len, _) ] ->
-                  Ok (Op.Op_nop { nop_len = Float.to_int len })
+              | [ J.Float len ] -> Ok (Op.Op_nop { nop_len = Float.to_int len })
+              | [ J.Int len ] -> Ok (Op.Op_nop { nop_len = Int64.to_int len })
               | _ -> Error "nop: invalid format")
           | _ -> Error (Printf.sprintf "unknown compact opcode: %d" opcode))
       | _ -> Error "operation must start with opcode number")
   | _ -> Error "operation must be an array"
 
-(** {1 Patch Decoding} *)
-
-(** Decode a patch from compact JSON *)
-let decode_patch_json (json : Jsont.json) : (Patch.t, string) result =
+let decode_patch_json (json : J.t) : (Patch.t, string) result =
   match json with
-  | Jsont.Array (elems, _) -> (
+  | J.Array elems -> (
       match elems with
       | [] -> Error "empty patch array"
       | id_json :: ops_json -> (
-          (* Decode ID: [[sid, time]] *)
           match id_json with
-          | Jsont.Array
-              ( [
-                  Jsont.Array
-                    ([ Jsont.Number (sid, _); Jsont.Number (time, _) ], _);
-                ],
-                _ ) -> (
+          | J.Array [ J.Array [ J.Float sid; J.Float time ] ] -> (
               let id : Clock.timestamp =
                 { sid = Float.to_int sid; time = Float.to_int time }
               in
               let patch_sid = id.sid in
-              (* Decode operations *)
+              let rec decode_ops acc = function
+                | [] -> Ok (List.rev acc)
+                | op_json :: rest -> (
+                    match decode_op ~patch_sid op_json with
+                    | Ok op -> decode_ops (op :: acc) rest
+                    | Error e -> Error e)
+              in
+              match decode_ops [] ops_json with
+              | Ok ops -> Ok (Patch.create ~id ~ops)
+              | Error e -> Error e)
+          | J.Array [ J.Array [ J.Int sid; J.Int time ] ] -> (
+              let id : Clock.timestamp =
+                { sid = Int64.to_int sid; time = Int64.to_int time }
+              in
+              let patch_sid = id.sid in
               let rec decode_ops acc = function
                 | [] -> Ok (List.rev acc)
                 | op_json :: rest -> (
···
           | _ -> Error "invalid patch ID format"))
   | _ -> Error "patch must be an array"
 
-(** Decode a patch from a compact JSON string *)
 let decode (s : string) : (Patch.t, string) result =
-  match Jsont_bytesrw.decode_string Jsont.json s with
+  match Simdjsont.Decode.decode_string Simdjsont.Decode.value s with
   | Ok json -> decode_patch_json json
   | Error e -> Error (Printf.sprintf "JSON parse error: %s" e)
 
-(** {1 Batch Encoding/Decoding} *)
+let encode_batch_json (batch : Patch.batch) : J.t =
+  J.Array (List.map encode_patch_json batch)
 
-(** Encode a batch of patches to compact JSON *)
-let encode_batch_json (batch : Patch.batch) : Jsont.json =
-  Jsont.Array (List.map encode_patch_json batch, meta)
-
-(** Encode a batch to a compact JSON string *)
 let encode_batch (batch : Patch.batch) : string =
   let json = encode_batch_json batch in
-  Format.asprintf "%a" Jsont.pp_json json
+  J.to_string json
 
-(** Decode a batch from compact JSON *)
-let decode_batch_json (json : Jsont.json) : (Patch.batch, string) result =
+let decode_batch_json (json : J.t) : (Patch.batch, string) result =
   match json with
-  | Jsont.Array (patches_json, _) ->
+  | J.Array patches_json ->
       let rec decode_patches acc = function
         | [] -> Ok (List.rev acc)
         | patch_json :: rest -> (
···
       decode_patches [] patches_json
   | _ -> Error "expected array of patches"
 
-(** Decode a batch from a compact JSON string *)
 let decode_batch (s : string) : (Patch.batch, string) result =
-  match Jsont_bytesrw.decode_string Jsont.json s with
+  match Simdjsont.Decode.decode_string Simdjsont.Decode.value s with
   | Ok json -> decode_batch_json json
   | Error e -> Error (Printf.sprintf "JSON parse error: %s" e)

lib/value_codec.ml

···
-(** JSON codec for Value.t using jsont.
+module J = Json_compat
 
-    This module provides encode/decode functions for Value.t to/from JSON using
-    the jsont library. *)
+type json = J.json
 
-(** Convert a Value.t to Jsont.json (generic JSON AST) *)
-let rec to_json (v : Value.t) : Jsont.json =
-  let meta = Jsont.Meta.none in
+let rec to_json (v : Value.t) : json =
   match v with
-  | Value.Null -> Jsont.Null ((), meta)
-  | Value.Undefined -> Jsont.Null ((), meta) (* Lossy: undefined -> null *)
-  | Value.Bool b -> Jsont.Bool (b, meta)
-  | Value.Int i -> Jsont.Number (Float.of_int i, meta)
-  | Value.Float f ->
-      if not (Float.is_finite f) then Jsont.Null ((), meta)
-        (* Non-finite floats become null *)
-      else Jsont.Number (f, meta)
-  | Value.String s -> Jsont.String (s, meta)
+  | Value.Null -> J.null
+  | Value.Undefined -> J.null
+  | Value.Bool b -> J.bool b
+  | Value.Int i ->
+      if i >= -9007199254740991 && i <= 9007199254740991 then
+        J.number (Float.of_int i)
+      else Simdjsont.Json.Int (Int64.of_int i)
+  | Value.Float f -> if Float.is_finite f then J.number f else J.null
+  | Value.String s -> J.string s
   | Value.Bytes b ->
-      (* Encode bytes as hex string for now (base64 needs extra dep) *)
       let hex =
         let buf = Buffer.create (Bytes.length b * 2) in
         Bytes.iter
···
           b;
         Buffer.contents buf
       in
-      Jsont.String (hex, meta)
-  | Value.Array items -> Jsont.Array (List.map to_json items, meta)
+      J.string hex
+  | Value.Array items -> J.array (List.map to_json items)
   | Value.Object pairs ->
-      let mems = List.map (fun (k, v) -> ((k, meta), to_json v)) pairs in
-      Jsont.Object (mems, meta)
+      J.object_ (List.map (fun (k, v) -> (k, to_json v)) pairs)
   | Value.Timestamp_ref (sid, time) ->
-      (* Encode as [sid, time] array per json-joy spec *)
-      Jsont.Array
-        ( [
-            Jsont.Number (Float.of_int sid, meta);
-            Jsont.Number (Float.of_int time, meta);
-          ],
-          meta )
+      J.array [ J.number (Float.of_int sid); J.number (Float.of_int time) ]
 
-(** Convert Jsont.json to Value.t *)
-let rec of_json (j : Jsont.json) : Value.t =
+let rec of_json (j : json) : Value.t =
   match j with
-  | Jsont.Null _ -> Value.Null
-  | Jsont.Bool (b, _) -> Value.Bool b
-  | Jsont.Number (f, _) ->
-      (* Check if it's an integer *)
-      if
-        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
-  | Jsont.String (s, _) -> Value.String s
-  | Jsont.Array (items, _) -> Value.Array (List.map of_json items)
-  | Jsont.Object (mems, _) ->
-      Value.Object (List.map (fun ((k, _), v) -> (k, of_json v)) mems)
-
-(** Encode a Value.t to a JSON string (minified) *)
-let encode (v : Value.t) : string =
-  let json = to_json v in
-  Format.asprintf "%a" Jsont.pp_json json
+  | Simdjsont.Json.Null -> Value.Null
+  | Simdjsont.Json.Bool b -> Value.Bool b
+  | Simdjsont.Json.Float f -> (
+      match J.float_to_int_opt f with
+      | Some i -> Value.Int i
+      | None -> Value.Float f)
+  | 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.String s -> Value.String s
+  | Simdjsont.Json.Array items -> Value.Array (List.map of_json items)
+  | Simdjsont.Json.Object mems ->
+      Value.Object (List.map (fun (k, v) -> (k, of_json v)) mems)
 
-(** Encode a Value.t to a JSON string (pretty-printed) *)
-let encode_pretty (v : Value.t) : string =
-  let json = to_json v in
-  Format.asprintf "%a" (Jsont.pp_json' ()) json
+let encode (v : Value.t) : string = J.to_string (to_json v)
+let encode_pretty (v : Value.t) : string = J.to_string (to_json v)
 
-(** Decode a JSON string to a Value.t *)
 let decode (s : string) : (Value.t, string) result =
-  match Jsont_bytesrw.decode_string Jsont.json s with
+  match J.decode_string s with
   | Ok json -> Ok (of_json json)
   | Error e -> Error e

test/test_crdt.ml

···
 (** CRDT Library Tests *)
 
 open Crdt
+module J = Simdjsont.Json
 
 (* Find the project root by looking for dune-project file *)
 let find_project_root () =
···
 
 let test_codec_array () =
   let arr = Value.array [ Value.int 1; Value.int 2; Value.int 3 ] in
-  Alcotest.(check string) "encode array" "[1, 2, 3]" (Value_codec.encode arr);
+  Alcotest.(check string) "encode array" "[1,2,3]" (Value_codec.encode arr);
   match Value_codec.decode "[1,2,3]" with
   | Ok v -> Alcotest.(check value_testable) "decode array" arr v
   | Error e -> Alcotest.fail e
···
   let json = Model_codec.Verbose.encode model in
   (* Verify structure *)
   match json with
-  | Jsont.Object (fields, _) ->
-      let has_time = List.exists (fun ((k, _), _) -> k = "time") fields in
-      let has_root = List.exists (fun ((k, _), _) -> k = "root") fields in
+  | J.Object fields ->
+      let has_time = List.exists (fun (k, _) -> k = "time") fields in
+      let has_root = List.exists (fun (k, _) -> k = "root") fields in
       Alcotest.(check bool) "has time" true has_time;
       Alcotest.(check bool) "has root" true has_root
   | _ -> Alcotest.fail "expected object"
···
   let json = Model_codec_sidecar.to_json sidecar in
   (* Should have view and meta fields *)
   match json with
-  | Jsont.Object (fields, _) ->
-      let has_view = List.exists (fun ((k, _), _) -> k = "view") fields in
-      let has_meta = List.exists (fun ((k, _), _) -> k = "meta") fields in
+  | J.Object fields ->
+      let has_view = List.exists (fun (k, _) -> k = "view") fields in
+      let has_meta = List.exists (fun (k, _) -> k = "meta") fields in
       Alcotest.(check bool) "has view" true has_view;
       Alcotest.(check bool) "has meta" true has_meta
   | _ -> Alcotest.fail "expected object"
···
   let json = Model_codec_indexed.encode model in
   (* Should have clock, root, and nodes fields *)
   match json with
-  | Jsont.Object (fields, _) ->
-      let has_clock = List.exists (fun ((k, _), _) -> k = "clock") fields in
-      let has_root = List.exists (fun ((k, _), _) -> k = "root") fields in
-      let has_nodes = List.exists (fun ((k, _), _) -> k = "nodes") fields in
+  | J.Object fields ->
+      let has_clock = List.exists (fun (k, _) -> k = "clock") fields in
+      let has_root = List.exists (fun (k, _) -> k = "root") fields in
+      let has_nodes = List.exists (fun (k, _) -> k = "nodes") fields in
       Alcotest.(check bool) "has clock" true has_clock;
       Alcotest.(check bool) "has root" true has_root;
       Alcotest.(check bool) "has nodes" true has_nodes