Migrate test fixture loading from Yojson to Atproto_json

- Replace Yojson with Atproto_json (simdjson-backed) in all test files:
- test/mst/test_mst.ml
- test/crypto/test_crypto.ml
- test/sync/test_sync.ml
- test/ipld/test_ipld.ml
- test/compliance/compliance_report.ml
- test/compliance/run_compliance.ml
- Remove yojson dependency from all test dune files
- Add encode_pretty function to lib/json/atproto_json.ml for formatted JSON output
- Update test/lexicon/dune to remove stale yojson dependency

All tests pass except pre-existing crypto signature verification failures.

.beads/issues.jsonl

···
 {"id":"atproto-q0h","title":"Add firehose commit-proof-fixtures.json tests","description":"Add tests for the commit-proof-fixtures.json file which contains 6 test cases for MST proof verification:\n\n1. two deep split\n2. two deep leafless split\n3. add on edge with neighbor two layers down\n4. merge and split in multi-op commit\n5. complex multi-op commit\n6. split with earlier leaves on same layer\n\nEach fixture includes:\n- keys (existing keys in MST)\n- adds (keys to add)\n- dels (keys to delete)\n- rootBeforeCommit / rootAfterCommit (expected CIDs)\n- blocksInProof (CIDs of blocks needed for proof)\n\nThis tests the commit proof verification needed for firehose sync.","acceptance_criteria":"- All 6 commit-proof fixtures are tested\n- MST operations (add/delete) produce correct root CIDs\n- Proof blocks are correctly identified\n- Tests verify rootBeforeCommit and rootAfterCommit match","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-28T12:12:34.999268893+01:00","updated_at":"2025-12-28T12:58:39.408679225+01:00","closed_at":"2025-12-28T12:58:39.408679225+01:00","labels":["conformance","firehose","testing"]}
 {"id":"atproto-s19","title":"Add CIDv0 parsing support","description":"Detect base58btc strings starting with \"Qm\", decode as multihash (sha2-256), implicit dag-pb codec","status":"closed","priority":2,"issue_type":"feature","created_at":"2025-12-28T15:47:26.962896421+01:00","updated_at":"2025-12-28T15:58:38.151319563+01:00","closed_at":"2025-12-28T15:58:38.151319563+01:00","labels":["compliance","ipld"]}
 {"id":"atproto-udz","title":"Add missing data-model conformance tests","description":"Add tests for data-model fixtures that are not currently covered:\n\n1. **data-model-valid.json** (5 entries) - Valid AT Protocol data model examples:\n   - trivial record\n   - float but integer-like (123.0)\n   - empty list and object\n   - list of nullable\n   - list of lists\n\n2. **data-model-invalid.json** (12 entries) - Invalid examples that must be rejected:\n   - top-level not an object\n   - non-integer float\n   - record with $type null/wrong type/empty\n   - blob with string size/missing key\n   - bytes with wrong field type/extra fields\n   - link with wrong field type/bogus CID/extra fields","acceptance_criteria":"- test_data_model_valid() tests all 5 valid entries\n- test_data_model_invalid() tests all 12 invalid entries\n- Valid entries encode/decode correctly\n- Invalid entries are rejected with appropriate errors","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-28T12:12:14.579573063+01:00","updated_at":"2025-12-28T12:42:16.291981859+01:00","closed_at":"2025-12-28T12:42:16.291981859+01:00","labels":["conformance","ipld","testing"]}
+{"id":"atproto-w30","title":"Migrate test fixture loading from Yojson to Atproto_json","description":"","status":"closed","priority":1,"issue_type":"task","created_at":"2026-01-01T22:43:58.821369697+01:00","updated_at":"2026-01-01T22:53:56.562250588+01:00","closed_at":"2026-01-01T22:53:56.562250588+01:00"}
 {"id":"atproto-w5i","title":"Create example applications","description":"Create example applications demonstrating the AT Protocol libraries:\n1. Simple client - authenticate and make posts\n2. Firehose consumer - subscribe to real-time events\n3. Bot example - automated posting/interactions","notes":"Added firehose_demo example showing how to use the firehose module with OCaml 5 effects. Additional examples (client, bot) can be added in future iterations.","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-28T13:34:11.928213055+01:00","updated_at":"2025-12-28T13:36:39.963890666+01:00","closed_at":"2025-12-28T13:36:39.963890666+01:00","labels":["documentation","examples"],"dependencies":[{"issue_id":"atproto-w5i","depends_on_id":"atproto-1","type":"parent-child","created_at":"2025-12-28T13:34:17.10878+01:00","created_by":"daemon"}]}
 {"id":"atproto-xfg","title":"Add Float support to DAG-CBOR","description":"Add Float of float variant to value type, encode as 64-bit double (CBOR major type 7, additional info 27), reject NaN and Infinity values, keep AT Protocol mode that rejects all floats","status":"closed","priority":1,"issue_type":"feature","created_at":"2025-12-28T15:47:24.836568239+01:00","updated_at":"2025-12-28T15:53:03.229484165+01:00","closed_at":"2025-12-28T15:53:03.229484165+01:00","labels":["compliance","ipld"]}
 {"id":"atproto-y4h","title":"Add JSON output mode to firehose demo","description":"Add --json flag to output events as JSON lines (JSONL format) instead of human-readable format. This enables piping to jq or other tools for further processing.","status":"closed","priority":3,"issue_type":"feature","created_at":"2025-12-28T21:08:22.085375231+01:00","updated_at":"2025-12-28T21:13:33.122865944+01:00","closed_at":"2025-12-28T21:13:33.122865944+01:00","labels":["demo","enhancement","firehose"]}

lib/json/atproto_json.ml

···
 let to_object_opt : t -> (string * t) list option = function
   | Simdjsont.Json.Object pairs -> Some pairs
   | _ -> None
