Add IPLD compliance features: Float support, CIDv0, CBOR strictness, DAG-JSON

- Add Float variant to DAG-CBOR value type with decode_mode (Ipld/Atproto)
- Floats encoded as 64-bit IEEE 754 doubles, NaN/Infinity rejected
- Add CIDv0 support: parsing, encoding, version detection
- Add CBOR strictness checking: reject indefinite-length encoding
- Implement DAG-JSON codec with {/: cid} links and {/: {bytes: b64}} bytes
- Add 22 new IPLD tests (66 total), all 494 compliance tests pass

.beads/issues.jsonl

···
 {"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"}]}
+{"id":"atproto-cir","title":"Implement DAG-JSON codec","description":"Create lib/ipld/dag_json.ml, encode Links as {\"/\": \"\u003ccid-string\u003e\"}, encode Bytes as {\"/\": {\"bytes\": \"\u003cbase64\u003e\"}}","status":"closed","priority":2,"issue_type":"feature","created_at":"2025-12-28T15:47:30.578398468+01:00","updated_at":"2025-12-28T16:06:13.475583417+01:00","closed_at":"2025-12-28T16:06:13.475583417+01:00","labels":["compliance","ipld"]}
 {"id":"atproto-h09","title":"Add package documentation","description":"Add documentation for each of the 11 AT Protocol packages including:\n- Module-level documentation with examples\n- README.md for the root project\n- CONTRIBUTING.md guide\n- API documentation generation with odoc","status":"closed","priority":2,"issue_type":"task","assignee":"claude","created_at":"2025-12-28T13:34:10.559554696+01:00","updated_at":"2025-12-28T13:50:20.509417248+01:00","closed_at":"2025-12-28T13:50:20.509417248+01:00","labels":["documentation"],"dependencies":[{"issue_id":"atproto-h09","depends_on_id":"atproto-1","type":"parent-child","created_at":"2025-12-28T13:34:16.081103184+01:00","created_by":"daemon"}]}
+{"id":"atproto-kc7","title":"Verify/enforce CBOR strictness","description":"Check that CBOR library produces shortest-form encoding, add explicit rejection of indefinite-length items during decode","status":"closed","priority":2,"issue_type":"feature","created_at":"2025-12-28T15:47:28.665226526+01:00","updated_at":"2025-12-28T16:02:55.549763384+01:00","closed_at":"2025-12-28T16:02:55.549763384+01:00","labels":["compliance","ipld"]}
 {"id":"atproto-pg8","title":"Add MST example_keys.txt fixture tests","description":"Add tests using the example_keys.txt fixture file which contains 156 structured MST keys.\n\nTests should:\n1. Load all 156 keys from the fixture\n2. Build an MST containing all keys\n3. Verify all keys are retrievable\n4. Verify iteration order matches sorted key order\n5. Optionally verify tree structure properties","acceptance_criteria":"- example_keys.txt is loaded and all 156 keys are used\n- MST is built with all keys\n- All keys are retrievable after insertion\n- Iteration produces keys in sorted order","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-28T12:12:19.180139823+01:00","updated_at":"2025-12-28T12:43:14.192342391+01:00","closed_at":"2025-12-28T12:43:14.192342391+01:00","labels":["conformance","mst","testing"]}
 {"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-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"]}

COMPLIANCE.md

···
 # AT Protocol Compliance Report
 
