lexicon: switch JSON from yojson to simdjsont

.beads/issues.jsonl

···
 {"id":"atproto-52","title":"Implement Lexicon validation","description":"Implement Lexicon-based validation for AT Protocol data. This validates records and API payloads against schemas.","design":"## Module Structure\n\n```ocaml\n(* atproto-lexicon/lib/validator.ml *)\ntype validation_error = {\n  path: string list;\n  message: string;\n}\n\nval validate_record :\n  registry:Registry.t -\u003e\n  nsid:Nsid.t -\u003e\n  value:Dag_cbor.value -\u003e\n  (unit, validation_error list) result\n\nval validate_xrpc_params :\n  registry:Registry.t -\u003e\n  nsid:Nsid.t -\u003e\n  params:(string * string) list -\u003e\n  (unit, validation_error list) result\n\nval validate_xrpc_input :\n  registry:Registry.t -\u003e\n  nsid:Nsid.t -\u003e\n  input:Jsont.json -\u003e\n  (unit, validation_error list) result\n\nval validate_xrpc_output :\n  registry:Registry.t -\u003e\n  nsid:Nsid.t -\u003e\n  output:Jsont.json -\u003e\n  (unit, validation_error list) result\n```\n\n## Constraint Types\n\n- **String**: minLength, maxLength, minGraphemes, maxGraphemes, format, enum, const\n- **Integer**: minimum, maximum, enum, const\n- **Bytes**: minLength, maxLength\n- **Array**: minLength, maxLength, items type\n- **Blob**: maxSize, accept (MIME types)\n- **Union**: open/closed, refs\n\n## Format Validators (Parser-based, NO REGEX)\n\nEach format has a dedicated parser module:\n\n```ocaml\n(* atproto-lexicon/lib/formats.ml *)\n\nlet validate_did s = Did.of_string s |\u003e Result.is_ok\nlet validate_handle s = Handle.of_string s |\u003e Result.is_ok\nlet validate_nsid s = Nsid.of_string s |\u003e Result.is_ok\nlet validate_tid s = Tid.of_string s |\u003e Result.is_ok\nlet validate_cid s = Cid.of_string s |\u003e Result.is_ok\nlet validate_at_uri s = At_uri.of_string s |\u003e Result.is_ok\nlet validate_at_identifier s = \n  Did.of_string s |\u003e Result.is_ok || Handle.of_string s |\u003e Result.is_ok\nlet validate_record_key s = Record_key.of_string s |\u003e Result.is_ok\n\nlet validate_datetime s =\n  (* Hand-written RFC-3339 parser *)\n  parse_datetime s |\u003e Result.is_ok\n\nlet validate_language s =\n  (* BCP-47 language tag parser *)\n  parse_language_tag s |\u003e Result.is_ok\n\nlet validate_uri s =\n  (* RFC-3986 URI parser *)\n  Uri.of_string s |\u003e Option.is_some\n```\n\n## Dependencies\n- atproto-lexicon (schema)\n- atproto-syntax (format validators)\n- jsont","acceptance_criteria":"- Validate records against schemas\n- Validate XRPC params, input, output\n- Proper error messages with paths\n- All constraint types supported\n- All record-data interop tests pass","status":"closed","priority":1,"issue_type":"feature","assignee":"claude","created_at":"2025-12-28T00:11:39.125440686+01:00","updated_at":"2025-12-28T10:25:46.671434007+01:00","closed_at":"2025-12-28T10:25:46.671434007+01:00","labels":["application","lexicon"],"dependencies":[{"issue_id":"atproto-52","depends_on_id":"atproto-50","type":"parent-child","created_at":"2025-12-28T00:12:05.375287273+01:00","created_by":"daemon"},{"issue_id":"atproto-52","depends_on_id":"atproto-51","type":"blocks","created_at":"2025-12-28T00:12:09.479940241+01:00","created_by":"daemon"}]}
 {"id":"atproto-53","title":"Implement Lexicon code generation","description":"Implement code generation from Lexicon schemas to OCaml types and API bindings.","design":"## Module Structure\n\n```ocaml\n(* atproto-lexicon-gen/lib/codegen.ml *)\ntype config = {\n  output_dir: string;\n  module_prefix: string;\n}\n\nval generate_types : config:config -\u003e lexicon:Lexicon.t -\u003e unit\nval generate_client : config:config -\u003e lexicons:Lexicon.t list -\u003e unit\n```\n\n## Generated Code Example\n\nInput Lexicon:\n```json\n{\n  \"id\": \"app.bsky.feed.post\",\n  \"defs\": {\n    \"main\": {\n      \"type\": \"record\",\n      \"record\": {\n        \"type\": \"object\",\n        \"properties\": {\n          \"text\": { \"type\": \"string\", \"maxGraphemes\": 300 },\n          \"createdAt\": { \"type\": \"string\", \"format\": \"datetime\" }\n        }\n      }\n    }\n  }\n}\n```\n\nGenerated OCaml:\n```ocaml\nmodule App_bsky_feed_post = struct\n  type t = {\n    text: string;\n    created_at: Ptime.t;\n  }\n  \n  let jsont : t Jsont.t =\n    Jsont.obj \"app.bsky.feed.post\" @@ fun o -\u003e\n    let text = Jsont.obj_mem o \"text\" Jsont.string in\n    let created_at = Jsont.obj_mem o \"createdAt\" Datetime.jsont in\n    Jsont.obj_finish o { text; created_at }\n  \n  val to_dag_cbor : t -\u003e Dag_cbor.value\n  val of_dag_cbor : Dag_cbor.value -\u003e (t, error) result\nend\n```\n\n## CLI Tool\n\n```bash\natproto-lexicon-gen --input lexicons/ --output lib/generated/\n```\n\n## Dependencies\n- atproto-lexicon\n- jsont","acceptance_criteria":"- Generate OCaml types from Lexicon schemas\n- Generate encoders/decoders\n- Type-safe API bindings\n- CLI tool for code generation","status":"closed","priority":2,"issue_type":"feature","assignee":"claude","created_at":"2025-12-28T00:11:47.861552784+01:00","updated_at":"2025-12-28T11:28:03.226633204+01:00","closed_at":"2025-12-28T11:28:03.226633204+01:00","labels":["application","codegen"],"dependencies":[{"issue_id":"atproto-53","depends_on_id":"atproto-50","type":"parent-child","created_at":"2025-12-28T00:12:06.539440409+01:00","created_by":"daemon"},{"issue_id":"atproto-53","depends_on_id":"atproto-51","type":"blocks","created_at":"2025-12-28T00:12:11.189125052+01:00","created_by":"daemon"}]}
 {"id":"atproto-54","title":"Implement high-level API client","description":"Implement high-level API client for AT Protocol / Bluesky. This provides a user-friendly interface for common operations.","design":"## Module Structure\n\n```ocaml\n(* atproto-api/lib/agent.ml *)\ntype t\n\nval create : pds:Uri.t -\u003e t\n\n(* Authentication *)\nval login : t -\u003e identifier:string -\u003e password:string -\u003e (t, error) result\nval login_oauth : t -\u003e tokens:Oauth.tokens -\u003e t\nval refresh_session : t -\u003e (t, error) result\n\n(* Profile *)\nval get_profile : t -\u003e actor:string -\u003e (profile, error) result\nval update_profile : t -\u003e display_name:string option -\u003e ... -\u003e (unit, error) result\n\n(* Posts *)\nval create_post : t -\u003e text:string -\u003e ?reply:reply_ref -\u003e ... -\u003e (post_ref, error) result\nval delete_post : t -\u003e uri:At_uri.t -\u003e (unit, error) result\n\n(* Social *)\nval like : t -\u003e uri:At_uri.t -\u003e cid:Cid.t -\u003e (like_ref, error) result\nval follow : t -\u003e did:Did.t -\u003e (follow_ref, error) result\nval unfollow : t -\u003e uri:At_uri.t -\u003e (unit, error) result\n\n(* Feed *)\nval get_timeline : t -\u003e ?cursor:string -\u003e ?limit:int -\u003e (timeline, error) result\nval get_author_feed : t -\u003e actor:string -\u003e ... -\u003e (feed, error) result\n\n(* atproto-api/lib/richtext.ml *)\ntype t\n\nval create : string -\u003e t\nval detect_facets : t -\u003e t  (* auto-detect mentions, links *)\nval add_mention : t -\u003e start:int -\u003e end_:int -\u003e did:Did.t -\u003e t\nval add_link : t -\u003e start:int -\u003e end_:int -\u003e uri:Uri.t -\u003e t\nval to_post_record : t -\u003e Dag_cbor.value\n```\n\n## Jsont Codecs for API Types\n\n```ocaml\nlet profile_jsont : profile Jsont.t =\n  Jsont.obj \"profile\" @@ fun o -\u003e\n  let did = Jsont.obj_mem o \"did\" did_jsont in\n  let handle = Jsont.obj_mem o \"handle\" handle_jsont in\n  let display_name = Jsont.obj_mem o \"displayName\" ~opt:true Jsont.string in\n  let description = Jsont.obj_mem o \"description\" ~opt:true Jsont.string in\n  let avatar = Jsont.obj_mem o \"avatar\" ~opt:true Jsont.string in\n  let followers_count = Jsont.obj_mem o \"followersCount\" ~opt:true Jsont.int in\n  let follows_count = Jsont.obj_mem o \"followsCount\" ~opt:true Jsont.int in\n  let posts_count = Jsont.obj_mem o \"postsCount\" ~opt:true Jsont.int in\n  Jsont.obj_finish o { did; handle; display_name; description; avatar; \n                        followers_count; follows_count; posts_count }\n\nlet facet_jsont : facet Jsont.t =\n  Jsont.obj \"facet\" @@ fun o -\u003e\n  let index = Jsont.obj_mem o \"index\" byte_slice_jsont in\n  let features = Jsont.obj_mem o \"features\" (Jsont.list facet_feature_jsont) in\n  Jsont.obj_finish o { index; features }\n```\n\n## RichText Facets\n\n```json\n{\n  \"text\": \"Hello @alice.bsky.social!\",\n  \"facets\": [\n    {\n      \"index\": { \"byteStart\": 6, \"byteEnd\": 25 },\n      \"features\": [\n        { \"$type\": \"app.bsky.richtext.facet#mention\", \"did\": \"did:plc:...\" }\n      ]\n    }\n  ]\n}\n```\n\n## Dependencies\n- atproto-xrpc\n- atproto-identity\n- atproto-repo\n- jsont","acceptance_criteria":"- Session management (login, logout, refresh)\n- Common operations (post, like, follow, etc.)\n- RichText handling (mentions, links, facets)\n- Timeline and feed fetching\n- Profile operations","status":"closed","priority":2,"issue_type":"feature","assignee":"claude","created_at":"2025-12-28T00:12:00.736309435+01:00","updated_at":"2025-12-28T11:47:47.071271001+01:00","closed_at":"2025-12-28T11:47:47.071271001+01:00","labels":["api","application"],"dependencies":[{"issue_id":"atproto-54","depends_on_id":"atproto-50","type":"parent-child","created_at":"2025-12-28T00:12:07.636789403+01:00","created_by":"daemon"},{"issue_id":"atproto-54","depends_on_id":"atproto-41","type":"blocks","created_at":"2025-12-28T00:12:12.376875324+01:00","created_by":"daemon"},{"issue_id":"atproto-54","depends_on_id":"atproto-33","type":"blocks","created_at":"2025-12-28T00:12:13.060557136+01:00","created_by":"daemon"},{"issue_id":"atproto-54","depends_on_id":"atproto-25","type":"blocks","created_at":"2025-12-28T00:12:13.934360048+01:00","created_by":"daemon"}]}