+
+let escape_string s =
+  let buf = Buffer.create (String.length s * 2) in
+  String.iter
+    (fun c ->
+      match c with
+      | '"' -> Buffer.add_string buf "\\\""
+      | '\\' -> Buffer.add_string buf "\\\\"
+      | '\n' -> Buffer.add_string buf "\\n"
+      | '\r' -> Buffer.add_string buf "\\r"
+      | '\t' -> Buffer.add_string buf "\\t"
+      | c when Char.code c < 32 ->
+          Buffer.add_string buf (Printf.sprintf "\\u%04x" (Char.code c))
+      | c -> Buffer.add_char buf c)
+    s;
+  Buffer.contents buf
+
+let rec encode_pretty_aux buf indent t =
+  let indent_str = String.make (indent * 2) ' ' in
+  let next_indent = indent + 1 in
+  match t with
+  | Simdjsont.Json.Null -> Buffer.add_string buf "null"
+  | Simdjsont.Json.Bool b ->
+      Buffer.add_string buf (if b then "true" else "false")
+  | Simdjsont.Json.Int i -> Buffer.add_string buf (Int64.to_string i)
+  | Simdjsont.Json.Float f -> Buffer.add_string buf (Printf.sprintf "%g" f)
+  | Simdjsont.Json.String s ->
+      Buffer.add_char buf '"';
+      Buffer.add_string buf (escape_string s);
+      Buffer.add_char buf '"'
+  | Simdjsont.Json.Array [] -> Buffer.add_string buf "[]"
+  | Simdjsont.Json.Array items ->
+      Buffer.add_string buf "[\n";
+      List.iteri
+        (fun i item ->
+          Buffer.add_string buf (String.make (next_indent * 2) ' ');
+          encode_pretty_aux buf next_indent item;
+          if i < List.length items - 1 then Buffer.add_char buf ',';
+          Buffer.add_char buf '\n')
+        items;
+      Buffer.add_string buf indent_str;
+      Buffer.add_char buf ']'
+  | Simdjsont.Json.Object [] -> Buffer.add_string buf "{}"
+  | Simdjsont.Json.Object pairs ->
+      Buffer.add_string buf "{\n";
+      List.iteri
+        (fun i (k, v) ->
+          Buffer.add_string buf (String.make (next_indent * 2) ' ');
+          Buffer.add_char buf '"';
+          Buffer.add_string buf (escape_string k);
+          Buffer.add_string buf "\": ";
+          encode_pretty_aux buf next_indent v;
+          if i < List.length pairs - 1 then Buffer.add_char buf ',';
+          Buffer.add_char buf '\n')
+        pairs;
+      Buffer.add_string buf indent_str;
+      Buffer.add_char buf '}'
+
+let encode_pretty (t : t) : string =
+  let buf = Buffer.create 1024 in
+  encode_pretty_aux buf 0 t;
+  Buffer.contents buf

test/compliance/compliance_report.ml

···
     report_pass_rate = pass_rate;
   }
 
-(** Convert report to JSON *)
 let result_to_json (r : test_result) =
-  `Assoc
+  Atproto_json.object_
     [
-      ("input", `String r.input);
+      ("input", Atproto_json.string r.input);
       ( "expected",
-        `String
+        Atproto_json.string
           (match r.expected with `Valid -> "valid" | `Invalid -> "invalid") );
       ( "actual",
-        `String
+        Atproto_json.string
           (match r.actual with `Valid -> "valid" | `Invalid -> "invalid") );
-      ("passed", `Bool r.passed);
-      ("error", match r.error_msg with Some s -> `String s | None -> `Null);
+      ("passed", Atproto_json.bool r.passed);
+      ( "error",
+        match r.error_msg with
+        | Some s -> Atproto_json.string s
+        | None -> Atproto_json.null );
     ]
 
 let category_to_json (c : category_result) =
-  `Assoc
+  Atproto_json.object_
     [
-      ("name", `String c.cat_name);
-      ("description", `String c.cat_description);
-      ("fixture_file", `String c.cat_fixture_file);
-      ("total", `Int c.cat_total);
-      ("passed", `Int c.cat_passed);
-      ("failed", `Int c.cat_failed);
+      ("name", Atproto_json.string c.cat_name);
+      ("description", Atproto_json.string c.cat_description);
+      ("fixture_file", Atproto_json.string c.cat_fixture_file);
+      ("total", Atproto_json.int c.cat_total);
+      ("passed", Atproto_json.int c.cat_passed);
+      ("failed", Atproto_json.int c.cat_failed);
       ( "pass_rate",
-        `Float
+        Atproto_json.float
           (if c.cat_total > 0 then
              float_of_int c.cat_passed /. float_of_int c.cat_total *. 100.0
            else 0.0) );
-      ("results", `List (List.map result_to_json c.cat_results));
+      ("results", Atproto_json.array (List.map result_to_json c.cat_results));
     ]
 
 let suite_to_json (s : suite_result) =
-  `Assoc
+  Atproto_json.object_
     [
-      ("name", `String s.suite_name);
+      ("name", Atproto_json.string s.suite_name);
       ( "spec_url",
-        match s.suite_spec_url with Some u -> `String u | None -> `Null );
-      ("total", `Int s.suite_total);
-      ("passed", `Int s.suite_passed);
-      ("failed", `Int s.suite_failed);
+        match s.suite_spec_url with
+        | Some u -> Atproto_json.string u
+        | None -> Atproto_json.null );
+      ("total", Atproto_json.int s.suite_total);
+      ("passed", Atproto_json.int s.suite_passed);
+      ("failed", Atproto_json.int s.suite_failed);
       ( "pass_rate",
-        `Float
+        Atproto_json.float
           (if s.suite_total > 0 then
              float_of_int s.suite_passed /. float_of_int s.suite_total *. 100.0
            else 0.0) );
