feat(schema): J4-J8, H11 — JSON Schema 2020-12 keywords + Path Item refs

J4: prefixItems
J5: patternProperties + propertyNames
J6: unevaluatedProperties + unevaluatedItems
J7: dependentRequired + dependentSchemas
J8: contains + minContains + maxContains + contentEncoding +
    contentMediaType + contentSchema

All landed as typed fields on SchemaDetails, plus the conditional
keywords (`if`/`then`/`else`/`not`), the `$defs` map (J2 partial),
`$comment`, `$schema`, `examples`, `example`, `title`, `deprecated`,
`readOnly`/`writeOnly`. Spec keywords no longer hide in `extra`.

Updated `should_use_dynamic_json` in analysis.rs to read these typed
fields instead of doing string lookups in `details.extra`.

H11: Path Item $ref resolution
  - resolve_path_item follows `$ref: "#/components/pathItems/X"` against
    spec.components.path_items at analysis time so referenced path items
    contribute their operations to the generated client.

All 205 tests still pass; insta snapshots updated for the new typed fields
where they show up in pretty-printed schemas.

Refs #14

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lightsofapollo

src/analysis.rs

@@ -3468,25 +3468,21 @@ impl SchemaAnalyzer {
             .unwrap_or(true);
 
         if no_properties {
-            // Check for constraints that would make this a structured type
+            // Check for constraints that would make this a structured type.
+            // After J5–J8, these are typed fields rather than `extra` lookups.
             let has_structural_constraints =
-                // Has required fields (other than just 'type')
                 details.required.as_ref()
                     .map(|req| req.iter().any(|r| r != "type"))
                     .unwrap_or(false)
-                // Has pattern-based property definitions    
-                || details.extra.contains_key("patternProperties")
-                // Has property name schema
-                || details.extra.contains_key("propertyNames")
-                // Has min/max property constraints
-                || details.extra.contains_key("minProperties")
-                || details.extra.contains_key("maxProperties")
-                // Has specific property dependencies
-                || details.extra.contains_key("dependencies")
-                // Has conditional schemas
-                || details.extra.contains_key("if")
-                || details.extra.contains_key("then")
-                || details.extra.contains_key("else");
+                || details.pattern_properties.is_some()
+                || details.property_names.is_some()
+                || details.min_properties.is_some()
+                || details.max_properties.is_some()
+                || details.dependent_required.is_some()
+                || details.dependent_schemas.is_some()
+                || details.if_schema.is_some()
+                || details.then_schema.is_some()
+                || details.else_schema.is_some();
 
             return !has_structural_constraints;
         }
@@ -3513,7 +3509,10 @@ impl SchemaAnalyzer {
 
         if let Some(paths) = &spec.paths {
             for (path, path_item) in paths {
-                self.ingest_path_item_operations(path, path_item, analysis)?;
+                // H11: Path Item may be a $ref to components/pathItems. Resolve here.
+                let resolved = self.resolve_path_item(path_item, &spec)?;
+                let pi: &crate::openapi::PathItem = resolved.as_ref().unwrap_or(path_item);
+                self.ingest_path_item_operations(path, pi, analysis)?;
             }
         }
         // T4: walk webhooks the same way as paths. Per OAS 3.1+, webhooks are
@@ -3531,6 +3530,37 @@ impl SchemaAnalyzer {
         Ok(())
     }
 
+    /// H11: Resolve a Path Item's `$ref` (3.1+ allows them) against
+    /// `components/pathItems`. Returns Some(resolved) when a ref was followed,
+    /// or None when the input is already inline.
+    fn resolve_path_item(
+        &self,
+        path_item: &crate::openapi::PathItem,
+        spec: &crate::openapi::OpenApiSpec,
+    ) -> Result<Option<crate::openapi::PathItem>> {
+        let Some(reference) = &path_item.reference else {
+            return Ok(None);
+        };
+        let target_name = reference
+            .strip_prefix("#/components/pathItems/")
+            .ok_or_else(|| {
+                GeneratorError::UnresolvedReference(format!(
+                    "Path Item $ref must point at #/components/pathItems/{{name}}, got {reference}"
+                ))
+            })?;
+        let pi = spec
+            .components
+            .as_ref()
+            .and_then(|c| c.path_items.as_ref())
+            .and_then(|map| map.get(target_name))
+            .ok_or_else(|| {
+                GeneratorError::UnresolvedReference(format!(
+                    "Path Item ref {reference} not found in components/pathItems"
+                ))
+            })?;
+        Ok(Some(pi.clone()))
+    }
+
     fn ingest_path_item_operations(
         &mut self,
         path: &str,

src/openapi.rs

@@ -212,8 +212,82 @@ pub struct SchemaDetails {
     #[serde(rename = "maxLength")]
     pub max_length: Option<u64>,
     pub pattern: Option<String>,
-
-    // Extensions and unknown fields
+    #[serde(rename = "exclusiveMinimum")]
+    pub exclusive_minimum: Option<f64>,
+    #[serde(rename = "exclusiveMaximum")]
+    pub exclusive_maximum: Option<f64>,
+    #[serde(rename = "multipleOf")]
+    pub multiple_of: Option<f64>,
+    #[serde(rename = "minItems")]
+    pub min_items: Option<u64>,
+    #[serde(rename = "maxItems")]
+    pub max_items: Option<u64>,
+    #[serde(rename = "uniqueItems")]
+    pub unique_items: Option<bool>,
+    #[serde(rename = "minProperties")]
+    pub min_properties: Option<u64>,
+    #[serde(rename = "maxProperties")]
+    pub max_properties: Option<u64>,
+
+    // JSON Schema 2020-12 array keywords (J4, J8).
+    #[serde(rename = "prefixItems")]
+    pub prefix_items: Option<Vec<Schema>>,
+    pub contains: Option<Box<Schema>>,
+    #[serde(rename = "minContains")]
+    pub min_contains: Option<u64>,
+    #[serde(rename = "maxContains")]
+    pub max_contains: Option<u64>,
+
+    // JSON Schema 2020-12 object keywords (J5, J6, J7).
+    #[serde(rename = "patternProperties")]
+    pub pattern_properties: Option<BTreeMap<String, Schema>>,
+    #[serde(rename = "propertyNames")]
+    pub property_names: Option<Box<Schema>>,
+    #[serde(rename = "unevaluatedProperties")]
+    pub unevaluated_properties: Option<AdditionalProperties>,
+    #[serde(rename = "unevaluatedItems")]
+    pub unevaluated_items: Option<AdditionalProperties>,
+    #[serde(rename = "dependentRequired")]
+    pub dependent_required: Option<BTreeMap<String, Vec<String>>>,
+    #[serde(rename = "dependentSchemas")]
+    pub dependent_schemas: Option<BTreeMap<String, Schema>>,
+
+    // JSON Schema 2020-12 content keywords (J8).
+    #[serde(rename = "contentEncoding")]
+    pub content_encoding: Option<String>,
+    #[serde(rename = "contentMediaType")]
+    pub content_media_type: Option<String>,
+    #[serde(rename = "contentSchema")]
+    pub content_schema: Option<Box<Schema>>,
+
+    // JSON Schema 2020-12 conditional keywords.
+    #[serde(rename = "if")]
+    pub if_schema: Option<Box<Schema>>,
+    #[serde(rename = "then")]
+    pub then_schema: Option<Box<Schema>>,
+    #[serde(rename = "else")]
+    pub else_schema: Option<Box<Schema>>,
+    pub not: Option<Box<Schema>>,
+
+    // 3.0 deprecated annotations now first-class (kept since openai-responses fixture is OAS 3.0).
+    pub title: Option<String>,
+    pub deprecated: Option<bool>,
+    #[serde(rename = "readOnly")]
+    pub read_only: Option<bool>,
+    #[serde(rename = "writeOnly")]
+    pub write_only: Option<bool>,
+    pub examples: Option<Vec<Value>>,
+    pub example: Option<Value>,
+    /// JSON Schema annotation `$comment`.
+    #[serde(rename = "$comment")]
+    pub comment: Option<String>,
+    #[serde(rename = "$schema")]
+    pub schema_keyword: Option<String>,
+    #[serde(rename = "$defs")]
+    pub defs: Option<BTreeMap<String, Schema>>,
+
+    // Extensions and unknown fields. After J5–J8 above this should be x-*-only
+    // for well-formed OAS 3.1+ specs.
     #[serde(flatten)]
     pub extra: BTreeMap<String, Value>,
 }