-{"id":"atproto-5l1","title":"Refactor JSON to simdjsont (replace yojson/jsont)","description":"","notes":"Next steps: migrate lib/crypto/jwt.ml off Yojson.Safe to Atproto_json/Simdjsont.Json (header_to_json/claims_to_json + *_of_json + create/decode_unverified); add atproto-json to lib/crypto/dune; run dune runtest test/crypto + full runtest; then continue with other Yojson hotspots (xrpc client/server, identity did_resolver, sync firehose, ipld blob).","status":"in_progress","priority":1,"issue_type":"feature","created_at":"2026-01-01T18:06:10.17746938+01:00","updated_at":"2026-01-01T19:32:47.437650903+01:00","dependencies":[{"issue_id":"atproto-5l1","depends_on_id":"atproto-dqs","type":"blocks","created_at":"2026-01-01T18:06:39.648046004+01:00","created_by":"daemon"}]}
+{"id":"atproto-5l1","title":"Refactor JSON to simdjsont (replace yojson/jsont)","description":"","notes":"Migrated atproto-lexicon off Yojson onto simdjsont.Json.t + Simdjsont.decode Codec.value. Updated lib/lexicon/{parser,validator,atproto_lexicon,codegen} and lib/lexicon/dune. Updated test/lexicon/test_lexicon.ml fixtures loader + patterns. Verified: dune runtest test/lexicon OK; dune build @install OK.","status":"in_progress","priority":1,"issue_type":"feature","created_at":"2026-01-01T18:06:10.17746938+01:00","updated_at":"2026-01-01T20:40:51.684953681+01:00","dependencies":[{"issue_id":"atproto-5l1","depends_on_id":"atproto-dqs","type":"blocks","created_at":"2026-01-01T18:06:39.648046004+01:00","created_by":"daemon"}]}
 {"id":"atproto-60","title":"Implement effects-based I/O abstraction","description":"Implement the effects-based I/O abstraction layer that makes all libraries runtime-agnostic.","design":"## Module Structure\n\n```ocaml\n(* atproto-effects/lib/effects.ml *)\n\n(* HTTP effects *)\ntype http_request = {\n  method_: [ `GET | `POST | `PUT | `DELETE ];\n  uri: Uri.t;\n  headers: (string * string) list;\n  body: string option;\n}\n\ntype http_response = {\n  status: int;\n  headers: (string * string) list;\n  body: string;\n}\n\ntype _ Effect.t +=\n  | Http_request : http_request -\u003e http_response Effect.t\n\n(* DNS effects *)\ntype _ Effect.t +=\n  | Dns_txt : string -\u003e string list Effect.t\n  | Dns_a : string -\u003e string list Effect.t\n\n(* Time effects *)\ntype _ Effect.t +=\n  | Now : Ptime.t Effect.t\n  | Sleep : float -\u003e unit Effect.t\n\n(* Random effects *)\ntype _ Effect.t +=\n  | Random_bytes : int -\u003e bytes Effect.t\n\n(* atproto-effects-eio/lib/handler.ml *)\nval run : (unit -\u003e 'a) -\u003e 'a\n```\n\n## Handler Example (eio)\n\n```ocaml\nlet run f =\n  Effect.Deep.match_ f ()\n  {\n    retc = Fun.id;\n    exnc = raise;\n    effc = fun (type a) (e : a Effect.t) -\u003e\n      match e with\n      | Http_request req -\u003e\n        Some (fun (k : (a, _) continuation) -\u003e\n          let resp = Eio_client.request req in\n          continue k resp)\n      | Dns_txt domain -\u003e\n        Some (fun k -\u003e\n          let records = Eio_dns.txt domain in\n          continue k records)\n      | _ -\u003e None\n  }\n```\n\n## Dependencies\n- eio (for testing handler)","acceptance_criteria":"- Effect types for HTTP, DNS, time, random\n- eio-based handler for testing\n- Handler composition utilities\n- Performance benchmarks","status":"closed","priority":1,"issue_type":"feature","assignee":"claude","created_at":"2025-12-28T00:12:29.021401617+01:00","updated_at":"2025-12-28T11:57:08.264086142+01:00","closed_at":"2025-12-28T11:57:08.264086142+01:00","labels":["effects","infrastructure"],"dependencies":[{"issue_id":"atproto-60","depends_on_id":"atproto-1","type":"parent-child","created_at":"2025-12-28T00:12:55.467983208+01:00","created_by":"daemon"}]}
 {"id":"atproto-61","title":"Set up interoperability test suite","description":"Set up and run the AT Protocol interoperability tests from bluesky-social/atproto-interop-tests.","design":"## Test Structure\n\n```\ntest/\n├── interop/\n│   ├── syntax_test.ml      # Handle, DID, NSID, TID, etc.\n│   ├── crypto_test.ml      # Signatures, did:key\n│   ├── data_model_test.ml  # DAG-CBOR, CID\n│   ├── mst_test.ml         # Key heights, tree structure\n│   ├── lexicon_test.ml     # Schema and record validation\n│   └── firehose_test.ml    # Commit proofs\n├── fixtures/               # Cloned from atproto-interop-tests\n└── dune\n```\n\n## Test Approach\n\n1. Clone test vectors from GitHub\n2. Parse JSON fixtures using jsont\n3. Parse text fixtures line by line\n4. Run each test case\n5. Compare output to expected values\n\n## Example Test\n\n```ocaml\nlet load_json_fixtures path =\n  let json = Jsont.of_file path in\n  Jsont.decode (Jsont.list fixture_jsont) json\n\nlet%test \"handle_syntax_valid\" =\n  let fixtures = load_lines \"fixtures/syntax/handle_syntax_valid.txt\" in\n  List.for_all (fun line -\u003e\n    match Handle.of_string line with\n    | Ok _ -\u003e true\n    | Error _ -\u003e false\n  ) fixtures\n\nlet%test \"handle_syntax_invalid\" =\n  let fixtures = load_lines \"fixtures/syntax/handle_syntax_invalid.txt\" in\n  List.for_all (fun line -\u003e\n    match Handle.of_string line with\n    | Ok _ -\u003e false\n    | Error _ -\u003e true\n  ) fixtures\n\nlet%test \"crypto_signature_fixtures\" =\n  let fixtures = load_json_fixtures \"fixtures/crypto/signature-fixtures.json\" in\n  List.for_all (fun fixture -\u003e\n    let message = Base64.decode fixture.message_base64 in\n    let signature = Base64.decode fixture.signature_base64 in\n    let key = Did_key.of_string fixture.public_key_did in\n    let result = Crypto.verify key message signature in\n    result = fixture.valid_signature\n  ) fixtures\n```\n\n## Dependencies\n- alcotest or ounit2\n- jsont","acceptance_criteria":"- All syntax interop tests pass\n- All crypto interop tests pass\n- All data-model interop tests pass\n- All MST interop tests pass\n- All lexicon interop tests pass\n- All firehose interop tests pass","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-28T00:12:40.553908313+01:00","updated_at":"2025-12-28T13:25:34.614867702+01:00","closed_at":"2025-12-28T13:25:34.614867702+01:00","labels":["conformance","testing"],"dependencies":[{"issue_id":"atproto-61","depends_on_id":"atproto-1","type":"parent-child","created_at":"2025-12-28T00:12:56.180809368+01:00","created_by":"daemon"}]}
 {"id":"atproto-62","title":"Set up monorepo package structure","description":"Set up the monorepo structure for multiple opam packages within a single repository.","design":"## Repository Structure\n\n```\natproto/\n├── dune-project           # Root with all packages\n├── packages/\n│   ├── atproto-syntax/\n│   │   ├── lib/\n│   │   │   ├── dune\n│   │   │   └── *.ml\n│   │   ├── test/\n│   │   │   ├── dune\n│   │   │   └── *_test.ml\n│   │   └── atproto-syntax.opam\n│   ├── atproto-crypto/\n│   ├── atproto-multibase/\n│   ├── atproto-ipld/\n│   ├── atproto-mst/\n│   ├── atproto-repo/\n│   ├── atproto-identity/\n│   ├── atproto-xrpc/\n│   ├── atproto-sync/\n│   ├── atproto-lexicon/\n│   ├── atproto-lexicon-gen/\n│   ├── atproto-api/\n│   └── atproto-effects/\n├── examples/\n│   ├── simple_client/\n│   └── firehose_consumer/\n└── interop-tests/\n```\n\n## dune-project\n\n```lisp\n(lang dune 3.20)\n(name atproto)\n(generate_opam_files true)\n\n(package\n (name atproto-syntax)\n (synopsis \"AT Protocol identifier syntax parsing\")\n (depends\n  (ocaml (\u003e= 5.4))\n  re\n  ptime))\n\n(package\n (name atproto-crypto)\n ...)\n```\n\n## CI (.github/workflows/ci.yml)\n\n- OCaml 5.4 matrix\n- Build all packages\n- Run all tests\n- Run interop tests","acceptance_criteria":"- Multi-package dune-project structure\n- Separate opam files per package\n- CI pipeline for building and testing\n- Documentation generation setup","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-28T00:12:50.547102438+01:00","updated_at":"2025-12-28T11:57:18.856810633+01:00","closed_at":"2025-12-28T11:57:18.856810633+01:00","labels":["infrastructure","setup"],"dependencies":[{"issue_id":"atproto-62","depends_on_id":"atproto-1","type":"parent-child","created_at":"2025-12-28T00:12:57.015938611+01:00","created_by":"daemon"}]}