-      ("categories", `List (List.map category_to_json s.suite_categories));
+      ( "categories",
+        Atproto_json.array (List.map category_to_json s.suite_categories) );
     ]
 
 let report_to_json (r : report) =
-  `Assoc
+  Atproto_json.object_
     [
-      ("title", `String r.report_title);
-      ("version", `String r.report_version);
-      ("generated_at", `String r.report_generated_at);
-      ("repository", `String r.report_repository);
-      ("total_tests", `Int r.report_total_tests);
-      ("total_passed", `Int r.report_total_passed);
-      ("total_failed", `Int r.report_total_failed);
-      ("pass_rate", `Float r.report_pass_rate);
-      ("suites", `List (List.map suite_to_json r.report_suites));
+      ("title", Atproto_json.string r.report_title);
+      ("version", Atproto_json.string r.report_version);
+      ("generated_at", Atproto_json.string r.report_generated_at);
+      ("repository", Atproto_json.string r.report_repository);
+      ("total_tests", Atproto_json.int r.report_total_tests);
+      ("total_passed", Atproto_json.int r.report_total_passed);
+      ("total_failed", Atproto_json.int r.report_total_failed);
+      ("pass_rate", Atproto_json.float r.report_pass_rate);
+      ("suites", Atproto_json.array (List.map suite_to_json r.report_suites));
     ]
 
-(** Write report to JSON file *)
 let write_json_report filename (report : report) =
   let json = report_to_json report in
   let oc = open_out filename in
-  output_string oc (Yojson.Safe.pretty_to_string json);
+  output_string oc (Atproto_json.encode_pretty json);
   output_char oc '\n';
   close_out oc
 

test/compliance/dune

···
 (library
  (name compliance_report)
  (modules compliance_report)
- (libraries yojson unix))
+ (libraries atproto_json unix))
 
 (executable
  (name run_compliance)
···
   atproto-ipld
   atproto-mst
   mirage-crypto-rng.unix
-  yojson
+  atproto_json
   unix))

test/compliance/run_compliance.ml

···
   let ic = open_in filename in
   let content = In_channel.input_all ic in
   close_in ic;
-  Yojson.Safe.from_string content
+  match Atproto_json.decode content with
+  | Ok json -> json
+  | Error e -> failwith ("JSON parse error: " ^ e)
 
 (** Base64 decode *)
 let base64_decode s =
···
 
 (* ==================== Crypto Tests ==================== *)
 
+let get_string_field key pairs =
+  match Atproto_json.get_string_opt key pairs with
+  | Some s -> s
+  | None -> failwith ("missing " ^ key)
+
+let get_bool_field key pairs =
+  match Atproto_json.get key pairs with
+  | Some v -> (
+      match Atproto_json.to_bool_opt v with
+      | Some b -> b
+      | None -> failwith ("invalid bool: " ^ key))
+  | None -> failwith ("missing " ^ key)
+
+let get_int_field key pairs =
+  match Atproto_json.get_int_opt key pairs with
+  | Some i -> i
+  | None -> failwith ("missing or invalid int: " ^ key)
+
 let run_crypto_tests () =
-  (* Signature verification tests *)
   let sig_fixtures =
     load_json_fixture (fixture_dir ^ "/crypto/signature-fixtures.json")
   in
   let sig_results =
-    match sig_fixtures with
-    | `List items ->
+    match Atproto_json.to_array_opt sig_fixtures with
+    | Some items ->
         List.map
           (fun item ->
-            match item with
-            | `Assoc fields ->
+            match Atproto_json.to_object_opt item with
+            | Some fields ->
                 let comment =
-                  match List.assoc_opt "comment" fields with
-                  | Some (`String s) -> s
-                  | _ -> "unknown"
+                  match Atproto_json.get_string_opt "comment" fields with
+                  | Some s -> s
+                  | None -> "unknown"
                 in
-                let message_b64 =
-                  match List.assoc_opt "messageBase64" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing messageBase64"
-                in
-                let algorithm =
-                  match List.assoc_opt "algorithm" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing algorithm"
-                in
-                let public_key_did =
-                  match List.assoc_opt "publicKeyDid" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing publicKeyDid"
-                in
-                let signature_b64 =
-                  match List.assoc_opt "signatureBase64" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing signatureBase64"
-                in
-                let valid_signature =
-                  match List.assoc_opt "validSignature" fields with
-                  | Some (`Bool b) -> b
-                  | _ -> failwith "missing validSignature"
-                in
+                let message_b64 = get_string_field "messageBase64" fields in
+                let algorithm = get_string_field "algorithm" fields in
+                let public_key_did = get_string_field "publicKeyDid" fields in
+                let signature_b64 = get_string_field "signatureBase64" fields in
+                let valid_signature = get_bool_field "validSignature" fields in
 
                 let message = base64_decode message_b64 in
                 let signature = base64_decode signature_b64 in
···
                   with _ -> `Invalid
                 in
                 make_result ~input:comment ~expected ~actual ()
-            | _ -> failwith "invalid fixture format")
+            | None -> failwith "invalid fixture format")
           items
-    | _ -> failwith "invalid fixtures format"
+    | None -> failwith "invalid fixtures format"
   in
 
   let sig_category =
···
       ~fixture_file:"signature-fixtures.json" sig_results
   in
 
-  (* did:key encoding tests for P-256 *)
   let p256_fixtures =
     load_json_fixture (fixture_dir ^ "/crypto/w3c_didkey_P256.json")
   in
   let p256_results =
-    match p256_fixtures with
-    | `List items ->
+    match Atproto_json.to_array_opt p256_fixtures with
+    | Some items ->
         List.map
           (fun item ->
-            match item with
-            | `Assoc fields ->
-                let did =
-                  match List.assoc_opt "publicDidKey" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing publicDidKey"
-                in
+            match Atproto_json.to_object_opt item with
+            | Some fields ->
+                let did = get_string_field "publicDidKey" fields in
                 let actual =
                   try
                     match Atproto_crypto.Did_key.decode did with
···
                   with _ -> `Invalid
                 in
                 make_result ~input:did ~expected:`Valid ~actual ()
-            | _ -> failwith "invalid fixture format")
+            | None -> failwith "invalid fixture format")
           items
-    | _ -> []
+    | None -> []
   in
 
   let p256_category =
···
       ~fixture_file:"w3c_didkey_P256.json" p256_results
   in
 
-  (* did:key encoding tests for K-256 *)
   let k256_fixtures =
     load_json_fixture (fixture_dir ^ "/crypto/w3c_didkey_K256.json")
   in
   let k256_results =
-    match k256_fixtures with
-    | `List items ->
+    match Atproto_json.to_array_opt k256_fixtures with
+    | Some items ->
         List.map
           (fun item ->
-            match item with
-            | `Assoc fields ->
-                let did =
-                  match List.assoc_opt "publicDidKey" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing publicDidKey"
-                in
+            match Atproto_json.to_object_opt item with
+            | Some fields ->
+                let did = get_string_field "publicDidKey" fields in
                 let actual =
                   try
                     match Atproto_crypto.Did_key.decode did with