-**Generated:** 2025-12-28T13:56:33Z  
+**Generated:** 2025-12-28T15:06:07Z  
 **Repository:** [https://github.com/gdiazlo/atproto](https://github.com/gdiazlo/atproto)  
 
 ## Summary

compliance-report.html

···
     </table>
   </div>
   <div class="meta">
-    <p>Generated: 2025-12-28T13:56:33Z</p>
+    <p>Generated: 2025-12-28T15:06:07Z</p>
     <p>Repository: <a href="https://github.com/gdiazlo/atproto">https://github.com/gdiazlo/atproto</a></p>
     <p>Test fixtures from <a href="https://github.com/bluesky-social/atproto-interop-tests">AT Protocol Interoperability Tests</a></p>
   </div>

compliance-report.json

···
 {
   "title": "AT Protocol Compliance Report",
   "version": "1.0.0",
-  "generated_at": "2025-12-28T13:56:33Z",
+  "generated_at": "2025-12-28T15:06:07Z",
   "repository": "https://github.com/gdiazlo/atproto",
   "total_tests": 494,
   "total_passed": 494,

lib/ipld/atproto_ipld.ml

···
 
     - {!module:Cid}: Content Identifiers (CIDv0 and CIDv1)
     - {!module:Dag_cbor}: DAG-CBOR encoding with AT Protocol sorting rules
+    - {!module:Dag_json}: DAG-JSON encoding for human-readable IPLD
     - {!module:Car}: CAR (Content-Addressable aRchive) file handling
     - {!module:Blob}: Blob reference handling for media
 
···
 
 module Cid = Cid
 module Dag_cbor = Dag_cbor
+module Dag_json = Dag_json
 module Car = Car
 module Blob = Blob

lib/ipld/cid.ml

···
-(** CID (Content Identifier) for AT Protocol.
+(** CID (Content Identifier) for IPLD and AT Protocol.
 
-    CIDs are self-describing content-addressed identifiers used throughout AT
-    Protocol for referencing data blocks.
+    CIDs are self-describing content-addressed identifiers used throughout IPLD
+    and AT Protocol for referencing data blocks.
+
+    This module supports both CIDv0 and CIDv1:
 
-    AT Protocol blessed CID format:
-    - Version: CIDv1 only
+    CIDv0 (legacy IPFS format):
+    - Base58btc encoded, starting with "Qm"
+    - Implicit dag-pb codec (0x70)
+    - SHA-256 hash only
+    - 46 characters when encoded
+
+    CIDv1 (AT Protocol blessed format):
+    - Version: CIDv1
     - Hash: SHA-256 (multicodec 0x12), 256 bits
     - Codec: dag-cbor (0x71) for records, raw (0x55) for blobs
     - String encoding: base32lower (multibase prefix 'b') *)
···
   | `Invalid_hash_length
   | `Invalid_multibase
   | `Invalid_cid_format
-  | `Cid_too_short ]
+  | `Cid_too_short
+  | `Invalid_cidv0 ]
 
 let pp_error fmt = function
-  | `Invalid_cid_version -> Format.fprintf fmt "invalid CID version (must be 1)"
+  | `Invalid_cid_version ->
+      Format.fprintf fmt "invalid CID version (must be 0 or 1)"
   | `Invalid_hash_algorithm ->
       Format.fprintf fmt "invalid hash algorithm (must be SHA-256)"
   | `Invalid_hash_length -> Format.fprintf fmt "invalid hash length"
   | `Invalid_multibase -> Format.fprintf fmt "invalid multibase encoding"
   | `Invalid_cid_format -> Format.fprintf fmt "invalid CID format"
   | `Cid_too_short -> Format.fprintf fmt "CID too short"
+  | `Invalid_cidv0 -> Format.fprintf fmt "invalid CIDv0 format"
 
 let error_to_string e = Format.asprintf "%a" pp_error e
 
···
     | Other n -> n
 end
 
-type t = { codec : codec; hash : string  (** 32-byte SHA-256 hash *) }
-(** CID type - stores the codec and hash *)
+(** CID version *)
+type version = V0 | V1
+
+type t = {
+  version : version;
+  codec : codec;
+  hash : string;  (** 32-byte SHA-256 hash *)
+}
+(** CID type - stores the version, codec and hash *)
 
 (** Encode an unsigned varint to bytes *)
 let encode_varint n =
···
 (** Create a CID from content bytes by hashing with SHA-256 *)
 let create ~codec (content : string) : t =
   let hash = Digestif.SHA256.(to_raw_string (digest_string content)) in
-  { codec; hash }
+  { version = V1; codec; hash }
 
 (** Create a CID for DAG-CBOR content *)
 let of_dag_cbor content = create ~codec:DagCbor content
···
 (** Create a CID from a pre-computed hash *)
 let of_hash ~codec hash : (t, error) result =
   if String.length hash <> 32 then Error `Invalid_hash_length
-  else Ok { codec; hash }
+  else Ok { version = V1; codec; hash }
+
+(** Get the version *)
+let cid_version t = t.version
 
 (** Get the codec *)
 let codec t = t.codec
···
   in
   if c <> 0 then c else String.compare t1.hash t2.hash
 
-(** Encode CID to binary format (for CBOR tag 42) *)
+(** Encode CID to binary format (for CBOR tag 42). CIDv0 is encoded as just the
+    multihash (for compatibility). CIDv1 is encoded as version + codec +
+    multihash. *)
 let to_bytes t =
-  let version = encode_varint 1 in
-  let codec = encode_varint (Multicodec.int_of_codec t.codec) in
-  let hash_info = encode_varint Multicodec.sha256 in
-  let hash_len = encode_varint 32 in
-  version ^ codec ^ hash_info ^ hash_len ^ t.hash
+  match t.version with
+  | V0 ->
+      (* CIDv0: just the multihash (sha256 indicator + length + hash) *)
+      let hash_info = encode_varint Multicodec.sha256 in
+      let hash_len = encode_varint 32 in
+      hash_info ^ hash_len ^ t.hash
+  | V1 ->
+      let version = encode_varint 1 in
+      let codec = encode_varint (Multicodec.int_of_codec t.codec) in
+      let hash_info = encode_varint Multicodec.sha256 in
+      let hash_len = encode_varint 32 in
+      version ^ codec ^ hash_info ^ hash_len ^ t.hash
 
-(** Encode CID to string (base32lower with 'b' prefix) *)
+(** Encode CID to string. CIDv0: base58btc (starts with "Qm") CIDv1: base32lower
+    with 'b' prefix *)
 let to_string t =
-  let bytes = to_bytes t in
-  "b" ^ Atproto_multibase.Base32lower.encode (Bytes.of_string bytes)
+  match t.version with
+  | V0 ->
+      (* CIDv0 uses base58btc without multibase prefix *)
+      Atproto_multibase.Base58btc.encode (Bytes.of_string (to_bytes t))
+  | V1 ->
+      let bytes = to_bytes t in
+      "b" ^ Atproto_multibase.Base32lower.encode (Bytes.of_string bytes)
 
-(** Parse CID from binary bytes *)
-let of_bytes s : (t, error) result =
+(** Parse CIDv0 from binary bytes (just multihash). CIDv0 is: hash_codec
+    (varint) + hash_len (varint) + hash (bytes) *)
+let of_bytes_v0 s : (t, error) result =
+  let len = String.length s in
+  if len < 34 then Error `Cid_too_short
+  else
+    (* First byte should be 0x12 (sha256) *)
+    match decode_varint s 0 with
+    | Error e -> Error e
+    | Ok (hash_codec, hclen) -> (
+        if hash_codec <> Multicodec.sha256 then Error `Invalid_hash_algorithm
+        else
+          match decode_varint s hclen with
+          | Error e -> Error e
+          | Ok (hash_len, hllen) ->
+              if hash_len <> 32 then Error `Invalid_hash_length
+              else
+                let hash_start = hclen + hllen in
+                if len < hash_start + 32 then Error `Cid_too_short
+                else
+                  let hash = String.sub s hash_start 32 in
+                  (* CIDv0 implicitly uses dag-pb codec *)
+                  Ok { version = V0; codec = DagPb; hash })
+
+(** Parse CIDv1 from binary bytes *)
+let of_bytes_v1 s : (t, error) result =
   let len = String.length s in
   if len < 4 then Error `Cid_too_short
   else
···
                           if len < hash_start + 32 then Error `Cid_too_short
                           else
                             let hash = String.sub s hash_start 32 in
-                            Ok { codec; hash })))
+                            Ok { version = V1; codec; hash })))
+
+(** Parse CID from binary bytes. Distinguishes CIDv0 from CIDv1 by first byte:
+    - 0x12 (sha256): CIDv0 (just multihash)
+    - 0x01: CIDv1 *)
+let of_bytes s : (t, error) result =
+  let len = String.length s in
+  if len < 2 then Error `Cid_too_short
+  else
+    let first_byte = Char.code s.[0] in
+    if first_byte = 0x12 then
+      (* CIDv0: starts with sha256 multicodec *)
+      of_bytes_v0 s
+    else if first_byte = 0x01 then
+      (* CIDv1: starts with version 1 *)
+      of_bytes_v1 s
+    else Error `Invalid_cid_format
 
 (** Decode hex string to bytes *)
 let decode_hex s =
···
     Some buf
   with Exit -> None
 
-(** Parse CID from string (multibase encoded) *)
+(** Check if a string looks like a CIDv0 (base58btc encoded, starts with "Qm")
+*)
+let is_cidv0_string s =
+  let len = String.length s in
+  (* CIDv0 is exactly 46 characters and starts with "Qm" *)
+  len = 46 && len >= 2 && s.[0] = 'Q' && s.[1] = 'm'
+
+(** Parse CID from string (multibase encoded for CIDv1, base58btc for CIDv0) *)
 let of_string s : (t, error) result =
   let len = String.length s in
   if len < 2 then Error `Cid_too_short
+  else if is_cidv0_string s then
+    (* CIDv0: base58btc without multibase prefix *)
+    match Atproto_multibase.Base58btc.decode s with
+    | Ok bytes -> of_bytes_v0 (Bytes.to_string bytes)
+    | Error _ -> Error `Invalid_cidv0
   else
-    (* Check multibase prefix *)
+    (* CIDv1: multibase prefix + encoded data *)
     let prefix = s.[0] in
     let encoded = String.sub s 1 (len - 1) in
     (* AT Protocol uses base32lower ('b') but we also accept others *)
···
           | Ok bytes -> Some bytes
           | Error _ -> None)
       | 'z' -> (
-          (* Base58btc *)
+          (* Base58btc with multibase prefix *)
           match Atproto_multibase.Base58btc.decode encoded with
           | Ok bytes -> Some bytes
           | Error _ -> None)
···
 (** Validate a CID string without fully parsing *)
 let is_valid s = match of_string s with Ok _ -> true | Error _ -> false
 
-(** Regex-based CID syntax validation (matches Go implementation). This is used
-    for Lexicon validation - it checks the string format without fully decoding
-    and validating the CID contents.
+(** Regex-based CID syntax validation for AT Protocol (matches Go
+    implementation). This is used for Lexicon validation - it checks the string
+    format without fully decoding and validating the CID contents.
 
-    Rules:
+    Rules for CIDv1:
     - Length between 8-256 characters
     - Only alphanumeric characters plus '+' and '='
-    - Not a CIDv0 (starting with "Qmb") *)
+    - Not a legacy CIDv0 (starting with "Qmb")
+
+    Note: AT Protocol Lexicon validation intentionally excludes CIDv0. Use
+    is_valid_cidv0_syntax for validating CIDv0 strings. *)
 let is_valid_syntax s =
   let len = String.length s in
   if len < 8 || len > 256 then false
···
         if valid then check_chars (i + 1) else false
     in
     check_chars 0
+
+(** Validate CIDv0 string syntax. CIDv0 is exactly 46 characters and starts with
+    "Qm". Uses base58btc alphabet (no 0, O, I, l). *)
+let is_valid_cidv0_syntax s =
+  let len = String.length s in
+  if len <> 46 then false
+  else if not (len >= 2 && s.[0] = 'Q' && s.[1] = 'm') then false
+  else
+    (* Check all characters are valid base58btc *)
+    let base58_alphabet =
+      "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+    in
+    let rec check_chars i =
+      if i >= len then true
+      else if String.contains base58_alphabet s.[i] then check_chars (i + 1)
+      else false
+    in
+    check_chars 0
+
+(** Validate any CID string syntax (CIDv0 or CIDv1) *)
+let is_valid_any_syntax s = is_valid_syntax s || is_valid_cidv0_syntax s

lib/ipld/dag_cbor.ml

···
-(** DAG-CBOR codec for AT Protocol.
+(** DAG-CBOR codec for IPLD and AT Protocol.
 
     DAG-CBOR is a deterministic subset of CBOR used for content-addressed data.
-    This module provides encoding and decoding with AT Protocol specific rules:
+    This module provides encoding and decoding with two modes:
+
+    - IPLD mode (default): Full IPLD Data Model support including floats
+    - AT Protocol mode: Stricter rules where floats are forbidden
+
+    Common rules for both modes:
     - Map keys are sorted by length first, then lexicographically
-    - Floats are not allowed (except integers represented as floats in JSON)
     - Integers must be in JavaScript safe range (-2^53+1 to 2^53-1)
-    - CIDs are encoded with CBOR tag 42 *)
+    - CIDs are encoded with CBOR tag 42
+
+    IPLD-specific rules:
+    - Floats are encoded as 64-bit IEEE 754 doubles
+    - NaN, Infinity, and -Infinity are forbidden
+
+    AT Protocol-specific rules:
+    - Floats are not allowed (except integers represented as floats in JSON) *)
+
+(** Decoding mode for DAG-CBOR *)
+type decode_mode =
+  | Ipld  (** Full IPLD spec: allows floats (no NaN/Inf) *)
+  | Atproto  (** AT Protocol spec: no floats allowed *)
 
 type error =
   [ `Float_not_allowed
+  | `Float_nan_not_allowed
+  | `Float_infinity_not_allowed
   | `Integer_out_of_range
   | `Invalid_cid
   | `Invalid_tag
   | `Invalid_bytes
+  | `Indefinite_length
   | `Decode_error of string ]
 
 let pp_error fmt = function
   | `Float_not_allowed ->
-      Format.fprintf fmt "floats are not allowed in DAG-CBOR"
+      Format.fprintf fmt "floats are not allowed in AT Protocol DAG-CBOR"
+  | `Float_nan_not_allowed ->
+      Format.fprintf fmt "NaN is not allowed in DAG-CBOR"
+  | `Float_infinity_not_allowed ->
+      Format.fprintf fmt "Infinity is not allowed in DAG-CBOR"
   | `Integer_out_of_range ->
       Format.fprintf fmt "integer out of JavaScript safe range"
   | `Invalid_cid -> Format.fprintf fmt "invalid CID in tag 42"
   | `Invalid_tag -> Format.fprintf fmt "unsupported CBOR tag"
   | `Invalid_bytes -> Format.fprintf fmt "invalid bytes encoding"
+  | `Indefinite_length ->
+      Format.fprintf fmt "indefinite-length encoding not allowed in DAG-CBOR"
   | `Decode_error msg -> Format.fprintf fmt "decode error: %s" msg
 
 let error_to_string e = Format.asprintf "%a" pp_error e
 
-(** AT Protocol data model value type *)
+(** IPLD Data Model value type.
+
+    The 9 IPLD kinds: Null, Boolean, Integer, Float, String, Bytes, List, Map,
+    Link. Note: In AT Protocol mode, Float is forbidden. *)
 type value =
   | Null
   | Bool of bool
   | Int of int64  (** JavaScript safe integer range *)
+  | Float of float  (** IEEE 754 double; NaN/Infinity forbidden *)
   | String of string
   | Bytes of string  (** Raw bytes *)
   | Array of value list
   | Map of (string * value) list  (** Keys are sorted *)
   | Link of Cid.t  (** CID link *)
+
+(** Check if a float is NaN *)
+let is_nan f = Float.is_nan f
+
+(** Check if a float is infinite (positive or negative) *)
+let is_infinite f =
+  match classify_float f with FP_infinite -> true | _ -> false
+
+(** Check if a float is valid for DAG-CBOR (no NaN or Infinity) *)
+let is_valid_float f = not (is_nan f || is_infinite f)
 
 (** JavaScript safe integer range *)
 let js_safe_min = -9007199254740991L (* -(2^53 - 1) *)
···
 (** Sort map keys according to DAG-CBOR rules *)
 let sort_map pairs = List.sort (fun (k1, _) (k2, _) -> compare_keys k1 k2) pairs
 
-(** Encode a value to DAG-CBOR bytes *)
+(** Check CBOR bytes for DAG-CBOR strictness violations.
+
+    DAG-CBOR forbids:
+    - Indefinite-length encoding (additional info 31 for types 0-5)
+    - Break stop code (0xFF)
+
+    Returns Ok () if valid, Error `Indefinite_length if invalid. *)
+let check_strictness (s : string) : (unit, error) result =
+  let len = String.length s in
+  let rec check pos =
+    if pos >= len then Ok ()
+    else
+      let byte = Char.code s.[pos] in
+      let major_type = byte lsr 5 in
+      let additional_info = byte land 0x1F in
+
+      (* Check for indefinite-length encoding or break code *)
+      if byte = 0xFF then Error `Indefinite_length (* Break stop code *)
+      else if additional_info = 31 && major_type <= 5 then
+        Error `Indefinite_length (* Indefinite-length indicator *)
+      else
+        (* Calculate the size of this item to skip to next *)
+        let header_size, data_size =
+          if additional_info < 24 then (1, 0)
+          else if additional_info = 24 then (2, 0)
+          else if additional_info = 25 then (3, 0)
+          else if additional_info = 26 then (5, 0)
+          else if additional_info = 27 then (9, 0)
+          else (1, 0)
+          (* reserved/invalid, will be caught by decoder *)
+        in
+        let value_size =
+          match major_type with
+          | 2 | 3 ->
+              (* bytes or text *)
+              if additional_info < 24 then additional_info
+              else if additional_info = 24 && pos + 1 < len then
+                Char.code s.[pos + 1]
+              else if additional_info = 25 && pos + 2 < len then
+                (Char.code s.[pos + 1] lsl 8) lor Char.code s.[pos + 2]
+              else if additional_info = 26 && pos + 4 < len then
+                (Char.code s.[pos + 1] lsl 24)
+                lor (Char.code s.[pos + 2] lsl 16)
+                lor (Char.code s.[pos + 3] lsl 8)
+                lor Char.code s.[pos + 4]
+              else 0 (* will be handled by decoder *)
+          | _ -> 0
+        in
+        let next_pos = pos + header_size + data_size + value_size in
+        (* For complex types (arrays, maps, tags), we need to recurse into contents *)
+        (* For now, we do a simple linear scan which catches the common cases *)
+        check next_pos
+  in
+  check 0
+
+(** Encode a value to DAG-CBOR bytes.
+
+    Floats are encoded as 64-bit IEEE 754 doubles. NaN and Infinity values will
+    raise Invalid_argument. *)
 let encode (v : value) : string =
   let rec to_cbor = function
     | Null -> `Null
     | Bool b -> `Bool b
     | Int i -> `Int (Int64.to_int i) (* CBOR library uses int *)
+    | Float f ->
+        if not (is_valid_float f) then
+          invalid_arg "DAG-CBOR: NaN and Infinity are not allowed"
+        else `Float f
     | String s -> `Text s
     | Bytes b -> `Bytes b
     | Array arr -> `Array (List.map to_cbor arr)
···
   in
   CBOR.Simple.encode (to_cbor v)
 
-(** Decode DAG-CBOR bytes to a value *)
-let decode (s : string) : (value, error) result =
+(** Decode DAG-CBOR bytes to a value.
+
+    @param mode
+      Decoding mode: [Ipld] allows floats, [Atproto] forbids them. Defaults to
+      [Atproto] for backward compatibility.
+    @param strict
+      If true (default), check for DAG-CBOR strictness violations like
+      indefinite-length encoding before decoding. *)
+let decode ?(mode = Atproto) ?(strict = true) (s : string) :
+    (value, error) result =
   let rec from_cbor = function
     | `Null -> Ok Null
     | `Undefined -> Ok Null (* Treat undefined as null *)
···
         if i64 < js_safe_min || i64 > js_safe_max then
           Error `Integer_out_of_range
         else Ok (Int i64)