lib/lexicon/atproto_lexicon.ml

···
 
     {[
       (* Parse a Lexicon schema *)
-      let schema_json = Yojson.Safe.from_file "app.bsky.feed.post.json" in
+      let schema_json =
+        match Parser.of_file "app.bsky.feed.post.json" with
+        | Ok lex -> lex
+        | Error msg -> failwith (Parser.error_to_string msg)
+      in
       let schema = Parser.parse_schema schema_json in
 
       (* Validate a record against a schema *)
       let record =
-        `Assoc
+        Simdjsont.Json.Object
           [
-            ("$type", `String "app.bsky.feed.post");
-            ("text", `String "Hello!");
-            ("createdAt", `String "2024-01-01T00:00:00Z");
+            ("$type", Simdjsont.Json.String "app.bsky.feed.post");
+            ("text", Simdjsont.Json.String "Hello!");
+            ("createdAt", Simdjsont.Json.String "2024-01-01T00:00:00Z");
           ]
       in
       match Validator.validate_record schema record with

lib/lexicon/codegen.ml

···
 
     Generated code includes:
     - OCaml record types matching Lexicon schemas
-    - JSON encoders/decoders using Yojson
+    - JSON encoders/decoders using simdjsont
     - DAG-CBOR encoders/decoders
     - Type-safe XRPC client methods *)
 