···
                   with _ -> `Invalid
                 in
                 make_result ~input:did ~expected:`Valid ~actual ()
-            | _ -> failwith "invalid fixture format")
+            | None -> failwith "invalid fixture format")
           items
-    | _ -> []
+    | None -> []
   in
 
   let k256_category =
···
 (* ==================== Data Model Tests ==================== *)
 
 let run_data_model_tests () =
-  (* DAG-CBOR encoding and CID computation *)
   let fixtures =
     load_json_fixture (fixture_dir ^ "/data-model/data-model-fixtures.json")
   in
   let results =
-    match fixtures with
-    | `List items ->
+    match Atproto_json.to_array_opt fixtures with
+    | Some items ->
         List.mapi
           (fun i item ->
-            match item with
-            | `Assoc fields ->
-                let expected_cid =
-                  match List.assoc_opt "cid" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing cid"
-                in
-                let cbor_b64 =
-                  match List.assoc_opt "cbor_base64" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing cbor_base64"
-                in
-                let json_value =
-                  match List.assoc_opt "json" fields with
-                  | Some j -> j
-                  | _ -> failwith "missing json"
-                in
-
-                let _ = json_value in
-                (* We'll use cbor_base64 directly *)
+            match Atproto_json.to_object_opt item with
+            | Some fields ->
+                let expected_cid = get_string_field "cid" fields in
+                let cbor_b64 = get_string_field "cbor_base64" fields in
                 let cbor_str = base64_decode cbor_b64 in
 
                 let actual =
···
                 make_result
                   ~input:(Printf.sprintf "fixture[%d]" i)
                   ~expected:`Valid ~actual ()
-            | _ -> failwith "invalid fixture format")
+            | None -> failwith "invalid fixture format")
           items
-    | _ -> []
+    | None -> []
   in
 
   let cbor_category =
···
       ~fixture_file:"data-model-fixtures.json" results
   in
 
-  (* CID syntax validation - preserve whitespace to test whitespace handling *)
   let cid_valid =
     load_test_vectors (fixture_dir ^ "/syntax/cid_syntax_valid.txt")
   in
···
     List.map
       (fun input ->
         let actual =
-          (* Use syntax validation for CID syntax tests - this matches the Go
-             implementation which does lenient validation without fully decoding *)
           if Atproto_ipld.Cid.is_valid_syntax input then `Valid else `Invalid
         in
         make_result ~input ~expected:`Valid ~actual ())
···
 (* ==================== MST Tests ==================== *)
 
 let run_mst_tests () =
-  (* Key height tests *)
   let height_fixtures =
     load_json_fixture (fixture_dir ^ "/mst/key_heights.json")
   in
   let height_results =
-    match height_fixtures with
-    | `Assoc items ->
+    match Atproto_json.to_object_opt height_fixtures with
+    | Some items ->
         List.map
           (fun (key, expected_height) ->
             let expected_h =
-              match expected_height with
-              | `Int h -> h
-              | _ -> failwith "invalid height"
+              match Atproto_json.to_int_opt expected_height with
+              | Some h -> h
+              | None -> failwith "invalid height"
             in
             let actual =
               try
···
             in
             make_result ~input:key ~expected:`Valid ~actual ())
           items
-    | _ -> []
+    | None -> []
   in
 
   let height_category =
···
       ~fixture_file:"key_heights.json" height_results
   in
 
-  (* Common prefix tests *)
   let prefix_fixtures =
     load_json_fixture (fixture_dir ^ "/mst/common_prefix.json")
   in
   let prefix_results =
-    match prefix_fixtures with
-    | `List items ->
+    match Atproto_json.to_array_opt prefix_fixtures with
+    | Some items ->
         List.mapi
           (fun i item ->
-            match item with
-            | `Assoc fields ->
-                let left =
-                  match List.assoc_opt "left" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing left"
-                in
-                let right =
-                  match List.assoc_opt "right" fields with
-                  | Some (`String s) -> s
-                  | _ -> failwith "missing right"
-                in
-                let expected_len =
-                  match List.assoc_opt "len" fields with
-                  | Some (`Int n) -> n
-                  | _ -> failwith "missing len"
-                in
+            match Atproto_json.to_object_opt item with
+            | Some fields ->
+                let left = get_string_field "left" fields in
+                let right = get_string_field "right" fields in
+                let expected_len = get_int_field "len" fields in
                 let actual =
                   try
                     let len = Atproto_mst.common_prefix_len left right in
···
                 make_result
                   ~input:(Printf.sprintf "prefix[%d]: %s, %s" i left right)
                   ~expected:`Valid ~actual ()
-            | _ -> failwith "invalid fixture format")
+            | None -> failwith "invalid fixture format")
           items
-    | _ -> []
+    | None -> []
   in
 
   let prefix_category =

test/crypto/dune

···
 (test
  (name test_crypto)
  (package atproto-crypto)
- (libraries atproto_crypto alcotest yojson mirage-crypto-rng.unix)
+ (libraries atproto_crypto atproto_json alcotest mirage-crypto-rng.unix)
  (deps
   (source_tree ../fixtures/crypto))
  (preprocess no_preprocessing))

test/crypto/test_crypto.ml

···
   let ic = open_in path in
   let content = In_channel.input_all ic in
   close_in ic;
-  Yojson.Safe.from_string content
+  match Atproto_json.decode content with
+  | Ok json -> json
+  | Error e -> failwith ("JSON parse error: " ^ e)
 
 (** Base64 decode *)
 let base64_decode s =
···
 
 let test_signature_verification () =
   let fixtures = read_fixture "signature-fixtures.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc fields ->
+          match Atproto_json.to_object_opt item with
+          | Some fields ->
               let comment =