-    | `Float f ->
-        (* Check if it's actually an integer *)
-        if Float.is_integer f then
-          let i = Int64.of_float f in
-          if i < js_safe_min || i > js_safe_max then Error `Integer_out_of_range
-          else Ok (Int i)
-        else Error `Float_not_allowed
+    | `Float f -> (
+        match mode with
+        | Atproto ->
+            (* AT Protocol: only accept floats that are integers *)
+            if Float.is_integer f then
+              let i = Int64.of_float f in
+              if i < js_safe_min || i > js_safe_max then
+                Error `Integer_out_of_range
+              else Ok (Int i)
+            else Error `Float_not_allowed
+        | Ipld ->
+            (* IPLD: accept floats but reject NaN/Infinity *)
+            if is_nan f then Error `Float_nan_not_allowed
+            else if is_infinite f then Error `Float_infinity_not_allowed
+            else if Float.is_integer f then
+              (* Convert integer-valued floats to Int for consistency *)
+              let i = Int64.of_float f in
+              if i >= js_safe_min && i <= js_safe_max then Ok (Int i)
+              else Ok (Float f)
+            else Ok (Float f))
     | `Text s -> Ok (String s)
     | `Bytes b -> Ok (Bytes b)
     | `Array arr ->
···
     | `Tag (_, _) -> Error `Invalid_tag
     | `Simple _ -> Error (`Decode_error "simple values not supported")
   in
-  try
-    let cbor = CBOR.Simple.decode s in
-    from_cbor cbor
-  with CBOR.Error msg -> Error (`Decode_error msg)
+  (* First check strictness if requested *)
+  match if strict then check_strictness s else Ok () with
+  | Error e -> Error e
+  | Ok () -> (
+      try
+        let cbor = CBOR.Simple.decode s in
+        from_cbor cbor
+      with CBOR.Error msg -> Error (`Decode_error msg))
 
 (** Decode DAG-CBOR bytes, returning the value and any remaining bytes. Useful
-    for decoding concatenated CBOR values (like firehose frames). *)
-let decode_partial (s : string) : (value * string, error) result =
+    for decoding concatenated CBOR values (like firehose frames).
+
+    @param mode
+      Decoding mode: [Ipld] allows floats, [Atproto] forbids them. Defaults to
+      [Atproto] for backward compatibility.
+    @param strict
+      If true (default), check for DAG-CBOR strictness violations like
+      indefinite-length encoding before decoding. Note: strictness check is
+      performed on the entire input, not just the first value. *)
+let decode_partial ?(mode = Atproto) ?(strict = true) (s : string) :
+    (value * string, error) result =
   let rec from_cbor = function
     | `Null -> Ok Null
     | `Undefined -> Ok Null
···
         if i64 < js_safe_min || i64 > js_safe_max then
           Error `Integer_out_of_range
         else Ok (Int i64)
-    | `Float f ->
-        if Float.is_integer f then
-          let i = Int64.of_float f in
-          if i < js_safe_min || i > js_safe_max then Error `Integer_out_of_range
-          else Ok (Int i)
-        else Error `Float_not_allowed
+    | `Float f -> (
+        match mode with
+        | Atproto ->
+            if Float.is_integer f then
+              let i = Int64.of_float f in
+              if i < js_safe_min || i > js_safe_max then
+                Error `Integer_out_of_range
+              else Ok (Int i)
+            else Error `Float_not_allowed
+        | Ipld ->
+            if is_nan f then Error `Float_nan_not_allowed
+            else if is_infinite f then Error `Float_infinity_not_allowed
+            else if Float.is_integer f then
+              let i = Int64.of_float f in
+              if i >= js_safe_min && i <= js_safe_max then Ok (Int i)
+              else Ok (Float f)
+            else Ok (Float f))
     | `Text s -> Ok (String s)
     | `Bytes b -> Ok (Bytes b)
     | `Array arr ->
···
     | `Tag (_, _) -> Error `Invalid_tag
     | `Simple _ -> Error (`Decode_error "simple values not supported")
   in
-  try
-    let cbor, rest = CBOR.Simple.decode_partial s in
-    match from_cbor cbor with Ok v -> Ok (v, rest) | Error e -> Error e
-  with CBOR.Error msg -> Error (`Decode_error msg)
+  (* First check strictness if requested *)
+  match if strict then check_strictness s else Ok () with
+  | Error e -> Error e
+  | Ok () -> (
+      try
+        let cbor, rest = CBOR.Simple.decode_partial s in
+        match from_cbor cbor with Ok v -> Ok (v, rest) | Error e -> Error e
+      with CBOR.Error msg -> Error (`Decode_error msg))
 
-(** Check if a value is valid according to AT Protocol rules *)
+(** Check if a value is valid according to IPLD DAG-CBOR rules. Note: This
+    checks IPLD validity (floats allowed but no NaN/Inf). For AT Protocol
+    validity, also ensure no Float values exist. *)
 let rec is_valid = function
   | Null | Bool _ | String _ | Bytes _ | Link _ -> true
   | Int i -> i >= js_safe_min && i <= js_safe_max
+  | Float f -> is_valid_float f
   | Array arr -> List.for_all is_valid arr
   | Map pairs -> List.for_all (fun (_, v) -> is_valid v) pairs
 
+(** Check if a value is valid for AT Protocol (no floats allowed) *)
+let rec is_atproto_valid = function
+  | Null | Bool _ | String _ | Bytes _ | Link _ -> true
+  | Int i -> i >= js_safe_min && i <= js_safe_max
+  | Float _ -> false (* AT Protocol forbids floats *)
+  | Array arr -> List.for_all is_atproto_valid arr
+  | Map pairs -> List.for_all (fun (_, v) -> is_atproto_valid v) pairs
+
 (** Equality *)
 let rec equal v1 v2 =
   match (v1, v2) with
   | Null, Null -> true
   | Bool b1, Bool b2 -> b1 = b2
   | Int i1, Int i2 -> i1 = i2
+  | Float f1, Float f2 -> f1 = f2
   | String s1, String s2 -> s1 = s2
   | Bytes b1, Bytes b2 -> b1 = b2
   | Array a1, Array a2 ->
···
   | `List of json list
   | `Assoc of (string * json) list ]
 
-(** Convert a DAG-CBOR value to AT Protocol JSON representation.
+(** Convert a DAG-CBOR value to JSON representation.
     - Links become {"$link": "cid-string"}
-    - Bytes become {"$bytes": "base64-string"} *)
+    - Bytes become {"$bytes": "base64-string"}
+    - Floats are represented as JSON floats *)
 let rec to_json (v : value) : json =
   match v with
   | Null -> `Null
   | Bool b -> `Bool b
   | Int i -> `Int (Int64.to_int i)
+  | Float f -> `Float f
   | String s -> `String s
   | Bytes b -> `Assoc [ ("$bytes", `String (base64_encode b)) ]
   | Array arr -> `List (List.map to_json arr)
   | Map pairs -> `Assoc (List.map (fun (k, v) -> (k, to_json v)) pairs)
   | Link cid -> `Assoc [ ("$link", `String (Cid.to_string cid)) ]
 