···
     | Schema.Array arr ->
         Printf.sprintf "%s list" (field_type_to_ocaml arr.items)
     | Schema.Object _ ->
-        "Yojson.Basic.t" (* Inline objects become raw JSON for now *)
+        "Simdjsont.Json.t" (* Inline objects become raw JSON for now *)
     | Schema.Ref r -> ref_to_ocaml r.ref_
     | Schema.Union u -> union_to_ocaml u
   in
···
   | Schema.String _ -> "string"
   | Schema.Bytes _ -> "string"
   | Schema.Cid_link _ -> "Cid.t"
-  | Schema.Unknown _ -> "Yojson.Basic.t"
+  | Schema.Unknown _ -> "Simdjsont.Json.t"
 
 and format_to_ocaml (fmt : Schema.string_format) : string =
   match fmt with
···
     let name = String.sub ref_str 1 (String.length ref_str - 1) in
     Printf.sprintf "%s.t" (String.capitalize_ascii (camel_to_snake name))
   else
-    (* External ref like "app.bsky.actor.defs#basicView" -> Yojson.Basic.t for now *)
-    "Yojson.Basic.t"
+    (* External ref like "app.bsky.actor.defs#basicView" -> Simdjsont.Json.t for now *)
+    "Simdjsont.Json.t"
 
 and union_to_ocaml (_u : Schema.union_type) : string =
   (* Unions become raw JSON for now - full union support would require variant types *)