-                match List.assoc_opt "comment" fields with
-                | Some (`String s) -> s
-                | _ -> "unknown"
+                match Atproto_json.get_string_opt "comment" fields with
+                | Some s -> s
+                | None -> "unknown"
               in
               let message_b64 =
-                match List.assoc_opt "messageBase64" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing messageBase64"
+                match Atproto_json.get_string_opt "messageBase64" fields with
+                | Some s -> s
+                | None -> failwith "missing messageBase64"
               in
               let algorithm =
-                match List.assoc_opt "algorithm" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing algorithm"
+                match Atproto_json.get_string_opt "algorithm" fields with
+                | Some s -> s
+                | None -> failwith "missing algorithm"
               in
               let public_key_did =
-                match List.assoc_opt "publicKeyDid" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing publicKeyDid"
+                match Atproto_json.get_string_opt "publicKeyDid" fields with
+                | Some s -> s
+                | None -> failwith "missing publicKeyDid"
               in
               let signature_b64 =
-                match List.assoc_opt "signatureBase64" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing signatureBase64"
+                match Atproto_json.get_string_opt "signatureBase64" fields with
+                | Some s -> s
+                | None -> failwith "missing signatureBase64"
               in
               let valid_signature =
-                match List.assoc_opt "validSignature" fields with
-                | Some (`Bool b) -> b
-                | _ -> failwith "missing validSignature"
+                match Atproto_json.get "validSignature" fields with
+                | Some json -> (
+                    match Atproto_json.to_bool_opt json with
+                    | Some b -> b
+                    | None -> failwith "missing validSignature")
+                | None -> failwith "missing validSignature"
               in
               let tags =
-                match List.assoc_opt "tags" fields with
-                | Some (`List tags) ->
-                    List.filter_map
-                      (function `String s -> Some s | _ -> None)
-                      tags
-                | _ -> []
+                match Atproto_json.get_array_opt "tags" fields with
+                | Some tags -> List.filter_map Atproto_json.to_string_opt tags
+                | None -> []
               in
 
               (* Decode inputs *)
···
                       (Printf.sprintf "signature validity: %s" comment)
                       valid_signature is_valid
               end
-          | _ -> failwith "expected object in fixture array")
+          | None -> failwith "expected object in fixture array")
         items
-  | _ -> failwith "expected array in fixture file"
+  | None -> failwith "expected array in fixture file"
 
 (* === did:key encoding tests for K-256 === *)
 
 let test_didkey_k256 () =
   let fixtures = read_fixture "w3c_didkey_K256.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc fields -> (
+          match Atproto_json.to_object_opt item with
+          | Some fields -> (
               let private_key_hex =
-                match List.assoc_opt "privateKeyBytesHex" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing privateKeyBytesHex"
+                match
+                  Atproto_json.get_string_opt "privateKeyBytesHex" fields
+                with
+                | Some s -> s
+                | None -> failwith "missing privateKeyBytesHex"
               in
               let expected_did =
-                match List.assoc_opt "publicDidKey" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing publicDidKey"
+                match Atproto_json.get_string_opt "publicDidKey" fields with
+                | Some s -> s
+                | None -> failwith "missing publicDidKey"
               in
 
               (* Decode private key and derive public key *)
···
                   | Ok (K256 _pub') -> ()
                   | Ok (P256 _) ->
                       Alcotest.fail "decoded as P256 instead of K256"))
-          | _ -> failwith "expected object in fixture array")
+          | None -> failwith "expected object in fixture array")
         items
-  | _ -> failwith "expected array in fixture file"
+  | None -> failwith "expected array in fixture file"
 
 (* === did:key encoding tests for P-256 === *)
 
 let test_didkey_p256 () =
   let fixtures = read_fixture "w3c_didkey_P256.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc fields -> (
