fix: generate Rust tuples from 2020-12 prefixItems + items:false

When normalizing prefixItems, inject minItems/maxItems matching the
tuple length for closed tuples (items: false). This is required by
typify's tuple detection which checks minItems == maxItems.

Now `prefixItems: [number, number], items: false` correctly generates
a Rust tuple type `(f64, f64)` instead of erroring.

Added runtime test deserializing [42.5, -73.0] as Coordinates tuple.

Author: ndreno

typify-impl/src/normalize.rs

@@ -60,11 +60,28 @@ fn normalize_object(map: &mut Map<String, Value>) {
     }
 
     // 2. prefixItems → items (as array), items → additionalItems
+    //    Also inject minItems/maxItems matching the tuple length so that
+    //    typify's tuple detection works (it requires both to be set).
     if let Some(prefix_items) = map.remove("prefixItems") {
+        let tuple_len = prefix_items.as_array().map(|a| a.len());
+
         // In 2020-12, `items` with `prefixItems` means "additionalItems"
         if let Some(items) = map.remove("items") {
+            // items: false means no additional items beyond the tuple
+            let is_closed = matches!(&items, Value::Bool(false));
             map.insert("additionalItems".to_string(), items);
+
+            // For closed tuples, set min/max to the tuple length
+            if is_closed {
+                if let Some(len) = tuple_len {
+                    map.entry("minItems".to_string())
+                        .or_insert_with(|| Value::Number(serde_json::Number::from(len)));
+                    map.entry("maxItems".to_string())
+                        .or_insert_with(|| Value::Number(serde_json::Number::from(len)));
+                }
+            }
         }
+
         map.insert("items".to_string(), prefix_items);
     }
 
@@ -259,6 +276,25 @@ mod tests {
             json!([{ "type": "string" }, { "type": "integer" }])
         );
         assert_eq!(schema["additionalItems"], json!(false));
+        // Closed tuple should have minItems/maxItems set for typify tuple detection
+        assert_eq!(schema["minItems"], json!(2));
+        assert_eq!(schema["maxItems"], json!(2));
+    }
+
+    #[test]
+    fn test_prefix_items_open_no_min_max() {
+        // When items is not false (open tuple), don't inject min/max
+        let mut schema = json!({
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "array",
+            "prefixItems": [
+                { "type": "string" }
+            ],
+            "items": { "type": "integer" }
+        });
+        normalize_schema(&mut schema);
+        assert!(schema.get("minItems").is_none());
+        assert!(schema.get("maxItems").is_none());
     }
 
     #[test]

typify-test/build.rs

@@ -267,13 +267,22 @@ fn main() {
                 "Tag": {
                     "type": "string",
                     "minLength": 1
+                },
+                "Coordinates": {
+                    "type": "array",
+                    "prefixItems": [
+                        { "type": "number" },
+                        { "type": "number" }
+                    ],
+                    "items": false
                 }
             },
             "type": "object",
             "title": "Location",
             "properties": {
                 "address": { "$ref": "#/$defs/Address" },
-                "tag": { "$ref": "#/$defs/Tag" }
+                "tag": { "$ref": "#/$defs/Tag" },
+                "coords": { "$ref": "#/$defs/Coordinates" }
             },
             "required": ["address"],
             "dependentRequired": {

typify-test/src/main.rs

@@ -325,6 +325,16 @@ fn test_2020_12_defs_and_dependent_required() {
     assert_eq!(v.address.city, "Anytown");
 }
 
+#[test]
+fn test_2020_12_prefix_items_tuple() {
+    // prefixItems + items:false should generate a proper Rust tuple
+    let json = r#"[42.5, -73.0]"#;
+    let v: schema_2020_12::Coordinates = serde_json::from_str(json).unwrap();
+    // Coordinates is a newtype around (f64, f64)
+    assert_eq!((v.0).0, 42.5);
+    assert_eq!((v.0).1, -73.0);
+}
+
 // --- External $ref support ---
 
 #[test]