-  "Yojson.Basic.t"
+  "Simdjsont.Json.t"
 
 (** {1 Code Generation} *)
 
···
 
   (* Generate output type if present *)
   emit_blank e;
-  emit e "type output = Yojson.Basic.t";
+  emit e "type output = Simdjsont.Json.t";
 
   dedent e;
   emit e "end";
···
   emit e (Printf.sprintf "let nsid = \"%s\"" lexicon.id);
 
   emit_blank e;
-  emit e "type input = Yojson.Basic.t";
+  emit e "type input = Simdjsont.Json.t";
   emit_blank e;
-  emit e "type output = Yojson.Basic.t";
+  emit e "type output = Simdjsont.Json.t";
 
   dedent e;
   emit e "end";

lib/lexicon/dune

···
 (library
  (name atproto_lexicon)
  (public_name atproto-lexicon)
- (libraries atproto_syntax yojson)
+ (libraries atproto_syntax simdjsont)
  (preprocess no_preprocessing))

lib/lexicon/parser.ml

···
 
 let error_to_string e = Format.asprintf "%a" pp_error e
 
+type json = Simdjsont.Json.t
+
+let int_of_int64 (i : int64) : int option =
+  if
+    Int64.compare i (Int64.of_int max_int) > 0
+    || Int64.compare i (Int64.of_int min_int) < 0
+  then None
+  else Some (Int64.to_int i)
+
 (** Helper to get string from JSON *)
 let get_string key json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt key pairs with