+          match Atproto_json.to_object_opt item with
+          | Some fields -> (
               let private_key_b58 =
-                match List.assoc_opt "privateKeyBytesBase58" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing privateKeyBytesBase58"
+                match
+                  Atproto_json.get_string_opt "privateKeyBytesBase58" fields
+                with
+                | Some s -> s
+                | None -> failwith "missing privateKeyBytesBase58"
               in
               let expected_did =
-                match List.assoc_opt "publicDidKey" fields with
-                | Some (`String s) -> s
-                | _ -> failwith "missing publicDidKey"
+                match Atproto_json.get_string_opt "publicDidKey" fields with
+                | Some s -> s
+                | None -> failwith "missing publicDidKey"
               in
 
               (* Decode private key and derive public key *)
···
                       | Ok (P256 _pub') -> ()
                       | Ok (K256 _) ->
                           Alcotest.fail "decoded as K256 instead of P256")))
-          | _ -> failwith "expected object in fixture array")
+          | None -> failwith "expected object in fixture array")
         items
-  | _ -> failwith "expected array in fixture file"
+  | None -> failwith "expected array in fixture file"
 
 (* === Basic P256 signing tests === *)
 

test/ipld/dune

···
  (deps
   (source_tree ../fixtures/syntax)
   (source_tree ../fixtures/data-model))
- (libraries atproto_ipld alcotest yojson base64))
+ (libraries atproto_ipld alcotest atproto_json base64))

test/ipld/test_ipld.ml

···
   let ic = open_in path in
   let content = really_input_string ic (in_channel_length ic) in
   close_in ic;
-  Yojson.Basic.from_string content
+  match Atproto_json.decode content with
+  | Ok json -> json
+  | Error e -> failwith ("JSON parse error: " ^ e)
 
 (** Base64 decode helper using the base64 library *)
 let base64_decode_test s =
···
   | Ok decoded -> decoded
   | Error _ -> failwith ("base64 decode failed: " ^ s)
 
-(** Convert Yojson.Basic.t to Dag_cbor.json *)
-let rec yojson_to_dag_cbor_json (j : Yojson.Basic.t) : Dag_cbor.json =
-  match j with
-  | `Null -> `Null
-  | `Bool b -> `Bool b
-  | `Int i -> `Int i
-  | `Float f -> `Float f
-  | `String s -> `String s
-  | `List l -> `List (List.map yojson_to_dag_cbor_json l)
-  | `Assoc pairs ->
-      `Assoc (List.map (fun (k, v) -> (k, yojson_to_dag_cbor_json v)) pairs)
+(** Convert Atproto_json.t to Dag_cbor.json *)
+let rec atproto_json_to_dag_cbor_json (j : Atproto_json.t) : Dag_cbor.json =
+  match Atproto_json.to_null_opt j with
+  | Some () -> `Null
+  | None -> (
+      match Atproto_json.to_bool_opt j with
+      | Some b -> `Bool b
+      | None -> (
+          match Atproto_json.to_int_opt j with
+          | Some i -> `Int i
+          | None -> (
+              match Atproto_json.to_float_opt j with
+              | Some f -> `Float f
+              | None -> (
+                  match Atproto_json.to_string_opt j with
+                  | Some s -> `String s
+                  | None -> (
+                      match Atproto_json.to_array_opt j with
+                      | Some l ->
+                          `List (List.map atproto_json_to_dag_cbor_json l)
+                      | None -> (
+                          match Atproto_json.to_object_opt j with
+                          | Some pairs ->
+                              `Assoc
+                                (List.map
+                                   (fun (k, v) ->
+                                     (k, atproto_json_to_dag_cbor_json v))
+                                   pairs)
+                          | None -> failwith "Unknown JSON type"))))))
 
 let test_dag_cbor_fixtures () =
   let fixtures = read_fixture_json "data-model/data-model-fixtures.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iteri
         (fun idx item ->
-          match item with
-          | `Assoc pairs -> (
+          match Atproto_json.to_object_opt item with
+          | Some pairs -> (
               let json_val =
-                List.assoc_opt "json" pairs
-                |> Option.map yojson_to_dag_cbor_json
-              in
-              let cbor_b64 =
-                match List.assoc_opt "cbor_base64" pairs with
-                | Some (`String s) -> Some s
-                | _ -> None
-              in
-              let expected_cid =
-                match List.assoc_opt "cid" pairs with
-                | Some (`String s) -> Some s
-                | _ -> None
+                Atproto_json.get "json" pairs
+                |> Option.map atproto_json_to_dag_cbor_json
               in
+              let cbor_b64 = Atproto_json.get_string_opt "cbor_base64" pairs in
+              let expected_cid = Atproto_json.get_string_opt "cid" pairs in
               match (json_val, cbor_b64, expected_cid) with
               | Some json, Some b64, Some cid_str -> (
-                  (* Parse JSON to value *)
                   match Dag_cbor.of_json json with
                   | Ok value -> (
-                      (* Encode to CBOR *)
                       let encoded = Dag_cbor.encode value in
-                      (* Decode expected CBOR *)
                       let expected_cbor = base64_decode_test b64 in
-                      (* Check CBOR matches *)
                       Alcotest.(check string)
                         (Printf.sprintf "fixture %d: CBOR encoding" idx)
                         expected_cbor encoded;
-                      (* Check CID matches *)
                       let cid = Cid.of_dag_cbor encoded in
                       Alcotest.(check string)
                         (Printf.sprintf "fixture %d: CID" idx)
                         cid_str (Cid.to_string cid);
-                      (* Test decode roundtrip *)
                       match Dag_cbor.decode encoded with
                       | Ok decoded ->
                           Alcotest.(check bool)
···
                       Alcotest.fail
                         (Printf.sprintf "fixture %d: JSON parse failed: %s" idx
                            (Dag_cbor.error_to_string e)))
-              | _ -> () (* Skip incomplete fixtures *))
-          | _ -> ())
+              | _ -> ())
+          | None -> ())
         items
-  | _ -> Alcotest.fail "Expected JSON array"
+  | None -> Alcotest.fail "Expected JSON array"
 
 let test_dag_cbor_key_sorting () =
   (* Test that map keys are sorted by length first, then lexicographically *)
···
 
 (** Validate AT Protocol data model JSON. This validates the structural rules
     beyond basic JSON parsing. *)
-let rec validate_data_model (j : Yojson.Basic.t) :
+let rec validate_data_model (j : Atproto_json.t) :
     (unit, data_model_error) result =
-  match j with
-  | `Null | `Bool _ | `String _ -> Ok ()
-  | `Int _ -> Ok ()
-  | `Float f ->
-      (* Floats must be integer-like in AT Protocol *)
-      if Float.is_integer f then Ok () else Error Float_not_integer
-  | `List items ->
-      (* Validate each item in the list *)
-      List.fold_left
-        (fun acc item ->
-          match acc with
-          | Error e -> Error e
-          | Ok () -> validate_data_model item)
-        (Ok ()) items
-  | `Assoc pairs ->
-      (* Check for special AT Protocol objects *)
-      let keys = List.map fst pairs in
-      if List.mem "$link" keys then validate_link pairs
-      else if List.mem "$bytes" keys then validate_bytes pairs
-      else if List.mem "$type" keys then validate_typed_object pairs
-      else
-        (* Regular object - validate all values *)
-        List.fold_left
-          (fun acc (_, v) ->
-            match acc with Error e -> Error e | Ok () -> validate_data_model v)
-          (Ok ()) pairs
+  match Atproto_json.to_null_opt j with
+  | Some () -> Ok ()
+  | None -> (
+      match Atproto_json.to_bool_opt j with
+      | Some _ -> Ok ()
+      | None -> (
+          match Atproto_json.to_string_opt j with
+          | Some _ -> Ok ()
+          | None -> (
+              match Atproto_json.to_int_opt j with
+              | Some _ -> Ok ()
+              | None -> (
+                  match Atproto_json.to_float_opt j with
+                  | Some f ->
+                      if Float.is_integer f then Ok ()
+                      else Error Float_not_integer
+                  | None -> (
+                      match Atproto_json.to_array_opt j with
+                      | Some items ->
+                          List.fold_left
+                            (fun acc item ->
+                              match acc with
+                              | Error e -> Error e
+                              | Ok () -> validate_data_model item)
+                            (Ok ()) items
+                      | None -> (
+                          match Atproto_json.to_object_opt j with
+                          | Some pairs ->
+                              let keys = List.map fst pairs in
+                              if List.mem "$link" keys then validate_link pairs
+                              else if List.mem "$bytes" keys then
+                                validate_bytes pairs
+                              else if List.mem "$type" keys then
+                                validate_typed_object pairs
+                              else
+                                List.fold_left
+                                  (fun acc (_, v) ->
+                                    match acc with
+                                    | Error e -> Error e
+                                    | Ok () -> validate_data_model v)
+                                  (Ok ()) pairs
+                          | None -> Ok ()))))))
 
 and validate_link pairs =
-  match pairs with
-  | [ ("$link", `String cid_str) ] ->
-      (* Validate CID string *)
-      if Cid.is_valid_syntax cid_str then Ok () else Error Link_invalid_cid
-  | [ ("$link", _) ] -> Error Link_wrong_type
-  | _ when List.length pairs > 1 -> Error Link_extra_fields
-  | _ -> Error Link_wrong_type
+  let link_val = Atproto_json.get "$link" pairs in
+  match link_val with
+  | Some v -> (
+      if List.length pairs > 1 then Error Link_extra_fields
+      else
+        match Atproto_json.to_string_opt v with
+        | Some cid_str ->
+            if Cid.is_valid_syntax cid_str then Ok ()
+            else Error Link_invalid_cid
+        | None -> Error Link_wrong_type)
+  | None -> Error Link_wrong_type
 
 and validate_bytes pairs =
-  match pairs with
-  | [ ("$bytes", `String _) ] -> Ok ()
-  | [ ("$bytes", _) ] -> Error Bytes_wrong_type
-  | _ when List.length pairs > 1 -> Error Bytes_extra_fields
-  | _ -> Error Bytes_wrong_type
+  let bytes_val = Atproto_json.get "$bytes" pairs in
+  match bytes_val with
+  | Some v -> (
+      if List.length pairs > 1 then Error Bytes_extra_fields
+      else
+        match Atproto_json.to_string_opt v with
+        | Some _ -> Ok ()
+        | None -> Error Bytes_wrong_type)
+  | None -> Error Bytes_wrong_type
 
 and validate_typed_object pairs =
-  (* Check $type field *)
-  let type_val = List.assoc_opt "$type" pairs in
+  let type_val = Atproto_json.get "$type" pairs in
   match type_val with
-  | Some `Null -> Error Type_null
-  | Some (`String s) when String.length s = 0 -> Error Type_empty
-  | Some (`String s) when s = "blob" ->
-      (* Validate blob structure *)
-      validate_blob pairs
-  | Some (`String _) ->
-      (* Valid record - validate all values *)
-      List.fold_left
-        (fun acc (_, v) ->
-          match acc with Error e -> Error e | Ok () -> validate_data_model v)
-        (Ok ()) pairs
-  | Some _ -> Error Type_not_string
-  | None -> Ok () (* No $type is fine for non-records *)
+  | Some v -> (
+      match Atproto_json.to_null_opt v with
+      | Some () -> Error Type_null
+      | None -> (
+          match Atproto_json.to_string_opt v with
+          | Some s when String.length s = 0 -> Error Type_empty
+          | Some s when s = "blob" -> validate_blob pairs
+          | Some _ ->
+              List.fold_left
+                (fun acc (_, v) ->
+                  match acc with
+                  | Error e -> Error e
+                  | Ok () -> validate_data_model v)
+                (Ok ()) pairs
+          | None -> Error Type_not_string))
+  | None -> Ok ()
 
 and validate_blob pairs =