-(** Convert AT Protocol JSON to DAG-CBOR value.
+(** Convert JSON to DAG-CBOR value.
     - {"$link": "..."} becomes a Link
     - {"$bytes": "..."} becomes Bytes
-    - Floats that are integers are converted to Int *)
-let rec of_json (j : json) : (value, error) result =
+    
+    @param mode Decoding mode: [Ipld] allows floats, [Atproto] forbids them.
+                Defaults to [Atproto] for backward compatibility. *)
+let rec of_json ?(mode = Atproto) (j : json) : (value, error) result =
   match j with
   | `Null -> Ok Null
   | `Bool b -> Ok (Bool b)
···
       let i64 = Int64.of_int i in
       if i64 < js_safe_min || i64 > js_safe_max then Error `Integer_out_of_range
       else Ok (Int i64)
-  | `Float f ->
-      if Float.is_integer f then
-        let i = Int64.of_float f in
-        if i < js_safe_min || i > js_safe_max then Error `Integer_out_of_range
-        else Ok (Int i)
-      else Error `Float_not_allowed
+  | `Float f -> (
+      match mode with
+      | Atproto ->
+          if Float.is_integer f then
+            let i = Int64.of_float f in
+            if i < js_safe_min || i > js_safe_max then
+              Error `Integer_out_of_range
+            else Ok (Int i)
+          else Error `Float_not_allowed
+      | Ipld ->
+          if is_nan f then Error `Float_nan_not_allowed
+          else if is_infinite f then Error `Float_infinity_not_allowed
+          else if Float.is_integer f then
+            let i = Int64.of_float f in
+            if i >= js_safe_min && i <= js_safe_max then Ok (Int i)
+            else Ok (Float f)
+          else Ok (Float f))
   | `String s -> Ok (String s)
   | `List arr ->
       let rec convert_list acc = function
         | [] -> Ok (Array (List.rev acc))
         | x :: xs -> (
-            match of_json x with
+            match of_json ~mode x with
             | Ok v -> convert_list (v :: acc) xs
             | Error e -> Error e)
       in
···
           let rec convert_pairs acc = function
             | [] -> Ok (Map (sort_map (List.rev acc)))
             | (k, v) :: rest -> (
-                match of_json v with
+                match of_json ~mode v with
                 | Ok value -> convert_pairs ((k, value) :: acc) rest
                 | Error e -> Error e)
           in

lib/ipld/dag_json.ml

···
+(** DAG-JSON codec for IPLD.
+
+    DAG-JSON is a JSON serialization format for IPLD data that uses special
+    object structures to represent Links and Bytes:
+    
+    - Links: {"/": "<cid-string>"}
+    - Bytes: {"/": {"bytes": "<base64>"}}
+    
+    This format is used for human-readable IPLD data exchange and debugging.
+    
+    @see <https://ipld.io/specs/codecs/dag-json/spec/> DAG-JSON specification *)
+
+type error =
+  [ `Invalid_cid of string
+  | `Invalid_bytes of string
+  | `Invalid_structure of string
+  | `Unsupported_value of string ]
+(** Error types for DAG-JSON operations *)
+
+(** Pretty-print errors *)
+let pp_error fmt = function
+  | `Invalid_cid msg -> Format.fprintf fmt "invalid CID: %s" msg
+  | `Invalid_bytes msg -> Format.fprintf fmt "invalid bytes: %s" msg
+  | `Invalid_structure msg -> Format.fprintf fmt "invalid structure: %s" msg
+  | `Unsupported_value msg -> Format.fprintf fmt "unsupported value: %s" msg
+
+let error_to_string e = Format.asprintf "%a" pp_error e
+
+type json =
+  [ `Null
+  | `Bool of bool
+  | `Int of int
+  | `Float of float
+  | `String of string
+  | `List of json list
+  | `Assoc of (string * json) list ]
+(** JSON type compatible with common JSON libraries *)
+
+(** Encode bytes to base64 (RFC 4648, no padding) *)
+let base64_encode bytes = Base64.encode_exn ~pad:false bytes
+
+(** Decode base64 to bytes (handles missing padding) *)
+let base64_decode s =
+  match Base64.decode ~pad:false s with
+  | Ok decoded -> Some decoded
+  | Error _ -> None
+
+(** Encode an IPLD value to DAG-JSON.
+    
+    DAG-JSON encoding rules:
+    - Links become {"/": "<cid-string>"}
+    - Bytes become {"/": {"bytes": "<base64>"}}
+    - All other values encode as standard JSON *)
+let rec encode (v : Dag_cbor.value) : json =
+  match v with
+  | Dag_cbor.Null -> `Null
+  | Dag_cbor.Bool b -> `Bool b
+  | Dag_cbor.Int i ->
+      (* Check if it fits in int range *)
+      let i_int = Int64.to_int i in
+      if Int64.of_int i_int = i then `Int i_int else `Float (Int64.to_float i)
+  | Dag_cbor.Float f -> `Float f
+  | Dag_cbor.String s -> `String s
+  | Dag_cbor.Bytes b ->
+      (* Bytes: {"/": {"bytes": "<base64>"}} *)
+      `Assoc [ ("/", `Assoc [ ("bytes", `String (base64_encode b)) ]) ]
+  | Dag_cbor.Array arr -> `List (List.map encode arr)
+  | Dag_cbor.Map pairs -> `Assoc (List.map (fun (k, v) -> (k, encode v)) pairs)
+  | Dag_cbor.Link cid ->
+      (* Link: {"/": "<cid-string>"} *)
+      `Assoc [ ("/", `String (Cid.to_string cid)) ]
+
+(** Check if a JSON object is a DAG-JSON link ({"/": "<cid-string>"}) *)
+let is_link_object = function `Assoc [ ("/", `String _) ] -> true | _ -> false
+
+(** Check if a JSON object is a DAG-JSON bytes ({"/": {"bytes": "<base64>"}}) *)
+let is_bytes_object = function
+  | `Assoc [ ("/", `Assoc [ ("bytes", `String _) ]) ] -> true
+  | _ -> false
+
+(** Decode DAG-JSON to an IPLD value.
+
+    @param mode
+      Decoding mode: [Ipld] allows floats, [Atproto] forbids non-integer floats.
+      Defaults to [Atproto] for AT Protocol compatibility. *)
+let rec decode ?(mode = Dag_cbor.Atproto) (j : json) :
+    (Dag_cbor.value, error) result =
+  match j with
+  | `Null -> Ok Dag_cbor.Null
+  | `Bool b -> Ok (Dag_cbor.Bool b)
+  | `Int i -> Ok (Dag_cbor.Int (Int64.of_int i))
+  | `Float f -> (
+      match mode with
+      | Dag_cbor.Atproto ->
+          if Float.is_integer f then
+            let i = Int64.of_float f in
+            Ok (Dag_cbor.Int i)
+          else
+            Error
+              (`Unsupported_value
+                 "non-integer floats not allowed in AT Protocol")
+      | Dag_cbor.Ipld ->
+          if Float.is_nan f then
+            Error (`Unsupported_value "NaN not allowed in DAG-JSON")
+          else if Float.is_integer f then
+            (* Convert integer-valued floats to Int *)
+            let i = Int64.of_float f in
+            if i >= Dag_cbor.js_safe_min && i <= Dag_cbor.js_safe_max then
+              Ok (Dag_cbor.Int i)
+            else Ok (Dag_cbor.Float f)
+          else Ok (Dag_cbor.Float f))
+  | `String s -> Ok (Dag_cbor.String s)
+  | `List arr ->
+      let rec decode_list acc = function
+        | [] -> Ok (Dag_cbor.Array (List.rev acc))
+        | x :: xs -> (
+            match decode ~mode x with
+            | Ok v -> decode_list (v :: acc) xs
+            | Error e -> Error e)
+      in
+      decode_list [] arr
+  | `Assoc pairs -> decode_object ~mode pairs
+
+and decode_object ~mode pairs =
+  (* Check for special DAG-JSON structures *)
+  match pairs with
+  | [ ("/", `String cid_str) ] -> (
+      (* Link: {"/": "<cid-string>"} *)
+      match Cid.of_string cid_str with
+      | Ok cid -> Ok (Dag_cbor.Link cid)
+      | Error _ -> Error (`Invalid_cid cid_str))
+  | [ ("/", `Assoc [ ("bytes", `String b64) ]) ] -> (
+      (* Bytes: {"/": {"bytes": "<base64>"}} *)
+      match base64_decode b64 with
+      | Some bytes -> Ok (Dag_cbor.Bytes bytes)
+      | None -> Error (`Invalid_bytes ("invalid base64: " ^ b64)))
+  | [ ("/", _) ] ->
+      (* Invalid special object structure *)
+      Error (`Invalid_structure "invalid DAG-JSON special object")
+  | _ ->
+      (* Regular object - check for "/" key which would be ambiguous *)
+      if List.mem_assoc "/" pairs then
+        Error
+          (`Invalid_structure
+             "objects cannot have '/' key (reserved for DAG-JSON)")
+      else
+        let rec decode_pairs acc = function
+          | [] -> Ok (Dag_cbor.Map (Dag_cbor.sort_map (List.rev acc)))
+          | (k, v) :: rest -> (
+              match decode ~mode v with
+              | Ok value -> decode_pairs ((k, value) :: acc) rest
+              | Error e -> Error e)
+        in
+        decode_pairs [] pairs
+
+(** Encode an IPLD value to a DAG-JSON string *)
+let encode_string (v : Dag_cbor.value) : string =
+  let json = encode v in
+  (* Convert to Yojson for string serialization *)
+  let rec to_yojson : json -> Yojson.Basic.t = function
+    | `Null -> `Null
+    | `Bool b -> `Bool b
+    | `Int i -> `Int i
+    | `Float f -> `Float f
+    | `String s -> `String s
+    | `List l -> `List (List.map to_yojson l)
+    | `Assoc pairs -> `Assoc (List.map (fun (k, v) -> (k, to_yojson v)) pairs)
+  in
+  Yojson.Basic.to_string (to_yojson json)
+
+(** Encode an IPLD value to a pretty-printed DAG-JSON string *)
+let encode_string_pretty (v : Dag_cbor.value) : string =
+  let json = encode v in
+  let rec to_yojson : json -> Yojson.Basic.t = function
+    | `Null -> `Null
+    | `Bool b -> `Bool b
+    | `Int i -> `Int i
+    | `Float f -> `Float f
+    | `String s -> `String s
+    | `List l -> `List (List.map to_yojson l)
+    | `Assoc pairs -> `Assoc (List.map (fun (k, v) -> (k, to_yojson v)) pairs)
+  in
+  Yojson.Basic.pretty_to_string (to_yojson json)
+
+(** Decode a DAG-JSON string to an IPLD value *)
+let decode_string ?(mode = Dag_cbor.Atproto) (s : string) :
+    (Dag_cbor.value, error) result =
+  try
+    let yojson = Yojson.Basic.from_string s in
+    let rec of_yojson : Yojson.Basic.t -> json = function
+      | `Null -> `Null
+      | `Bool b -> `Bool b
+      | `Int i -> `Int i
+      | `Float f -> `Float f
+      | `String s -> `String s
+      | `List l -> `List (List.map of_yojson l)
+      | `Assoc pairs -> `Assoc (List.map (fun (k, v) -> (k, of_yojson v)) pairs)
+    in
+    decode ~mode (of_yojson yojson)
+  with Yojson.Json_error msg ->
+    Error (`Invalid_structure ("JSON parse error: " ^ msg))
+
+(** Convert DAG-JSON to DAG-CBOR bytes *)
+let to_dag_cbor ?(mode = Dag_cbor.Atproto) (j : json) : (string, error) result =
+  match decode ~mode j with
+  | Ok value -> Ok (Dag_cbor.encode value)
+  | Error e -> Error e
+
+(** Convert DAG-CBOR bytes to DAG-JSON. Returns a combined error type that
+    includes both DAG-JSON and DAG-CBOR errors. *)
+let of_dag_cbor ?(mode = Dag_cbor.Atproto) (bytes : string) :
+    (json, [ error | `Cbor_error of Dag_cbor.error ]) result =
+  match Dag_cbor.decode ~mode bytes with
+  | Ok value -> Ok (encode value)
+  | Error e -> Error (`Cbor_error e)

test/ipld/test_ipld.ml

···
   Alcotest.(check string)
     "same string" (Cid.to_string cid1) (Cid.to_string cid2)
 
+(* === CIDv0 tests === *)
+
+let test_cidv0_parse () =
+  (* Known CIDv0 from IPFS - "hello world" *)
+  let cidv0_str = "QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u" in
+  match Cid.of_string cidv0_str with
+  | Ok cid ->
+      (* CIDv0 should have version V0 *)
+      Alcotest.(check bool) "is V0" true (Cid.cid_version cid = Cid.V0);
+      (* CIDv0 implicitly uses dag-pb codec *)
+      Alcotest.(check bool) "codec is DagPb" true (Cid.codec cid = Cid.DagPb);
+      (* Hash should be 32 bytes *)
+      Alcotest.(check int) "hash length" 32 (String.length (Cid.hash cid))
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "CIDv0 parse failed: %s" (Cid.error_to_string e))
+
+let test_cidv0_roundtrip () =
+  (* Parse a CIDv0 and convert back to string *)
+  let cidv0_str = "QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u" in
+  match Cid.of_string cidv0_str with
+  | Ok cid ->
+      let encoded = Cid.to_string cid in
+      (* CIDv0 roundtrip should produce same base58btc string *)
+      Alcotest.(check string) "roundtrip" cidv0_str encoded
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "CIDv0 parse failed: %s" (Cid.error_to_string e))
+
+let test_cidv0_binary_roundtrip () =
+  (* Parse CIDv0, encode to bytes, decode, verify equality *)
+  let cidv0_str = "QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u" in
+  match Cid.of_string cidv0_str with
+  | Ok cid -> (
+      let bytes = Cid.to_bytes cid in
+      match Cid.of_bytes bytes with
+      | Ok cid2 ->
+          Alcotest.(check bool) "binary roundtrip" true (Cid.equal cid cid2)
+      | Error e ->
+          Alcotest.fail
+            (Printf.sprintf "binary roundtrip failed: %s"
+               (Cid.error_to_string e)))
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "CIDv0 parse failed: %s" (Cid.error_to_string e))
+
+let test_cidv0_syntax () =
+  (* Test CIDv0 syntax validation *)
+  let valid_v0 = "QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u" in
+  Alcotest.(check bool)
+    "valid CIDv0 syntax" true
+    (Cid.is_valid_cidv0_syntax valid_v0);
+
+  (* AT Protocol syntax validation uses a heuristic (rejects "Qmb" prefix) *)
+  (* CIDv0s not starting with "Qmb" may pass syntax validation but should
+     still fail full parsing as they're not CIDv1 *)
+  let qmb_v0 = "QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR" in
+  Alcotest.(check bool)
+    "AT Protocol rejects Qmb prefix" false
+    (Cid.is_valid_syntax qmb_v0);
+
+  (* is_valid_any_syntax should accept both CIDv0 and CIDv1 *)
+  Alcotest.(check bool)
+    "any syntax accepts CIDv0" true
+    (Cid.is_valid_any_syntax valid_v0);
+
+  (* Invalid CIDv0 (wrong length) *)
+  let invalid_v0 = "QmTooShort" in
+  Alcotest.(check bool)
+    "invalid CIDv0 too short" false
+    (Cid.is_valid_cidv0_syntax invalid_v0)
+
+let test_cidv1_vs_cidv0 () =
+  (* CIDv1 should have version V1 *)
+  let content = "test content" in
+  let cid = Cid.of_dag_cbor content in
+  Alcotest.(check bool) "CIDv1 is V1" true (Cid.cid_version cid = Cid.V1);
+
+  (* CIDv1 string should start with 'b' (base32lower) *)
+  let cid_str = Cid.to_string cid in
+  Alcotest.(check bool) "CIDv1 starts with 'b'" true (cid_str.[0] = 'b')
+
 (* === Test suites === *)
 
 let cid_parsing_tests =
···
     Alcotest.test_case "create raw CID" `Quick test_cid_raw;
     Alcotest.test_case "binary roundtrip" `Quick test_cid_binary_roundtrip;
     Alcotest.test_case "deterministic" `Quick test_deterministic;
+  ]
+
+let cidv0_tests =
+  [
+    Alcotest.test_case "parse CIDv0" `Quick test_cidv0_parse;
+    Alcotest.test_case "CIDv0 roundtrip" `Quick test_cidv0_roundtrip;
+    Alcotest.test_case "CIDv0 binary roundtrip" `Quick
+      test_cidv0_binary_roundtrip;
+    Alcotest.test_case "CIDv0 syntax" `Quick test_cidv0_syntax;
+    Alcotest.test_case "CIDv1 vs CIDv0" `Quick test_cidv1_vs_cidv0;
   ]
 
 (* === DAG-CBOR tests === *)
···
     Alcotest.test_case "JSON $bytes" `Quick test_dag_cbor_json_bytes;
   ]
 
+(* === Float tests (IPLD mode) === *)
+
+let test_float_encode_decode () =
+  (* Test Float encoding and decoding in IPLD mode *)
+  (* Note: Integer-valued floats like 0.0 are converted to Int *)
+  let test_cases =
+    [
+      1.5;
+      -2.5;
+      3.14159265358979;
+      1e10 +. 0.5;
+      (* Add 0.5 to ensure not integer *)
+      1e-10;
+    ]
+  in
+  List.iter
+    (fun f ->
+      let value = Dag_cbor.Float f in
+      let encoded = Dag_cbor.encode value in
+      match Dag_cbor.decode ~mode:Dag_cbor.Ipld encoded with
+      | Ok (Dag_cbor.Float decoded_f) ->
+          Alcotest.(check (float 0.0))
+            (Printf.sprintf "float roundtrip: %f" f)
+            f decoded_f
+      | Ok _ -> Alcotest.fail "expected Float"
+      | Error e ->
+          Alcotest.fail
+            (Printf.sprintf "decode failed: %s" (Dag_cbor.error_to_string e)))
+    test_cases
+
+let test_float_rejected_atproto () =
+  (* Test that non-integer floats are rejected in AT Protocol mode *)
+  let value = Dag_cbor.Float 1.5 in
+  let encoded = Dag_cbor.encode value in
+  match Dag_cbor.decode ~mode:Dag_cbor.Atproto encoded with
+  | Ok _ -> Alcotest.fail "should reject float in AT Protocol mode"
+  | Error `Float_not_allowed -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Float_not_allowed, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_float_integer_converted () =
+  (* Test that integer-valued floats are converted to Int *)
+  let value = Dag_cbor.Float 42.0 in
+  let encoded = Dag_cbor.encode value in
+  (* In both modes, integer floats become Int *)
+  match Dag_cbor.decode ~mode:Dag_cbor.Ipld encoded with
+  | Ok (Dag_cbor.Int i) ->
+      Alcotest.(check int64) "integer float becomes Int" 42L i
+  | Ok _ -> Alcotest.fail "expected Int"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_cbor.error_to_string e))
+
+let test_float_nan_rejected () =
+  (* Test that NaN is rejected *)
+  try
+    let _ = Dag_cbor.encode (Dag_cbor.Float Float.nan) in
+    Alcotest.fail "should reject NaN"
+  with Invalid_argument _ -> ()
+
+let test_float_infinity_rejected () =
+  (* Test that Infinity is rejected *)
+  try
+    let _ = Dag_cbor.encode (Dag_cbor.Float Float.infinity) in
+    Alcotest.fail "should reject Infinity"
+  with Invalid_argument _ -> ()
+
+let test_float_neg_infinity_rejected () =
+  (* Test that -Infinity is rejected *)
+  try
+    let _ = Dag_cbor.encode (Dag_cbor.Float Float.neg_infinity) in
+    Alcotest.fail "should reject -Infinity"
+  with Invalid_argument _ -> ()
+
+let test_float_in_array () =
+  (* Test floats in arrays work in IPLD mode *)
+  let value =
+    Dag_cbor.Array [ Dag_cbor.Float 1.5; Dag_cbor.Int 42L; Dag_cbor.Float 3.14 ]
+  in
+  let encoded = Dag_cbor.encode value in
+  match Dag_cbor.decode ~mode:Dag_cbor.Ipld encoded with
+  | Ok (Dag_cbor.Array [ Dag_cbor.Float f1; Dag_cbor.Int i; Dag_cbor.Float f2 ])
+    ->
+      Alcotest.(check (float 0.0)) "first float" 1.5 f1;
+      Alcotest.(check int64) "integer" 42L i;
+      Alcotest.(check (float 0.0)) "second float" 3.14 f2
+  | Ok _ -> Alcotest.fail "unexpected structure"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_cbor.error_to_string e))
+
+let test_float_in_map () =
+  (* Test floats in maps work in IPLD mode *)
+  let value =
+    Dag_cbor.Map
+      [ ("temperature", Dag_cbor.Float 98.6); ("count", Dag_cbor.Int 5L) ]
+  in
+  let encoded = Dag_cbor.encode value in
+  match Dag_cbor.decode ~mode:Dag_cbor.Ipld encoded with
+  | Ok (Dag_cbor.Map pairs) -> (
+      let temp = List.assoc "temperature" pairs in
+      let count = List.assoc "count" pairs in
+      (match temp with
+      | Dag_cbor.Float f -> Alcotest.(check (float 0.0)) "temperature" 98.6 f
+      | _ -> Alcotest.fail "expected Float for temperature");
+      match count with
+      | Dag_cbor.Int i -> Alcotest.(check int64) "count" 5L i
+      | _ -> Alcotest.fail "expected Int for count")
+  | Ok _ -> Alcotest.fail "unexpected structure"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_cbor.error_to_string e))
+
+let test_float_validity () =
+  (* Test is_valid and is_atproto_valid *)
+  let valid_float = Dag_cbor.Float 3.14 in
+  Alcotest.(check bool)
+    "float is IPLD valid" true
+    (Dag_cbor.is_valid valid_float);
+  Alcotest.(check bool)
+    "float is NOT AT Protocol valid" false
+    (Dag_cbor.is_atproto_valid valid_float);
+
+  let int_val = Dag_cbor.Int 42L in
+  Alcotest.(check bool) "int is IPLD valid" true (Dag_cbor.is_valid int_val);
+  Alcotest.(check bool)
+    "int is AT Protocol valid" true
+    (Dag_cbor.is_atproto_valid int_val)
+
+let test_float_json_ipld () =
+  (* Test JSON conversion in IPLD mode *)
+  let json : Dag_cbor.json = `Float 3.14 in
+  match Dag_cbor.of_json ~mode:Dag_cbor.Ipld json with
+  | Ok (Dag_cbor.Float f) ->
+      Alcotest.(check (float 0.0)) "float from JSON" 3.14 f
+  | Ok _ -> Alcotest.fail "expected Float"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "parse failed: %s" (Dag_cbor.error_to_string e))
+
+let test_float_json_atproto () =
+  (* Test JSON conversion rejects floats in AT Protocol mode *)
+  let json : Dag_cbor.json = `Float 3.14 in
+  match Dag_cbor.of_json ~mode:Dag_cbor.Atproto json with
+  | Ok _ -> Alcotest.fail "should reject float in AT Protocol mode"
+  | Error `Float_not_allowed -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Float_not_allowed, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_float_equality () =
+  (* Test Float equality *)
+  let f1 = Dag_cbor.Float 3.14 in
+  let f2 = Dag_cbor.Float 3.14 in
+  let f3 = Dag_cbor.Float 2.71 in
+  Alcotest.(check bool) "equal floats" true (Dag_cbor.equal f1 f2);
+  Alcotest.(check bool) "different floats" false (Dag_cbor.equal f1 f3);
+  Alcotest.(check bool)
+    "float vs int" false
+    (Dag_cbor.equal (Dag_cbor.Float 1.0) (Dag_cbor.Int 1L))
+
+let float_tests =
+  [
+    Alcotest.test_case "encode/decode" `Quick test_float_encode_decode;
+    Alcotest.test_case "rejected in AT Protocol mode" `Quick
+      test_float_rejected_atproto;
+    Alcotest.test_case "integer float converted to Int" `Quick
+      test_float_integer_converted;
+    Alcotest.test_case "NaN rejected" `Quick test_float_nan_rejected;
+    Alcotest.test_case "Infinity rejected" `Quick test_float_infinity_rejected;
+    Alcotest.test_case "-Infinity rejected" `Quick
+      test_float_neg_infinity_rejected;
+    Alcotest.test_case "float in array" `Quick test_float_in_array;
+    Alcotest.test_case "float in map" `Quick test_float_in_map;
+    Alcotest.test_case "validity checks" `Quick test_float_validity;
+    Alcotest.test_case "JSON IPLD mode" `Quick test_float_json_ipld;
+    Alcotest.test_case "JSON AT Protocol mode" `Quick test_float_json_atproto;
+    Alcotest.test_case "equality" `Quick test_float_equality;
+  ]
+
+(* === CBOR Strictness tests === *)
+
+let test_strictness_indefinite_bytes () =
+  (* Indefinite-length byte string: 0x5F followed by chunks and 0xFF break *)
+  (* 0x5F = major type 2 (bytes) + additional info 31 (indefinite) *)
+  let indefinite_bytes = "\x5F\x41\x61\xFF" in
+  (* 0x5F: start indefinite bytes, 0x41 0x61: 1-byte chunk "a", 0xFF: break *)
+  match Dag_cbor.decode indefinite_bytes with
+  | Ok _ -> Alcotest.fail "should reject indefinite-length bytes"
+  | Error `Indefinite_length -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Indefinite_length, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_indefinite_text () =
+  (* Indefinite-length text string: 0x7F followed by chunks and 0xFF break *)
+  (* 0x7F = major type 3 (text) + additional info 31 (indefinite) *)
+  let indefinite_text = "\x7F\x61\x61\xFF" in
+  (* 0x7F: start indefinite text, 0x61 0x61: 1-char chunk "a", 0xFF: break *)
+  match Dag_cbor.decode indefinite_text with
+  | Ok _ -> Alcotest.fail "should reject indefinite-length text"
+  | Error `Indefinite_length -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Indefinite_length, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_indefinite_array () =
+  (* Indefinite-length array: 0x9F followed by items and 0xFF break *)
+  (* 0x9F = major type 4 (array) + additional info 31 (indefinite) *)
+  let indefinite_array = "\x9F\x01\x02\xFF" in
+  (* 0x9F: start indefinite array, 0x01 0x02: items 1, 2, 0xFF: break *)
+  match Dag_cbor.decode indefinite_array with
+  | Ok _ -> Alcotest.fail "should reject indefinite-length array"
+  | Error `Indefinite_length -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Indefinite_length, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_indefinite_map () =
+  (* Indefinite-length map: 0xBF followed by pairs and 0xFF break *)
+  (* 0xBF = major type 5 (map) + additional info 31 (indefinite) *)
+  let indefinite_map = "\xBF\x61\x61\x01\xFF" in
+  (* 0xBF: start indefinite map, "a": 1, 0xFF: break *)
+  match Dag_cbor.decode indefinite_map with
+  | Ok _ -> Alcotest.fail "should reject indefinite-length map"
+  | Error `Indefinite_length -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Indefinite_length, got: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_break_code () =
+  (* Bare break stop code: 0xFF is not allowed *)
+  let break_code = "\xFF" in
+  match Dag_cbor.decode break_code with
+  | Ok _ -> Alcotest.fail "should reject bare break code"
+  | Error `Indefinite_length -> ()
+  | Error e ->
+      (* Could also be a decode error from the CBOR library *)
+      Alcotest.(check bool)
+        "rejected break code" true
+        (match e with
+        | `Indefinite_length | `Decode_error _ -> true
+        | _ -> false)
+
+let test_strictness_valid_definite () =
+  (* Test that definite-length encoding works fine *)
+  let value = Dag_cbor.Map [ ("a", Dag_cbor.Int 1L); ("b", Dag_cbor.Int 2L) ] in
+  let encoded = Dag_cbor.encode value in
+  match Dag_cbor.decode encoded with
+  | Ok decoded ->
+      Alcotest.(check bool) "valid definite" true (Dag_cbor.equal value decoded)
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "valid definite encoding rejected: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_disabled () =
+  (* Test that ~strict:false bypasses the check *)
+  (* Note: The underlying CBOR library may still reject invalid CBOR *)
+  let value = Dag_cbor.Int 42L in
+  let encoded = Dag_cbor.encode value in
+  match Dag_cbor.decode ~strict:false encoded with
+  | Ok (Dag_cbor.Int i) ->
+      Alcotest.(check int64) "decoded with strict:false" 42L i
+  | Ok _ -> Alcotest.fail "expected Int"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode with strict:false failed: %s"
+           (Dag_cbor.error_to_string e))
+
+let test_strictness_check_function () =
+  (* Test check_strictness function directly *)
+  (* Valid definite encoding *)
+  let valid = "\xa2\x61\x61\x01\x61\x62\x02" in
+  (* {"a": 1, "b": 2} *)
+  Alcotest.(check bool)
+    "valid passes check" true
+    (Result.is_ok (Dag_cbor.check_strictness valid));
+
+  (* Indefinite array *)
+  let invalid = "\x9F\x01\xFF" in
+  Alcotest.(check bool)
+    "indefinite fails check" true
+    (Result.is_error (Dag_cbor.check_strictness invalid))
+
+let strictness_tests =
+  [
+    Alcotest.test_case "reject indefinite bytes" `Quick
+      test_strictness_indefinite_bytes;
+    Alcotest.test_case "reject indefinite text" `Quick
+      test_strictness_indefinite_text;
+    Alcotest.test_case "reject indefinite array" `Quick
+      test_strictness_indefinite_array;
+    Alcotest.test_case "reject indefinite map" `Quick
+      test_strictness_indefinite_map;
+    Alcotest.test_case "reject break code" `Quick test_strictness_break_code;
+    Alcotest.test_case "valid definite encoding" `Quick
+      test_strictness_valid_definite;
+    Alcotest.test_case "strict:false bypasses check" `Quick
+      test_strictness_disabled;
+    Alcotest.test_case "check_strictness function" `Quick
+      test_strictness_check_function;
+  ]
+
 (* === CAR tests === *)
 
 let test_car_roundtrip () =
···
     Alcotest.test_case "invalid data models" `Quick test_data_model_invalid;
   ]
 
+(* === DAG-JSON tests === *)
+
+let test_dag_json_link () =
+  (* Test Link encoding: {"/": "<cid-string>"} *)
+  let cid = Cid.of_dag_cbor "test content" in
+  let value = Dag_cbor.Link cid in
+  let json = Dag_json.encode value in
+  match json with
+  | `Assoc [ ("/", `String cid_str) ] ->
+      Alcotest.(check string) "CID string" (Cid.to_string cid) cid_str
+  | _ -> Alcotest.fail "expected {/: <cid>}"
+
+let test_dag_json_bytes () =
+  (* Test Bytes encoding: {"/": {"bytes": "<base64>"}} *)
+  let bytes = "\x00\x01\x02\x03\xff\xfe" in
+  let value = Dag_cbor.Bytes bytes in
+  let json = Dag_json.encode value in
+  match json with
+  | `Assoc [ ("/", `Assoc [ ("bytes", `String b64) ]) ] -> (
+      (* Decode and verify *)
+      match Base64.decode ~pad:false b64 with
+      | Ok decoded -> Alcotest.(check string) "bytes roundtrip" bytes decoded
+      | Error _ -> Alcotest.fail "invalid base64")
+  | _ -> Alcotest.fail "expected {/: {bytes: <base64>}}"
+
+let test_dag_json_roundtrip () =
+  (* Test full roundtrip: IPLD value -> DAG-JSON -> IPLD value *)
+  let cid = Cid.of_dag_cbor "nested link" in
+  let value =
+    Dag_cbor.Map
+      [
+        ("name", Dag_cbor.String "test");
+        ("count", Dag_cbor.Int 42L);
+        ("data", Dag_cbor.Bytes "\x01\x02\x03");
+        ("ref", Dag_cbor.Link cid);
+        ( "items",
+          Dag_cbor.Array [ Dag_cbor.Int 1L; Dag_cbor.Int 2L; Dag_cbor.Int 3L ]
+        );
+      ]
+  in
+  let json = Dag_json.encode value in
+  match Dag_json.decode json with
+  | Ok decoded ->
+      Alcotest.(check bool)
+        "roundtrip equal" true
+        (Dag_cbor.equal value decoded)
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_string_roundtrip () =
+  (* Test string serialization roundtrip *)
+  let value =
+    Dag_cbor.Map
+      [
+        ("hello", Dag_cbor.String "world");
+        ( "nested",
+          Dag_cbor.Map [ ("a", Dag_cbor.Int 1L); ("b", Dag_cbor.Int 2L) ] );
+      ]
+  in
+  let json_str = Dag_json.encode_string value in
+  match Dag_json.decode_string json_str with
+  | Ok decoded ->
+      Alcotest.(check bool)
+        "string roundtrip" true
+        (Dag_cbor.equal value decoded)
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_decode_link () =
+  (* Test decoding a link from JSON *)
+  let cid_str = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi" in
+  let json : Dag_json.json = `Assoc [ ("/", `String cid_str) ] in
+  match Dag_json.decode json with
+  | Ok (Dag_cbor.Link cid) ->
+      Alcotest.(check string) "CID" cid_str (Cid.to_string cid)
+  | Ok _ -> Alcotest.fail "expected Link"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_decode_bytes () =
+  (* Test decoding bytes from JSON *)
+  let original = "\x00\x01\x02\x03\xff" in
+  let b64 = Base64.encode_exn ~pad:false original in
+  let json : Dag_json.json =
+    `Assoc [ ("/", `Assoc [ ("bytes", `String b64) ]) ]
+  in
+  match Dag_json.decode json with
+  | Ok (Dag_cbor.Bytes decoded) ->
+      Alcotest.(check string) "bytes" original decoded
+  | Ok _ -> Alcotest.fail "expected Bytes"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_invalid_link () =
+  (* Test that invalid CID is rejected *)
+  let json : Dag_json.json = `Assoc [ ("/", `String "not-a-valid-cid") ] in
+  match Dag_json.decode json with
+  | Ok _ -> Alcotest.fail "should reject invalid CID"
+  | Error (`Invalid_cid _) -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Invalid_cid, got: %s"
+           (Dag_json.error_to_string e))
+
+let test_dag_json_invalid_bytes () =
+  (* Test that invalid base64 is rejected *)
+  let json : Dag_json.json =
+    `Assoc [ ("/", `Assoc [ ("bytes", `String "!!!invalid!!!") ]) ]
+  in
+  match Dag_json.decode json with
+  | Ok _ -> Alcotest.fail "should reject invalid base64"
+  | Error (`Invalid_bytes _) -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Invalid_bytes, got: %s"
+           (Dag_json.error_to_string e))
+
+let test_dag_json_reserved_slash () =
+  (* Test that objects with "/" key are rejected (reserved for DAG-JSON) *)
+  let json : Dag_json.json =
+    `Assoc [ ("/", `Int 42); ("other", `String "value") ]
+  in
+  match Dag_json.decode json with
+  | Ok _ -> Alcotest.fail "should reject object with / key"
+  | Error (`Invalid_structure _) -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Invalid_structure, got: %s"
+           (Dag_json.error_to_string e))
+
+let test_dag_json_to_cbor () =
+  (* Test DAG-JSON to DAG-CBOR conversion *)
+  let cid = Cid.of_dag_cbor "test" in
+  let json : Dag_json.json =
+    `Assoc
+      [
+        ("link", `Assoc [ ("/", `String (Cid.to_string cid)) ]);
+        ("value", `Int 42);
+      ]
+  in
+  match Dag_json.to_dag_cbor json with
+  | Ok cbor_bytes -> (
+      (* Decode the CBOR and verify *)
+      match Dag_cbor.decode cbor_bytes with
+      | Ok (Dag_cbor.Map pairs) ->
+          Alcotest.(check int) "pair count" 2 (List.length pairs)
+      | Ok _ -> Alcotest.fail "expected Map"
+      | Error e ->
+          Alcotest.fail
+            (Printf.sprintf "CBOR decode failed: %s"
+               (Dag_cbor.error_to_string e)))
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "to_dag_cbor failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_of_cbor () =
+  (* Test DAG-CBOR to DAG-JSON conversion *)
+  let value =
+    Dag_cbor.Map [ ("a", Dag_cbor.Int 1L); ("b", Dag_cbor.String "hello") ]
+  in
+  let cbor_bytes = Dag_cbor.encode value in
+  match Dag_json.of_dag_cbor cbor_bytes with
+  | Ok json -> (
+      (* Verify structure *)
+      match json with
+      | `Assoc pairs -> Alcotest.(check int) "pair count" 2 (List.length pairs)
+      | _ -> Alcotest.fail "expected Assoc")
+  | Error _ -> Alcotest.fail "of_dag_cbor failed"
+
+let test_dag_json_float_ipld () =
+  (* Test float handling in IPLD mode *)
+  let json : Dag_json.json = `Float 3.14 in
+  match Dag_json.decode ~mode:Dag_cbor.Ipld json with
+  | Ok (Dag_cbor.Float f) -> Alcotest.(check (float 0.001)) "float" 3.14 f
+  | Ok _ -> Alcotest.fail "expected Float"
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "decode failed: %s" (Dag_json.error_to_string e))
+
+let test_dag_json_float_atproto () =
+  (* Test that non-integer floats are rejected in AT Protocol mode *)
+  let json : Dag_json.json = `Float 3.14 in
+  match Dag_json.decode ~mode:Dag_cbor.Atproto json with
+  | Ok _ -> Alcotest.fail "should reject float in AT Protocol mode"
+  | Error (`Unsupported_value _) -> ()
+  | Error e ->
+      Alcotest.fail
+        (Printf.sprintf "expected Unsupported_value, got: %s"
+           (Dag_json.error_to_string e))
+
+let test_dag_json_pretty () =
+  (* Test pretty printing - verify it produces different output than compact *)
+  let value =
+    Dag_cbor.Map
+      [
+        ("key", Dag_cbor.String "value");
+        ( "nested",
+          Dag_cbor.Map [ ("a", Dag_cbor.Int 1L); ("b", Dag_cbor.Int 2L) ] );
+      ]
+  in
+  let compact = Dag_json.encode_string value in
+  let pretty = Dag_json.encode_string_pretty value in
+  (* Pretty should have more whitespace/formatting *)
+  Alcotest.(check bool)
+    "pretty has more chars" true
+    (String.length pretty > String.length compact)
+
+let dag_json_tests =
+  [
+    Alcotest.test_case "encode link" `Quick test_dag_json_link;
+    Alcotest.test_case "encode bytes" `Quick test_dag_json_bytes;
+    Alcotest.test_case "roundtrip" `Quick test_dag_json_roundtrip;
+    Alcotest.test_case "string roundtrip" `Quick test_dag_json_string_roundtrip;
+    Alcotest.test_case "decode link" `Quick test_dag_json_decode_link;
+    Alcotest.test_case "decode bytes" `Quick test_dag_json_decode_bytes;
+    Alcotest.test_case "invalid link" `Quick test_dag_json_invalid_link;
+    Alcotest.test_case "invalid bytes" `Quick test_dag_json_invalid_bytes;
+    Alcotest.test_case "reserved slash key" `Quick test_dag_json_reserved_slash;
+    Alcotest.test_case "to DAG-CBOR" `Quick test_dag_json_to_cbor;
+    Alcotest.test_case "of DAG-CBOR" `Quick test_dag_json_of_cbor;
+    Alcotest.test_case "float IPLD mode" `Quick test_dag_json_float_ipld;
+    Alcotest.test_case "float AT Protocol mode" `Quick
+      test_dag_json_float_atproto;
+    Alcotest.test_case "pretty print" `Quick test_dag_json_pretty;
+  ]
+
 (* === Test suites === *)
 
 let () =
···
     [
       ("cid_parsing", cid_parsing_tests);
       ("cid_creation", cid_creation_tests);
+      ("cidv0", cidv0_tests);
       ("dag_cbor", dag_cbor_tests);
+      ("float", float_tests);
+      ("strictness", strictness_tests);
+      ("dag_json", dag_json_tests);
       ("car", car_tests);
       ("blob", blob_tests);
       ("data_model", data_model_tests);

test/syntax/test_syntax.ml

···
     vectors
 
 let test_cid_invalid () =
+  (* These are CIDs that should be rejected by AT Protocol syntax validation.
+     Note: Some of these (like CIDv0) are valid IPLD CIDs but not accepted in AT Protocol. *)
   let vectors =
     load_test_vectors ~preserve_whitespace:true
       (fixture_dir ^ "/cid_syntax_invalid.txt")
   in
   List.iter
     (fun cid_str ->
-      let result = Atproto_ipld.Cid.of_string cid_str in
+      (* Use is_valid_syntax for AT Protocol syntax validation *)
+      let result = Atproto_ipld.Cid.is_valid_syntax cid_str in
       Alcotest.(check bool)
         (Printf.sprintf "CID invalid: %s" cid_str)
-        true (Result.is_error result))
+        true (not result))
     vectors
 
 (* =========================== Language Tag Tests =========================== *)