-      | Some (`String s) -> Some s
+      | Some (Simdjsont.Json.String s) -> Some s
       | _ -> None)
   | _ -> None
 
···
 (** Helper to get int from JSON *)
 let get_int key json =
   match json with
-  | `Assoc pairs -> (
-      match List.assoc_opt key pairs with Some (`Int i) -> Some i | _ -> None)
+  | Simdjsont.Json.Object pairs -> (
+      match List.assoc_opt key pairs with
+      | Some (Simdjsont.Json.Int i) -> int_of_int64 i
+      | _ -> None)
   | _ -> None
 
 (** Helper to get bool from JSON *)
 let get_bool key json =
   match json with
-  | `Assoc pairs -> (
-      match List.assoc_opt key pairs with Some (`Bool b) -> Some b | _ -> None)
+  | Simdjsont.Json.Object pairs -> (
+      match List.assoc_opt key pairs with
+      | Some (Simdjsont.Json.Bool b) -> Some b
+      | _ -> None)
   | _ -> None
 
 (** Helper to get list from JSON *)
 let get_list key json =
   match json with
-  | `Assoc pairs -> (
-      match List.assoc_opt key pairs with Some (`List l) -> Some l | _ -> None)
+  | Simdjsont.Json.Object pairs -> (
+      match List.assoc_opt key pairs with
+      | Some (Simdjsont.Json.Array l) -> Some l
+      | _ -> None)
   | _ -> None
 
 (** Helper to get assoc from JSON *)
 let get_assoc key json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt key pairs with
-      | Some (`Assoc a) -> Some a
+      | Some (Simdjsont.Json.Object a) -> Some a
       | _ -> None)
   | _ -> None
 
···
 let get_string_list key json =
   match get_list key json with
   | Some l ->
-      Some (List.filter_map (function `String s -> Some s | _ -> None) l)
+      Some
+        (List.filter_map
+           (function Simdjsont.Json.String s -> Some s | _ -> None)
+           l)
   | None -> None
 
 (** Helper to get int list *)
 let get_int_list key json =
   match get_list key json with
-  | Some l -> Some (List.filter_map (function `Int i -> Some i | _ -> None) l)
+  | Some l ->
+      Some
+        (List.filter_map
+           (function Simdjsont.Json.Int i -> int_of_int64 i | _ -> None)
+           l)
   | None -> None
 
 (** Parse a field type from JSON *)
···
                })
       | "array" -> (
           match json with
-          | `Assoc pairs -> (
+          | Simdjsont.Json.Object pairs -> (
               match List.assoc_opt "items" pairs with
               | Some items_json -> (
                   match parse_field_type items_json with
···
   | Some encoding ->
       let schema =
         match json with
-        | `Assoc pairs -> (
+        | Simdjsont.Json.Object pairs -> (
             match List.assoc_opt "schema" pairs with
             | Some schema_json -> (
                 match parse_field_type schema_json with
···
 (** Parse message from JSON *)
 let parse_message json : (Schema.message, error) result =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt "schema" pairs with
       | Some schema_json -> (
           match parse_field_type schema_json with
···
             | None -> Schema.Any
           in
           match json with
-          | `Assoc pairs -> (
+          | Simdjsont.Json.Object pairs -> (
               match List.assoc_opt "record" pairs with
               | Some record_json -> (
                   match parse_object_type record_json with
···
       | "query" ->
           let parameters =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "parameters" pairs with
                 | Some p -> (
                     match parse_params p with
···
           in
           let output =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "output" pairs with
                 | Some o -> (
                     match parse_body o with
···
       | "procedure" ->
           let parameters =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "parameters" pairs with
                 | Some p -> (
                     match parse_params p with
···
           in
           let input =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "input" pairs with
                 | Some i -> (
                     match parse_body i with
···
           in
           let output =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "output" pairs with
                 | Some o -> (
                     match parse_body o with
···
       | "subscription" ->
           let parameters =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "parameters" pairs with
                 | Some p -> (
                     match parse_params p with
···
           in
           let message =
             match json with
-            | `Assoc pairs -> (
+            | Simdjsont.Json.Object pairs -> (
                 match List.assoc_opt "message" pairs with
                 | Some m -> (
                     match parse_message m with
···
 (** Parse a complete lexicon from JSON *)
 let parse_lexicon json : (Schema.lexicon, error) result =
   match json with
-  | `Assoc _ -> (
+  | Simdjsont.Json.Object _ -> (
       match get_int "lexicon" json with
       | None -> Error (`Missing_field "lexicon")
       | Some version -> (
···
 
 (** Parse a lexicon from a JSON string *)
 let of_string s : (Schema.lexicon, error) result =
-  try
-    let json = Yojson.Basic.from_string s in
-    parse_lexicon json
-  with Yojson.Json_error msg -> Error (`Parse_error msg)
+  match Simdjsont.decode Simdjsont.Codec.value s with
+  | Ok json -> parse_lexicon json
+  | Error msg -> Error (`Parse_error msg)
 
 (** Parse a lexicon from a file *)
 let of_file path : (Schema.lexicon, error) result =
   try
-    let json = Yojson.Basic.from_file path in
-    parse_lexicon json
-  with
-  | Yojson.Json_error msg -> Error (`Parse_error msg)
-  | Sys_error msg -> Error (`Parse_error msg)
+    let ic = open_in path in
+    let len = in_channel_length ic in
+    let s = really_input_string ic len in
+    close_in ic;
+    of_string s
+  with Sys_error msg -> Error (`Parse_error msg)

lib/lexicon/validator.ml

···
 
 (* === JSON value helpers === *)
 
-type json = Yojson.Basic.t
+type json = Simdjsont.Json.t
 
 let get_string key = function
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt key pairs with
-      | Some (`String s) -> Some s
+      | Some (Simdjsont.Json.String s) -> Some s
       | _ -> None)
   | _ -> None
 
 let get_int key = function
-  | `Assoc pairs -> (
-      match List.assoc_opt key pairs with Some (`Int i) -> Some i | _ -> None)
+  | Simdjsont.Json.Object pairs -> (
+      match List.assoc_opt key pairs with
+      | Some (Simdjsont.Json.Int i) ->
+          if
+            Int64.compare i (Int64.of_int max_int) > 0
+            || Int64.compare i (Int64.of_int min_int) < 0
+          then None
+          else Some (Int64.to_int i)
+      | _ -> None)
   | _ -> None
 
 let get_bool key = function
-  | `Assoc pairs -> (
-      match List.assoc_opt key pairs with Some (`Bool b) -> Some b | _ -> None)
+  | Simdjsont.Json.Object pairs -> (
+      match List.assoc_opt key pairs with
+      | Some (Simdjsont.Json.Bool b) -> Some b
+      | _ -> None)
   | _ -> None
 
-let is_null = function `Null -> true | _ -> false
+let is_null = function Simdjsont.Json.Null -> true | _ -> false
 
 (* === Field validators === *)
 
 (** Validate a boolean value *)
 let validate_boolean ~path json =
-  match json with `Bool _ -> [] | _ -> [ error ~path "expected boolean" ]
+  match json with
+  | Simdjsont.Json.Bool _ -> []
+  | _ -> [ error ~path "expected boolean" ]
 
 (** Validate an integer value with constraints *)
 let validate_integer ~path ?minimum ?maximum ?enum ?const json =
   match json with
-  | `Int i ->
-      let errs = ref [] in
-      (match const with
-      | Some c when i <> c ->
-          errs := error ~path (Printf.sprintf "must be %d" c) :: !errs
-      | _ -> ());
-      (match enum with
-      | Some values when not (List.mem i values) ->
-          errs := error ~path "value not in enum" :: !errs
-      | _ -> ());
-      (match minimum with
-      | Some min when i < min ->
-          errs := error ~path (Printf.sprintf "must be >= %d" min) :: !errs
-      | _ -> ());
-      (match maximum with
-      | Some max when i > max ->
-          errs := error ~path (Printf.sprintf "must be <= %d" max) :: !errs
-      | _ -> ());
-      !errs
+  | Simdjsont.Json.Int i64 -> (
+      let i_opt =
+        if
+          Int64.compare i64 (Int64.of_int max_int) > 0
+          || Int64.compare i64 (Int64.of_int min_int) < 0
+        then None
+        else Some (Int64.to_int i64)
+      in
+      match i_opt with
+      | None -> [ error ~path "integer out of int range" ]
+      | Some i ->
+          let errs = ref [] in
+          (match const with
+          | Some c when i <> c ->
+              errs := error ~path (Printf.sprintf "must be %d" c) :: !errs
+          | _ -> ());
+          (match enum with
+          | Some values when not (List.mem i values) ->
+              errs := error ~path "value not in enum" :: !errs
+          | _ -> ());
+          (match minimum with
+          | Some min when i < min ->
+              errs := error ~path (Printf.sprintf "must be >= %d" min) :: !errs
+          | _ -> ());
+          (match maximum with
+          | Some max when i > max ->
+              errs := error ~path (Printf.sprintf "must be <= %d" max) :: !errs
+          | _ -> ());
+          !errs)
   | _ -> [ error ~path "expected integer" ]
 
 (** Validate a string value with constraints *)
 let validate_string ~path ?format ?min_length ?max_length ?min_graphemes
     ?max_graphemes ?enum ?const ?known_values:_ json =
   match json with
-  | `String s ->
+  | Simdjsont.Json.String s ->
       let errs = ref [] in
       (match const with
       | Some c when s <> c ->
···
 (** Validate a bytes value (expects $bytes object) *)
 let validate_bytes ~path ?min_length ?max_length json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt "$bytes" pairs with
-      | Some (`String b64) ->
+      | Some (Simdjsont.Json.String b64) ->
           (* Decode base64 to get actual length *)
           let len = String.length b64 * 3 / 4 in
           (* approximate *)
···
 (** Validate a CID link (expects $link object) *)
 let validate_cid_link ~path json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt "$link" pairs with
-      | Some (`String _cid) -> []
+      | Some (Simdjsont.Json.String _cid) -> []
       | _ -> [ error ~path "expected $link object" ])
   | _ -> [ error ~path "expected $link object" ]
 
 (** Validate a blob value *)
 let validate_blob ~path ?max_size ?accept json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt "$type" pairs with
-      | Some (`String "blob") ->
+      | Some (Simdjsont.Json.String "blob") ->
           let errs = ref [] in
           (* Check mimeType *)
           (match List.assoc_opt "mimeType" pairs with
-          | Some (`String mime) -> (
+          | Some (Simdjsont.Json.String mime) -> (
               match accept with
               | Some patterns ->
                   let matches =
···
           | None -> errs := error ~path "missing mimeType" :: !errs);
           (* Check size *)
           (match List.assoc_opt "size" pairs with
-          | Some (`Int size) -> (
-              match max_size with
-              | Some max when size > max ->
-                  errs :=
-                    error ~path (Printf.sprintf "blob size must be <= %d" max)
-                    :: !errs
-              | _ -> ())
+          | Some (Simdjsont.Json.Int size64) -> (
+              let size =
+                if
+                  Int64.compare size64 (Int64.of_int max_int) > 0
+                  || Int64.compare size64 (Int64.of_int min_int) < 0
+                then None
+                else Some (Int64.to_int size64)
+              in
+              match size with
+              | None -> errs := error ~path "size out of int range" :: !errs
+              | Some size -> (
+                  match max_size with
+                  | Some max when size > max ->
+                      errs :=
+                        error ~path
+                          (Printf.sprintf "blob size must be <= %d" max)
+                        :: !errs
+                  | _ -> ()))
           | Some _ -> errs := error ~path "size must be integer" :: !errs
           | None -> errs := error ~path "missing size" :: !errs);
           (* Check ref *)
···
     This is part of the data model restrictions. *)
 let validate_unknown ~path json =
   match json with
-  | `Bool _ -> [ error ~path "unknown type cannot contain boolean" ]
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Bool _ ->
+      [ error ~path "unknown type cannot contain boolean" ]
+  | Simdjsont.Json.Object pairs -> (
       (* Check for $bytes - not allowed in unknown *)
       match List.assoc_opt "$bytes" pairs with
       | Some _ -> [ error ~path "unknown type cannot contain bytes ($bytes)" ]
       | None -> (
           (* Check for blob ($type: "blob") - not allowed in unknown *)
           match List.assoc_opt "$type" pairs with
-          | Some (`String "blob") ->
+          | Some (Simdjsont.Json.String "blob") ->
               [ error ~path "unknown type cannot contain blob" ]
           | _ -> []))
   | _ -> []
···
 
 and validate_array ~resolver ~path (arr : Schema.array_type) json =
   match json with
-  | `List items ->
+  | Simdjsont.Json.Array items ->
       let errs = ref [] in
       (* Check length constraints *)
       let len = List.length items in
···
 
 and validate_object ~resolver ~path (obj : Schema.object_type) json =
   match json with
-  | `Assoc pairs ->
+  | Simdjsont.Json.Object pairs ->
       let errs = ref [] in
       (* Check required fields *)
       List.iter
···
   | None -> (
       (* Fallback: require an object for unresolved refs *)
       match json with
-      | `Assoc _ -> []
+      | Simdjsont.Json.Object _ -> []
       | _ -> [ error ~path "expected object for ref" ])
 
 and validate_union ~resolver ~path (union : Schema.union_type) json =
   match json with
-  | `Assoc pairs -> (
+  | Simdjsont.Json.Object pairs -> (
       match List.assoc_opt "$type" pairs with
-      | Some (`String type_ref) ->
+      | Some (Simdjsont.Json.String type_ref) ->
           let errs = ref [] in
           (* Check if type is in allowed refs for closed unions *)
           (if union.closed then

test/lexicon/test_lexicon.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 Simdjsont.decode Simdjsont.Codec.value content with
+  | Ok json -> json
+  | Error msg -> failwith msg
 
 (** Read catalog lexicon file *)
 let read_catalog_file filename =
···
 let test_valid_lexicons () =
   let fixtures = read_fixture_json "lexicon-valid.json" in
   match fixtures with
-  | `List items ->
+  | Simdjsont.Json.Array items ->
       List.iter
         (fun item ->
           match item with
-          | `Assoc pairs -> (
+          | Simdjsont.Json.Object pairs -> (
               let name =
                 match List.assoc_opt "name" pairs with
-                | Some (`String s) -> s
+                | Some (Simdjsont.Json.String s) -> s
                 | _ -> "unknown"
               in
               match List.assoc_opt "lexicon" pairs with
               | Some lexicon_json -> (
-                  let lexicon_str = Yojson.Basic.to_string lexicon_json in
+                  let lexicon_str = Simdjsont.Json.to_string lexicon_json in
                   match Parser.of_string lexicon_str with
                   | Ok lexicon ->
                       Alcotest.(check bool)
···
 let test_invalid_lexicons () =
   let fixtures = read_fixture_json "lexicon-invalid.json" in
   match fixtures with
-  | `List items ->
+  | Simdjsont.Json.Array items ->
       List.iter
         (fun item ->
           match item with
-          | `Assoc pairs -> (
+          | Simdjsont.Json.Object pairs -> (
               let name =
                 match List.assoc_opt "name" pairs with
-                | Some (`String s) -> s
+                | Some (Simdjsont.Json.String s) -> s
                 | _ -> "unknown"
               in
               match List.assoc_opt "lexicon" pairs with
               | Some lexicon_json -> (
-                  let lexicon_str = Yojson.Basic.to_string lexicon_json in
+                  let lexicon_str = Simdjsont.Json.to_string lexicon_json in
                   match Parser.of_string lexicon_str with
                   | Ok _ ->
                       (* Some "invalid" lexicons may be parseable but semantically invalid *)
···
       let resolver = make_resolver lexicon in
       let fixtures = read_fixture_json "record-data-valid.json" in
       match fixtures with
-      | `List items ->
+      | Simdjsont.Json.Array items ->
           List.iter
             (fun item ->
               match item with
-              | `Assoc pairs -> (
+              | Simdjsont.Json.Object pairs -> (
                   let name =
                     match List.assoc_opt "name" pairs with
-                    | Some (`String s) -> s
+                    | Some (Simdjsont.Json.String s) -> s
                     | _ -> "unknown"
                   in
                   match List.assoc_opt "data" pairs with
···
       let resolver = make_resolver lexicon in
       let fixtures = read_fixture_json "record-data-invalid.json" in
       match fixtures with
-      | `List items ->
+      | Simdjsont.Json.Array items ->
           List.iter
             (fun item ->
               match item with
-              | `Assoc pairs -> (
+              | Simdjsont.Json.Object pairs -> (
                   let name =
                     match List.assoc_opt "name" pairs with
-                    | Some (`String s) -> s
+                    | Some (Simdjsont.Json.String s) -> s
                     | _ -> "unknown"
                   in
                   match List.assoc_opt "data" pairs with
···
   | None -> Alcotest.fail "could not load record schema"
   | Some schema ->
       (* Missing required 'integer' field *)
-      let data = `Assoc [ ("$type", `String "example.lexicon.record") ] in
+      let data =
+        Simdjsont.Json.Object
+          [ ("$type", Simdjsont.Json.String "example.lexicon.record") ]
+      in
       let errors = Validator.validate_record ~path:[] schema data in
       Alcotest.(check bool) "has errors" true (errors <> []);
       let has_required_error =
···
   | Some schema ->
       (* Wrong type for integer field *)
       let data =
-        `Assoc
+        Simdjsont.Json.Object
           [
-            ("$type", `String "example.lexicon.record");
-            ("integer", `String "not-an-integer");
+            ("$type", Simdjsont.Json.String "example.lexicon.record");
+            ("integer", Simdjsont.Json.String "not-an-integer");
           ]
       in
       let errors = Validator.validate_record ~path:[] schema data in
···
   | Some schema ->
       (* Invalid DID format in nested formats object *)
       let data =
-        `Assoc
+        Simdjsont.Json.Object
           [
-            ("$type", `String "example.lexicon.record");
-            ("integer", `Int 1);
-            ("formats", `Assoc [ ("did", `String "invalid-did") ]);
+            ("$type", Simdjsont.Json.String "example.lexicon.record");
+            ("integer", Simdjsont.Json.Int 1L);
+            ( "formats",
+              Simdjsont.Json.Object
+                [ ("did", Simdjsont.Json.String "invalid-did") ] );
           ]
       in
       let _errors = Validator.validate_record ~path:[] schema data in
···
   | Some schema ->
       (* Integer out of range *)
       let data =
-        `Assoc
+        Simdjsont.Json.Object
           [
-            ("$type", `String "example.lexicon.record");
-            ("integer", `Int 1);
-            ("rangeInteger", `Int 9000);
+            ("$type", Simdjsont.Json.String "example.lexicon.record");
+            ("integer", Simdjsont.Json.Int 1L);
+            ("rangeInteger", Simdjsont.Json.Int 9000L);
           ]
       in
       let errors = Validator.validate_record ~path:[] schema data in