-  (* Blob must have: $type = "blob", ref (CID link), mimeType (string), size (int) *)
-  let size_val = List.assoc_opt "size" pairs in
-  let ref_val = List.assoc_opt "ref" pairs in
-  match (size_val, ref_val) with
-  | Some (`String _), _ -> Error Blob_size_not_int
-  | _, None -> Error Blob_missing_ref
-  | Some (`Int _), Some ref_json ->
-      (* Validate the ref is a proper link *)
-      validate_data_model ref_json
-  | _ ->
-      (* Validate all fields *)
-      List.fold_left
-        (fun acc (_, v) ->
-          match acc with Error e -> Error e | Ok () -> validate_data_model v)
-        (Ok ()) pairs
+  let size_val = Atproto_json.get "size" pairs in
+  let ref_val = Atproto_json.get "ref" pairs in
+  match ref_val with
+  | None -> Error Blob_missing_ref
+  | Some ref_json -> (
+      match size_val with
+      | Some sv -> (
+          match Atproto_json.to_string_opt sv with
+          | Some _ -> Error Blob_size_not_int
+          | None -> (
+              match Atproto_json.to_int_opt sv with
+              | Some _ -> validate_data_model ref_json
+              | None ->
+                  List.fold_left
+                    (fun acc (_, v) ->
+                      match acc with
+                      | Error e -> Error e
+                      | Ok () -> validate_data_model v)
+                    (Ok ()) pairs))
+      | None ->
+          List.fold_left
+            (fun acc (_, v) ->
+              match acc with
+              | Error e -> Error e
+              | Ok () -> validate_data_model v)
+            (Ok ()) pairs)
 
-(** Validate top-level - must be an object *)
-let validate_top_level (j : Yojson.Basic.t) : (unit, data_model_error) result =
-  match j with
-  | `Assoc pairs ->
-      (* Validate all values recursively *)
+let validate_top_level (j : Atproto_json.t) : (unit, data_model_error) result =
+  match Atproto_json.to_object_opt j with
+  | Some pairs ->
       List.fold_left
         (fun acc (_, v) ->
           match acc with Error e -> Error e | Ok () -> validate_data_model v)
         (Ok ()) pairs
-  | _ -> Error Top_level_not_object
+  | None -> Error Top_level_not_object
 
 let test_data_model_valid () =
   let fixtures = read_fixture_json "data-model/data-model-valid.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc pairs -> (
+          match Atproto_json.to_object_opt item with
+          | Some pairs -> (
               let note =
-                match List.assoc_opt "note" pairs with
-                | Some (`String s) -> s
-                | _ -> "unknown"
+                match Atproto_json.get_string_opt "note" pairs with
+                | Some s -> s
+                | None -> "unknown"
               in
-              match List.assoc_opt "json" pairs with
+              match Atproto_json.get "json" pairs with
               | Some json ->
                   let result = validate_top_level json in
                   Alcotest.(check bool)
                     (Printf.sprintf "valid: %s" note)
                     true (Result.is_ok result)
               | None -> ())
-          | _ -> ())
+          | None -> ())
         items
-  | _ -> Alcotest.fail "Expected JSON array"
+  | None -> Alcotest.fail "Expected JSON array"
 
 let test_data_model_invalid () =
   let fixtures = read_fixture_json "data-model/data-model-invalid.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc pairs -> (
+          match Atproto_json.to_object_opt item with
+          | Some pairs -> (
               let note =
-                match List.assoc_opt "note" pairs with
-                | Some (`String s) -> s
-                | _ -> "unknown"
+                match Atproto_json.get_string_opt "note" pairs with
+                | Some s -> s
+                | None -> "unknown"
               in
-              match List.assoc_opt "json" pairs with
+              match Atproto_json.get "json" pairs with
               | Some json ->
                   let result = validate_top_level json in
                   Alcotest.(check bool)
                     (Printf.sprintf "invalid: %s" note)
                     true (Result.is_error result)
               | None -> ())
-          | _ -> ())
+          | None -> ())
         items
-  | _ -> Alcotest.fail "Expected JSON array"
+  | None -> Alcotest.fail "Expected JSON array"
 
 let data_model_tests =
   [

test/lexicon/dune

···
  (package atproto-lexicon)
  (deps
   (source_tree ../fixtures/lexicon))
- (libraries atproto-lexicon yojson alcotest))
+ (libraries atproto-lexicon alcotest))

test/mst/dune

···
  (package atproto-mst)
  (deps
   (source_tree ../fixtures/mst))
- (libraries atproto_mst atproto_ipld alcotest yojson))
+ (libraries atproto_mst atproto_ipld atproto_json alcotest))
 
 (executable
  (name debug_mst)

test/mst/test_mst.ml

···
   let ic = open_in path in
   let content = really_input_string ic (in_channel_length ic) in
   close_in ic;
-  Yojson.Basic.from_string content
+  match Atproto_json.decode content with
+  | Ok json -> json
+  | Error e -> failwith ("JSON parse error: " ^ e)
 
 (* === Key height tests === *)
 
 let test_key_heights () =
   let fixtures = read_fixture_json "key_heights.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc pairs -> (
-              let key =
-                match List.assoc_opt "key" pairs with
-                | Some (`String s) -> Some s
-                | _ -> None
-              in
-              let expected_height =
-                match List.assoc_opt "height" pairs with
-                | Some (`Int h) -> Some h
-                | _ -> None
-              in
+          match Atproto_json.to_object_opt item with
+          | Some pairs -> (
+              let key = Atproto_json.get_string_opt "key" pairs in
+              let expected_height = Atproto_json.get_int_opt "height" pairs in
               match (key, expected_height) with
               | Some k, Some expected ->
                   let actual = key_height k in
···
                     (Printf.sprintf "height of %S" k)
                     expected actual
               | _ -> ())
-          | _ -> ())
+          | None -> ())
         items
-  | _ -> Alcotest.fail "Expected JSON array"
+  | None -> Alcotest.fail "Expected JSON array"
 
 (* === Common prefix tests === *)
 
 let test_common_prefix () =
   let fixtures = read_fixture_json "common_prefix.json" in
-  match fixtures with
-  | `List items ->
+  match Atproto_json.to_array_opt fixtures with
+  | Some items ->
       List.iter
         (fun item ->
-          match item with
-          | `Assoc pairs -> (
-              let left =
-                match List.assoc_opt "left" pairs with
-                | Some (`String s) -> Some s
-                | _ -> None
-              in
-              let right =
-                match List.assoc_opt "right" pairs with
-                | Some (`String s) -> Some s
-                | _ -> None
-              in
-              let expected_len =
-                match List.assoc_opt "len" pairs with
-                | Some (`Int n) -> Some n
-                | _ -> None
-              in
+          match Atproto_json.to_object_opt item with
+          | Some pairs -> (
+              let left = Atproto_json.get_string_opt "left" pairs in
+              let right = Atproto_json.get_string_opt "right" pairs in
+              let expected_len = Atproto_json.get_int_opt "len" pairs in
               match (left, right, expected_len) with
               | Some l, Some r, Some expected ->
                   let actual = common_prefix_len l r in
···
                     (Printf.sprintf "prefix(%S, %S)" l r)
                     expected actual
               | _ -> ())
-          | _ -> ())
+          | None -> ())
         items
-  | _ -> Alcotest.fail "Expected JSON array"
+  | None -> Alcotest.fail "Expected JSON array"
 
 (* === MST operations tests === *)
 

test/sync/dune

···
 (test
  (name test_sync)
- (libraries atproto-sync atproto-ipld atproto-mst yojson alcotest))
+ (libraries atproto-sync atproto-ipld atproto-mst atproto-json alcotest))

test/sync/test_sync.ml

···
           content)
         else try_paths rest
   in
-  match Yojson.Safe.from_string (try_paths paths) with
-  | `List fixtures -> fixtures
-  | _ -> failwith "Expected array of fixtures"
+  match Atproto_json.decode (try_paths paths) with
+  | Ok json -> (
+      match Atproto_json.to_array_opt json with
+      | Some fixtures -> fixtures
+      | None -> failwith "Expected array of fixtures")
+  | Error e -> failwith ("JSON parse error: " ^ e)
 
 (** Extract string from JSON *)
-let json_string = function `String s -> s | _ -> failwith "Expected string"
+let json_string json =
+  match Atproto_json.to_string_opt json with
+  | Some s -> s
+  | None -> failwith "Expected string"
 
 (** Extract string list from JSON *)
-let json_string_list = function
-  | `List items -> List.map json_string items
-  | _ -> failwith "Expected array of strings"
+let json_string_list json =
+  match Atproto_json.to_array_opt json with
+  | Some items -> List.map json_string items
+  | None -> failwith "Expected array of strings"
 
 (** Get field from JSON object *)
-let json_field name = function
-  | `Assoc pairs -> List.assoc name pairs
-  | _ -> failwith ("Expected object with field " ^ name)
+let json_field name json =
+  match Atproto_json.to_object_opt json with
+  | Some pairs -> (
+      match Atproto_json.get name pairs with
+      | Some v -> v
+      | None -> failwith ("Expected object with field " ^ name))
+  | None -> failwith ("Expected object with field " ^ name)
 
 module Mst = Atproto_mst