xberg 1.2.5 → 1.2.6

data/ext/xberg_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:88d2135df85c592f02269aceb1caa207be8b22378d55c8bd717ffaa3f5359d86
+// alef:hash:f96e7fa37ad41175262a0e7e7e6cc03473ea5e795d7cf76e5118687cbeff2554
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -6006,8 +6006,12 @@ impl DbfMetadata {
 #[magnus::wrap(class = "Xberg::DeepseekOcrBackendOptions")]
 pub struct DeepseekOcrBackendOptions {
     model_path: Option<String>,
+    model_id: Option<String>,
+    hf_revision: Option<String>,
+    cache_dir: Option<String>,
     device: Option<CandleDevicePreference>,
     version: Option<u32>,
+    dtype: Option<CandleDeepseekOcrDtype>,
 }
 
 #[cfg(feature = "candle-ocr")]
@@ -6074,6 +6078,33 @@ impl DeepseekOcrBackendOptions {
                 })?),
                 None => None,
             },
+            model_id: match kwargs.get(ruby.to_symbol("model_id")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `model_id`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            hf_revision: match kwargs.get(ruby.to_symbol("hf_revision")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `hf_revision`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            cache_dir: match kwargs.get(ruby.to_symbol("cache_dir")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(String::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `cache_dir`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             device: match kwargs.get(ruby.to_symbol("device")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(CandleDevicePreference::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -6092,6 +6123,15 @@ impl DeepseekOcrBackendOptions {
                 })?),
                 None => None,
             },
+            dtype: match kwargs.get(ruby.to_symbol("dtype")).filter(|v| !v.is_nil()) {
+                Some(v) => Some(CandleDeepseekOcrDtype::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `dtype`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -6099,6 +6139,18 @@ impl DeepseekOcrBackendOptions {
         self.model_path.clone()
     }
 
+    fn model_id(&self) -> Option<String> {
+        self.model_id.clone()
+    }
+
+    fn hf_revision(&self) -> Option<String> {
+        self.hf_revision.clone()
+    }
+
+    fn cache_dir(&self) -> Option<String> {
+        self.cache_dir.clone()
+    }
+
     fn device(&self) -> Option<CandleDevicePreference> {
         self.device.clone()
     }
@@ -6106,6 +6158,10 @@ impl DeepseekOcrBackendOptions {
     fn version(&self) -> Option<u32> {
         self.version
     }
+
+    fn dtype(&self) -> Option<CandleDeepseekOcrDtype> {
+        self.dtype.clone()
+    }
 }
 
 #[cfg(feature = "api")]
@@ -12691,6 +12747,202 @@ impl ExtractionConfig {
         core_self.needs_image_data()
     }
 
+    fn runs_ocr_on_embedded_images(&self) -> bool {
+        #[allow(clippy::needless_update)]
+        let core_self = xberg::ExtractionConfig {
+            mime_detection_policy: self.mime_detection_policy.clone().into(),
+
+            use_cache: self.use_cache,
+
+            enable_quality_processing: self.enable_quality_processing,
+
+            ocr: self.ocr.clone().map(Into::into),
+
+            force_ocr: self.force_ocr,
+
+            ocr_strategy: self.ocr_strategy.clone().into(),
+
+            force_ocr_pages: self.force_ocr_pages.clone(),
+
+            disable_ocr: self.disable_ocr,
+
+            chunking: self.chunking.clone().map(Into::into),
+
+            content_filter: self.content_filter.clone().map(Into::into),
+
+            images: self.images.clone().map(Into::into),
+
+            token_reduction: self.token_reduction.clone().map(Into::into),
+
+            language_detection: self.language_detection.clone().map(Into::into),
+
+            pages: self.pages.clone().map(Into::into),
+
+            postprocessor: self.postprocessor.clone().map(Into::into),
+
+            extraction_timeout_secs: self.extraction_timeout_secs,
+
+            max_concurrent_extractions: self.max_concurrent_extractions,
+
+            result_format: self.result_format.clone().into(),
+
+            security_limits: self.security_limits.clone().map(Into::into),
+
+            max_embedded_file_bytes: self.max_embedded_file_bytes,
+
+            output_format: self.output_format.clone().into(),
+
+            escape_markdown: self.escape_markdown,
+
+            table_anchors: self.table_anchors,
+
+            jupyter_cell_rendering: self.jupyter_cell_rendering.clone().into(),
+
+            apply_notebook_cell_tags: self.apply_notebook_cell_tags,
+
+            use_layout_for_markdown: self.use_layout_for_markdown,
+
+            include_document_structure: self.include_document_structure,
+
+            acceleration: self.acceleration.clone().map(Into::into),
+
+            cache_namespace: self.cache_namespace.clone(),
+
+            cache_ttl_secs: self.cache_ttl_secs,
+
+            email: self.email.clone().map(Into::into),
+
+            csv: self.csv.clone().map(Into::into),
+
+            geojson: self.geojson.clone().map(Into::into),
+
+            concurrency: self.concurrency.clone().map(Into::into),
+
+            url: self.url.clone().into(),
+
+            max_archive_depth: self.max_archive_depth,
+
+            structured_extraction: self.structured_extraction.clone().map(Into::into),
+
+            ner: self.ner.clone().map(Into::into),
+
+            redaction: self.redaction.clone().map(Into::into),
+
+            summarization: self.summarization.clone().map(Into::into),
+
+            translation: self.translation.clone().map(Into::into),
+
+            page_classification: self.page_classification.clone().map(Into::into),
+
+            chunk_classification: self.chunk_classification.clone().map(Into::into),
+
+            captioning: self.captioning.clone().map(Into::into),
+
+            qr_codes: self.qr_codes,
+
+            ..Default::default()
+        };
+        core_self.runs_ocr_on_embedded_images()
+    }
+
+    fn wants_own_bytes_in_result(&self) -> bool {
+        #[allow(clippy::needless_update)]
+        let core_self = xberg::ExtractionConfig {
+            mime_detection_policy: self.mime_detection_policy.clone().into(),
+
+            use_cache: self.use_cache,
+
+            enable_quality_processing: self.enable_quality_processing,
+
+            ocr: self.ocr.clone().map(Into::into),
+
+            force_ocr: self.force_ocr,
+
+            ocr_strategy: self.ocr_strategy.clone().into(),
+
+            force_ocr_pages: self.force_ocr_pages.clone(),
+
+            disable_ocr: self.disable_ocr,
+
+            chunking: self.chunking.clone().map(Into::into),
+
+            content_filter: self.content_filter.clone().map(Into::into),
+
+            images: self.images.clone().map(Into::into),
+
+            token_reduction: self.token_reduction.clone().map(Into::into),
+
+            language_detection: self.language_detection.clone().map(Into::into),
+
+            pages: self.pages.clone().map(Into::into),
+
+            postprocessor: self.postprocessor.clone().map(Into::into),
+
+            extraction_timeout_secs: self.extraction_timeout_secs,
+
+            max_concurrent_extractions: self.max_concurrent_extractions,
+
+            result_format: self.result_format.clone().into(),
+
+            security_limits: self.security_limits.clone().map(Into::into),
+
+            max_embedded_file_bytes: self.max_embedded_file_bytes,
+
+            output_format: self.output_format.clone().into(),
+
+            escape_markdown: self.escape_markdown,
+
+            table_anchors: self.table_anchors,
+
+            jupyter_cell_rendering: self.jupyter_cell_rendering.clone().into(),
+
+            apply_notebook_cell_tags: self.apply_notebook_cell_tags,
+
+            use_layout_for_markdown: self.use_layout_for_markdown,
+
+            include_document_structure: self.include_document_structure,
+
+            acceleration: self.acceleration.clone().map(Into::into),
+
+            cache_namespace: self.cache_namespace.clone(),
+
+            cache_ttl_secs: self.cache_ttl_secs,
+
+            email: self.email.clone().map(Into::into),
+
+            csv: self.csv.clone().map(Into::into),
+
+            geojson: self.geojson.clone().map(Into::into),
+
+            concurrency: self.concurrency.clone().map(Into::into),
+
+            url: self.url.clone().into(),
+
+            max_archive_depth: self.max_archive_depth,
+
+            structured_extraction: self.structured_extraction.clone().map(Into::into),
+
+            ner: self.ner.clone().map(Into::into),
+
+            redaction: self.redaction.clone().map(Into::into),
+
+            summarization: self.summarization.clone().map(Into::into),
+
+            translation: self.translation.clone().map(Into::into),
+
+            page_classification: self.page_classification.clone().map(Into::into),
+
+            chunk_classification: self.chunk_classification.clone().map(Into::into),
+
+            captioning: self.captioning.clone().map(Into::into),
+
+            qr_codes: self.qr_codes,
+
+            ..Default::default()
+        };
+        core_self.wants_own_bytes_in_result()
+    }
+
     fn needs_image_processing(&self) -> bool {
         #[allow(clippy::needless_update)]
         let core_self = xberg::ExtractionConfig {
@@ -22794,6 +23046,8 @@ pub struct OcrQualityThresholds {
     min_undecodable_ratio: f64,
     enable_provenance_ocr_routing: bool,
     min_provenance_fallback_ratio: f64,
+    enable_plausibility_ocr_routing: bool,
+    min_reliable_language_chunk_ratio: f64,
 }
 
 unsafe impl IntoValueFromNative for OcrQualityThresholds {}
@@ -23065,6 +23319,24 @@ impl OcrQualityThresholds {
                 })?,
                 None => 0.5,
             },
+            enable_plausibility_ocr_routing: match kwargs.get(ruby.to_symbol("enable_plausibility_ocr_routing")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `enable_plausibility_ocr_routing`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
+            min_reliable_language_chunk_ratio: match kwargs.get(ruby.to_symbol("min_reliable_language_chunk_ratio")) {
+                Some(v) => f64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `min_reliable_language_chunk_ratio`: {}", e),
+                    )
+                })?,
+                None => 0.1,
+            },
         })
     }
 
@@ -23163,6 +23435,14 @@ impl OcrQualityThresholds {
     fn min_provenance_fallback_ratio(&self) -> f64 {
         self.min_provenance_fallback_ratio
     }
+
+    fn enable_plausibility_ocr_routing(&self) -> bool {
+        self.enable_plausibility_ocr_routing
+    }
+
+    fn min_reliable_language_chunk_ratio(&self) -> f64 {
+        self.min_reliable_language_chunk_ratio
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -26652,6 +26932,8 @@ pub struct PdfMetadata {
     page_count: Option<u32>,
     scanned_confidence: Option<f32>,
     scanned_pages: Option<Vec<u32>>,
+    fabricated_text_pages: Option<Vec<u32>>,
+    implausible_text_pages: Option<Vec<u32>>,
     layout_gated_pages: Option<Vec<u32>>,
     layout_gate_reasons: Option<Vec<String>>,
 }
@@ -26774,6 +27056,30 @@ impl PdfMetadata {
                 })?),
                 None => None,
             },
+            fabricated_text_pages: match kwargs
+                .get(ruby.to_symbol("fabricated_text_pages"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(<Vec<u32>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `fabricated_text_pages`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
+            implausible_text_pages: match kwargs
+                .get(ruby.to_symbol("implausible_text_pages"))
+                .filter(|v| !v.is_nil())
+            {
+                Some(v) => Some(<Vec<u32>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `implausible_text_pages`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
             layout_gated_pages: match kwargs.get(ruby.to_symbol("layout_gated_pages")).filter(|v| !v.is_nil()) {
                 Some(v) => Some(<Vec<u32>>::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -26830,6 +27136,14 @@ impl PdfMetadata {
         self.scanned_pages.clone()
     }
 
+    fn fabricated_text_pages(&self) -> Option<Vec<u32>> {
+        self.fabricated_text_pages.clone()
+    }
+
+    fn implausible_text_pages(&self) -> Option<Vec<u32>> {
+        self.implausible_text_pages.clone()
+    }
+
     fn layout_gated_pages(&self) -> Option<Vec<u32>> {
         self.layout_gated_pages.clone()
     }
@@ -35309,7 +35623,8 @@ impl magnus::IntoValue for AnnotationKind {
 
 impl magnus::TryConvert for AnnotationKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -35341,9 +35656,10 @@ impl magnus::TryConvert for AnnotationKind {
 
 unsafe impl IntoValueFromNative for AnnotationKind {}
 unsafe impl TryConvertOwned for AnnotationKind {}
+
 impl AnnotationKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AssetCategory {
     Document,
@@ -35384,7 +35700,14 @@ impl magnus::IntoValue for AssetCategory {
 
 impl magnus::TryConvert for AssetCategory {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35441,7 +35764,8 @@ impl magnus::IntoValue for AuthConfig {
 
 impl magnus::TryConvert for AuthConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -35473,9 +35797,10 @@ impl magnus::TryConvert for AuthConfig {
 
 unsafe impl IntoValueFromNative for AuthConfig {}
 unsafe impl TryConvertOwned for AuthConfig {}
+
 impl AuthConfig {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BlockType {
     Paragraph,
@@ -35528,7 +35853,14 @@ impl magnus::IntoValue for BlockType {
 
 impl magnus::TryConvert for BlockType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35560,7 +35892,7 @@ impl magnus::TryConvert for BlockType {
 unsafe impl IntoValueFromNative for BlockType {}
 unsafe impl TryConvertOwned for BlockType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BoundaryReason {
     Start,
@@ -35591,7 +35923,14 @@ impl magnus::IntoValue for BoundaryReason {
 
 impl magnus::TryConvert for BoundaryReason {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35612,7 +35951,7 @@ impl magnus::TryConvert for BoundaryReason {
 unsafe impl IntoValueFromNative for BoundaryReason {}
 unsafe impl TryConvertOwned for BoundaryReason {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BrowserBackend {
     Chromiumoxide,
@@ -35637,7 +35976,14 @@ impl magnus::IntoValue for BrowserBackend {
 
 impl magnus::TryConvert for BrowserBackend {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35655,7 +36001,7 @@ impl magnus::TryConvert for BrowserBackend {
 unsafe impl IntoValueFromNative for BrowserBackend {}
 unsafe impl TryConvertOwned for BrowserBackend {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BrowserMode {
     Auto,
@@ -35684,7 +36030,14 @@ impl magnus::IntoValue for BrowserMode {
 
 impl magnus::TryConvert for BrowserMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35704,7 +36057,7 @@ impl magnus::TryConvert for BrowserMode {
 unsafe impl IntoValueFromNative for BrowserMode {}
 unsafe impl TryConvertOwned for BrowserMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum BrowserWait {
     NetworkIdle,
@@ -35731,7 +36084,14 @@ impl magnus::IntoValue for BrowserWait {
 
 impl magnus::TryConvert for BrowserWait {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35750,7 +36110,7 @@ impl magnus::TryConvert for BrowserWait {
 unsafe impl IntoValueFromNative for BrowserWait {}
 unsafe impl TryConvertOwned for BrowserWait {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CallMode {
     TextOnly,
@@ -35777,7 +36137,14 @@ impl magnus::IntoValue for CallMode {
 
 impl magnus::TryConvert for CallMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35796,7 +36163,63 @@ impl magnus::TryConvert for CallMode {
 unsafe impl IntoValueFromNative for CallMode {}
 unsafe impl TryConvertOwned for CallMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum CandleDeepseekOcrDtype {
+    Auto,
+    F32,
+    F16,
+    Bf16,
+}
+
+impl Default for CandleDeepseekOcrDtype {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+impl magnus::IntoValue for CandleDeepseekOcrDtype {
+    fn into_value_with(self, handle: &Ruby) -> magnus::Value {
+        let sym = match self {
+            CandleDeepseekOcrDtype::Auto => "auto",
+            CandleDeepseekOcrDtype::F32 => "f32",
+            CandleDeepseekOcrDtype::F16 => "f16",
+            CandleDeepseekOcrDtype::Bf16 => "bf16",
+        };
+        handle.to_symbol(sym).into_value_with(handle)
+    }
+}
+
+impl magnus::TryConvert for CandleDeepseekOcrDtype {
+    fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
+        // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
+        // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
+        // existing consumer code written in any of those styles keep working.
+        match s.as_str() {
+            "auto" | "Auto" => Ok(CandleDeepseekOcrDtype::Auto),
+            "f32" | "F32" => Ok(CandleDeepseekOcrDtype::F32),
+            "f16" | "F16" => Ok(CandleDeepseekOcrDtype::F16),
+            "bf16" | "Bf16" => Ok(CandleDeepseekOcrDtype::Bf16),
+            other => Err(magnus::Error::new(
+                unsafe { Ruby::get_unchecked() }.exception_arg_error(),
+                format!("invalid CandleDeepseekOcrDtype value: {other}"),
+            )),
+        }
+    }
+}
+
+unsafe impl IntoValueFromNative for CandleDeepseekOcrDtype {}
+unsafe impl TryConvertOwned for CandleDeepseekOcrDtype {}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum CandleDevicePreference {
     Auto,
@@ -35825,7 +36248,14 @@ impl magnus::IntoValue for CandleDevicePreference {
 
 impl magnus::TryConvert for CandleDevicePreference {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35845,7 +36275,7 @@ impl magnus::TryConvert for CandleDevicePreference {
 unsafe impl IntoValueFromNative for CandleDevicePreference {}
 unsafe impl TryConvertOwned for CandleDevicePreference {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum CandleTrocrVariant {
     BasePrinted,
@@ -35874,7 +36304,14 @@ impl magnus::IntoValue for CandleTrocrVariant {
 
 impl magnus::TryConvert for CandleTrocrVariant {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -35919,7 +36356,8 @@ impl magnus::IntoValue for ChunkSizing {
 
 impl magnus::TryConvert for ChunkSizing {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -35951,9 +36389,10 @@ impl magnus::TryConvert for ChunkSizing {
 
 unsafe impl IntoValueFromNative for ChunkSizing {}
 unsafe impl TryConvertOwned for ChunkSizing {}
+
 impl ChunkSizing {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ChunkType {
     Heading,
@@ -36006,7 +36445,14 @@ impl magnus::IntoValue for ChunkType {
 
 impl magnus::TryConvert for ChunkType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36038,7 +36484,7 @@ impl magnus::TryConvert for ChunkType {
 unsafe impl IntoValueFromNative for ChunkType {}
 unsafe impl TryConvertOwned for ChunkType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ChunkerType {
     Text,
@@ -36067,7 +36513,14 @@ impl magnus::IntoValue for ChunkerType {
 
 impl magnus::TryConvert for ChunkerType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36116,7 +36569,8 @@ impl magnus::IntoValue for ChunkingReason {
 
 impl magnus::TryConvert for ChunkingReason {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -36148,9 +36602,10 @@ impl magnus::TryConvert for ChunkingReason {
 
 unsafe impl IntoValueFromNative for ChunkingReason {}
 unsafe impl TryConvertOwned for ChunkingReason {}
+
 impl ChunkingReason {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum CodeBlockStyle {
     Indented,
     Backticks,
@@ -36176,7 +36631,14 @@ impl magnus::IntoValue for CodeBlockStyle {
 
 impl magnus::TryConvert for CodeBlockStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36195,7 +36657,7 @@ impl magnus::TryConvert for CodeBlockStyle {
 unsafe impl IntoValueFromNative for CodeBlockStyle {}
 unsafe impl TryConvertOwned for CodeBlockStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CodeContentMode {
     Chunks,
@@ -36222,7 +36684,14 @@ impl magnus::IntoValue for CodeContentMode {
 
 impl magnus::TryConvert for CodeContentMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36241,7 +36710,7 @@ impl magnus::TryConvert for CodeContentMode {
 unsafe impl IntoValueFromNative for CodeContentMode {}
 unsafe impl TryConvertOwned for CodeContentMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CodeDataNodeKind {
     KeyValue,
@@ -36268,7 +36737,14 @@ impl magnus::IntoValue for CodeDataNodeKind {
 
 impl magnus::TryConvert for CodeDataNodeKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36349,7 +36825,7 @@ impl ConfidenceSemantics {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ContentFilterKind {
     Bm25,
@@ -36372,7 +36848,14 @@ impl magnus::IntoValue for ContentFilterKind {
 
 impl magnus::TryConvert for ContentFilterKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36389,7 +36872,7 @@ impl magnus::TryConvert for ContentFilterKind {
 unsafe impl IntoValueFromNative for ContentFilterKind {}
 unsafe impl TryConvertOwned for ContentFilterKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ContentLayer {
     Body,
@@ -36418,7 +36901,14 @@ impl magnus::IntoValue for ContentLayer {
 
 impl magnus::TryConvert for ContentLayer {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36438,7 +36928,7 @@ impl magnus::TryConvert for ContentLayer {
 unsafe impl IntoValueFromNative for ContentLayer {}
 unsafe impl TryConvertOwned for ContentLayer {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum CrawlStrategyKind {
     Bfs,
@@ -36467,7 +36957,14 @@ impl magnus::IntoValue for CrawlStrategyKind {
 
 impl magnus::TryConvert for CrawlStrategyKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36512,17 +37009,6 @@ pub enum CredentialProviderConfig {
     },
 }
 
-impl Default for CredentialProviderConfig {
-    fn default() -> Self {
-        Self::AzureAd {
-            tenant_id: Default::default(),
-            client_id: Default::default(),
-            client_secret: Default::default(),
-            scope: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for CredentialProviderConfig {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -36534,7 +37020,8 @@ impl magnus::IntoValue for CredentialProviderConfig {
 
 impl magnus::TryConvert for CredentialProviderConfig {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -36566,6 +37053,7 @@ impl magnus::TryConvert for CredentialProviderConfig {
 
 unsafe impl IntoValueFromNative for CredentialProviderConfig {}
 unsafe impl TryConvertOwned for CredentialProviderConfig {}
+
 impl CredentialProviderConfig {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -36594,7 +37082,8 @@ impl magnus::IntoValue for DiffLine {
 
 impl magnus::TryConvert for DiffLine {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -36626,6 +37115,7 @@ impl magnus::TryConvert for DiffLine {
 
 unsafe impl IntoValueFromNative for DiffLine {}
 unsafe impl TryConvertOwned for DiffLine {}
+
 impl DiffLine {
     pub fn context(&self) -> Option<&String> {
         match self {
@@ -36647,7 +37137,7 @@ impl DiffLine {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum DocumentContentEncoding {
     Base64,
@@ -36670,7 +37160,14 @@ impl magnus::IntoValue for DocumentContentEncoding {
 
 impl magnus::TryConvert for DocumentContentEncoding {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36687,7 +37184,7 @@ impl magnus::TryConvert for DocumentContentEncoding {
 unsafe impl IntoValueFromNative for DocumentContentEncoding {}
 unsafe impl TryConvertOwned for DocumentContentEncoding {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ElementType {
     Title,
@@ -36732,7 +37229,14 @@ impl magnus::IntoValue for ElementType {
 
 impl magnus::TryConvert for ElementType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36766,7 +37270,7 @@ unsafe impl TryConvertOwned for ElementType {}
 pub enum EmbeddingModelType {
     Preset { name: String },
     Custom { model_id: String, dimensions: usize },
-    Llm { llm: LlmConfig },
+    Llm { llm: Box<LlmConfig> },
     Plugin { name: String },
 }
 
@@ -36789,7 +37293,8 @@ impl magnus::IntoValue for EmbeddingModelType {
 
 impl magnus::TryConvert for EmbeddingModelType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -36821,9 +37326,10 @@ impl magnus::TryConvert for EmbeddingModelType {
 
 unsafe impl IntoValueFromNative for EmbeddingModelType {}
 unsafe impl TryConvertOwned for EmbeddingModelType {}
+
 impl EmbeddingModelType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum EmbeddingsEmbeddingBackend {
     Onnx,
@@ -36848,7 +37354,14 @@ impl magnus::IntoValue for EmbeddingsEmbeddingBackend {
 
 impl magnus::TryConvert for EmbeddingsEmbeddingBackend {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36931,7 +37444,7 @@ impl magnus::TryConvert for EntityCategory {
 unsafe impl IntoValueFromNative for EntityCategory {}
 unsafe impl TryConvertOwned for EntityCategory {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ExecutionProviderType {
     Auto,
@@ -36962,7 +37475,14 @@ impl magnus::IntoValue for ExecutionProviderType {
 
 impl magnus::TryConvert for ExecutionProviderType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -36983,7 +37503,7 @@ impl magnus::TryConvert for ExecutionProviderType {
 unsafe impl IntoValueFromNative for ExecutionProviderType {}
 unsafe impl TryConvertOwned for ExecutionProviderType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ExtractInputKind {
     Bytes,
@@ -37008,7 +37528,14 @@ impl magnus::IntoValue for ExtractInputKind {
 
 impl magnus::TryConvert for ExtractInputKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37026,7 +37553,7 @@ impl magnus::TryConvert for ExtractInputKind {
 unsafe impl IntoValueFromNative for ExtractInputKind {}
 unsafe impl TryConvertOwned for ExtractInputKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ExtractionMethod {
     Native,
@@ -37053,7 +37580,14 @@ impl magnus::IntoValue for ExtractionMethod {
 
 impl magnus::TryConvert for ExtractionMethod {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37072,7 +37606,7 @@ impl magnus::TryConvert for ExtractionMethod {
 unsafe impl IntoValueFromNative for ExtractionMethod {}
 unsafe impl TryConvertOwned for ExtractionMethod {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum FormFieldType {
     Text,
@@ -37107,7 +37641,14 @@ impl magnus::IntoValue for FormFieldType {
 
 impl magnus::TryConvert for FormFieldType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37140,7 +37681,7 @@ pub enum FormatMetadata {
     },
     Docx {
         #[serde(flatten)]
-        _0: DocxMetadata,
+        _0: Box<DocxMetadata>,
     },
     Excel {
         #[serde(flatten)]
@@ -37172,7 +37713,7 @@ pub enum FormatMetadata {
     },
     Html {
         #[serde(flatten)]
-        _0: HtmlMetadata,
+        _0: Box<HtmlMetadata>,
     },
     Ocr {
         #[serde(flatten)]
@@ -37237,7 +37778,92 @@ impl magnus::IntoValue for FormatMetadata {
 
 impl magnus::TryConvert for FormatMetadata {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?;
+        if class_name.as_deref() == Some("Xberg::FormatMetadataPdf") {
+            let payload: PdfMetadata = val.funcall("value", ())?;
+            return Ok(Self::Pdf { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataDocx") {
+            let payload: DocxMetadata = val.funcall("value", ())?;
+            return Ok(Self::Docx { _0: Box::new(payload) });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataExcel") {
+            let payload: ExcelMetadata = val.funcall("value", ())?;
+            return Ok(Self::Excel { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataEmail") {
+            let payload: EmailMetadata = val.funcall("value", ())?;
+            return Ok(Self::Email { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataPptx") {
+            let payload: PptxMetadata = val.funcall("value", ())?;
+            return Ok(Self::Pptx { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataArchive") {
+            let payload: ArchiveMetadata = val.funcall("value", ())?;
+            return Ok(Self::Archive { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataImage") {
+            let payload: ImageMetadata = val.funcall("value", ())?;
+            return Ok(Self::Image { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataXml") {
+            let payload: XmlMetadata = val.funcall("value", ())?;
+            return Ok(Self::Xml { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataText") {
+            let payload: TextMetadata = val.funcall("value", ())?;
+            return Ok(Self::Text { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataHtml") {
+            let payload: HtmlMetadata = val.funcall("value", ())?;
+            return Ok(Self::Html { _0: Box::new(payload) });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataOcr") {
+            let payload: OcrMetadata = val.funcall("value", ())?;
+            return Ok(Self::Ocr { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataCsv") {
+            let payload: CsvMetadata = val.funcall("value", ())?;
+            return Ok(Self::Csv { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataBibtex") {
+            let payload: BibtexMetadata = val.funcall("value", ())?;
+            return Ok(Self::Bibtex { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataCitation") {
+            let payload: CitationMetadata = val.funcall("value", ())?;
+            return Ok(Self::Citation { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataFictionBook") {
+            let payload: FictionBookMetadata = val.funcall("value", ())?;
+            return Ok(Self::FictionBook { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataDbf") {
+            let payload: DbfMetadata = val.funcall("value", ())?;
+            return Ok(Self::Dbf { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataJats") {
+            let payload: JatsMetadata = val.funcall("value", ())?;
+            return Ok(Self::Jats { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataEpub") {
+            let payload: EpubMetadata = val.funcall("value", ())?;
+            return Ok(Self::Epub { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataPst") {
+            let payload: PstMetadata = val.funcall("value", ())?;
+            return Ok(Self::Pst { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataAudio") {
+            let payload: AudioMetadata = val.funcall("value", ())?;
+            return Ok(Self::Audio { _0: payload });
+        }
+        if class_name.as_deref() == Some("Xberg::FormatMetadataCode") {
+            let payload: CodeMetadata = val.funcall("value", ())?;
+            return Ok(Self::Code { _0: payload });
+        } // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -37269,6 +37895,7 @@ impl magnus::TryConvert for FormatMetadata {
 
 unsafe impl IntoValueFromNative for FormatMetadata {}
 unsafe impl TryConvertOwned for FormatMetadata {}
+
 impl FormatMetadata {
     pub fn pdf(&self) -> Option<&PdfMetadata> {
         match self {
@@ -37278,7 +37905,7 @@ impl FormatMetadata {
     }
     pub fn docx(&self) -> Option<&DocxMetadata> {
         match self {
-            Self::Docx { _0 } => Some(_0),
+            Self::Docx { _0 } => Some(&**_0),
             _ => None,
         }
     }
@@ -37326,7 +37953,7 @@ impl FormatMetadata {
     }
     pub fn html(&self) -> Option<&HtmlMetadata> {
         match self {
-            Self::Html { _0 } => Some(_0),
+            Self::Html { _0 } => Some(&**_0),
             _ => None,
         }
     }
@@ -37398,7 +38025,7 @@ impl FormatMetadata {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum FormulaModel {
     LatexOcr,
@@ -37421,7 +38048,14 @@ impl magnus::IntoValue for FormulaModel {
 
 impl magnus::TryConvert for FormulaModel {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37438,7 +38072,7 @@ impl magnus::TryConvert for FormulaModel {
 unsafe impl IntoValueFromNative for FormulaModel {}
 unsafe impl TryConvertOwned for FormulaModel {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum GlmOcrLayoutMode {
     WholePage,
@@ -37463,7 +38097,14 @@ impl magnus::IntoValue for GlmOcrLayoutMode {
 
 impl magnus::TryConvert for GlmOcrLayoutMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37481,7 +38122,7 @@ impl magnus::TryConvert for GlmOcrLayoutMode {
 unsafe impl IntoValueFromNative for GlmOcrLayoutMode {}
 unsafe impl TryConvertOwned for GlmOcrLayoutMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum GlmOcrTaskKind {
     Ocr,
@@ -37512,7 +38153,14 @@ impl magnus::IntoValue for GlmOcrTaskKind {
 
 impl magnus::TryConvert for GlmOcrTaskKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37533,7 +38181,7 @@ impl magnus::TryConvert for GlmOcrTaskKind {
 unsafe impl IntoValueFromNative for GlmOcrTaskKind {}
 unsafe impl TryConvertOwned for GlmOcrTaskKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HeadingStyle {
     Underlined,
     Atx,
@@ -37559,7 +38207,14 @@ impl magnus::IntoValue for HeadingStyle {
 
 impl magnus::TryConvert for HeadingStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37578,7 +38233,7 @@ impl magnus::TryConvert for HeadingStyle {
 unsafe impl IntoValueFromNative for HeadingStyle {}
 unsafe impl TryConvertOwned for HeadingStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HighlightStyle {
     DoubleEqual,
     Html,
@@ -37606,7 +38261,14 @@ impl magnus::IntoValue for HighlightStyle {
 
 impl magnus::TryConvert for HighlightStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37635,14 +38297,6 @@ pub enum HostMatcher {
     Cidr { value: String },
 }
 
-impl Default for HostMatcher {
-    fn default() -> Self {
-        Self::Exact {
-            value: Default::default(),
-        }
-    }
-}
-
 impl magnus::IntoValue for HostMatcher {
     fn into_value_with(self, handle: &Ruby) -> magnus::Value {
         match serde_json::to_value(&self) {
@@ -37654,7 +38308,8 @@ impl magnus::IntoValue for HostMatcher {
 
 impl magnus::TryConvert for HostMatcher {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -37686,9 +38341,10 @@ impl magnus::TryConvert for HostMatcher {
 
 unsafe impl IntoValueFromNative for HostMatcher {}
 unsafe impl TryConvertOwned for HostMatcher {}
+
 impl HostMatcher {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum HtmlTheme {
     Default,
@@ -37719,7 +38375,14 @@ impl magnus::IntoValue for HtmlTheme {
 
 impl magnus::TryConvert for HtmlTheme {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37740,7 +38403,7 @@ impl magnus::TryConvert for HtmlTheme {
 unsafe impl IntoValueFromNative for HtmlTheme {}
 unsafe impl TryConvertOwned for HtmlTheme {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum HtmlToMarkdownRsOutputFormat {
     Markdown,
     Djot,
@@ -37766,7 +38429,14 @@ impl magnus::IntoValue for HtmlToMarkdownRsOutputFormat {
 
 impl magnus::TryConvert for HtmlToMarkdownRsOutputFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37785,7 +38455,7 @@ impl magnus::TryConvert for HtmlToMarkdownRsOutputFormat {
 unsafe impl IntoValueFromNative for HtmlToMarkdownRsOutputFormat {}
 unsafe impl TryConvertOwned for HtmlToMarkdownRsOutputFormat {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ImageKind {
     Photograph,
@@ -37830,7 +38500,14 @@ impl magnus::IntoValue for ImageKind {
 
 impl magnus::TryConvert for ImageKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37887,7 +38564,8 @@ impl magnus::IntoValue for ImageOutputFormat {
 
 impl magnus::TryConvert for ImageOutputFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -37919,9 +38597,10 @@ impl magnus::TryConvert for ImageOutputFormat {
 
 unsafe impl IntoValueFromNative for ImageOutputFormat {}
 unsafe impl TryConvertOwned for ImageOutputFormat {}
+
 impl ImageOutputFormat {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ImageType {
     #[serde(rename = "data-uri")]
@@ -37952,7 +38631,14 @@ impl magnus::IntoValue for ImageType {
 
 impl magnus::TryConvert for ImageType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -37972,7 +38658,7 @@ impl magnus::TryConvert for ImageType {
 unsafe impl IntoValueFromNative for ImageType {}
 unsafe impl TryConvertOwned for ImageType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum InlineType {
     Text,
@@ -38025,7 +38711,14 @@ impl magnus::IntoValue for InlineType {
 
 impl magnus::TryConvert for InlineType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38057,7 +38750,7 @@ impl magnus::TryConvert for InlineType {
 unsafe impl IntoValueFromNative for InlineType {}
 unsafe impl TryConvertOwned for InlineType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum JupyterCellRendering {
     Source,
@@ -38084,7 +38777,14 @@ impl magnus::IntoValue for JupyterCellRendering {
 
 impl magnus::TryConvert for JupyterCellRendering {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38103,7 +38803,7 @@ impl magnus::TryConvert for JupyterCellRendering {
 unsafe impl IntoValueFromNative for JupyterCellRendering {}
 unsafe impl TryConvertOwned for JupyterCellRendering {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum KeywordAlgorithm {
     Yake,
@@ -38128,7 +38828,14 @@ impl magnus::IntoValue for KeywordAlgorithm {
 
 impl magnus::TryConvert for KeywordAlgorithm {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38183,7 +38890,8 @@ impl magnus::IntoValue for LateInteractionModelType {
 
 impl magnus::TryConvert for LateInteractionModelType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -38215,9 +38923,10 @@ impl magnus::TryConvert for LateInteractionModelType {
 
 unsafe impl IntoValueFromNative for LateInteractionModelType {}
 unsafe impl TryConvertOwned for LateInteractionModelType {}
+
 impl LateInteractionModelType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LayoutClass {
     Caption,
@@ -38274,7 +38983,14 @@ impl magnus::IntoValue for LayoutClass {
 
 impl magnus::TryConvert for LayoutClass {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38308,7 +39024,7 @@ impl magnus::TryConvert for LayoutClass {
 unsafe impl IntoValueFromNative for LayoutClass {}
 unsafe impl TryConvertOwned for LayoutClass {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LayoutStrategy {
     Always,
@@ -38333,7 +39049,14 @@ impl magnus::IntoValue for LayoutStrategy {
 
 impl magnus::TryConvert for LayoutStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38351,7 +39074,7 @@ impl magnus::TryConvert for LayoutStrategy {
 unsafe impl IntoValueFromNative for LayoutStrategy {}
 unsafe impl TryConvertOwned for LayoutStrategy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum LinkStyle {
     Inline,
     Reference,
@@ -38375,7 +39098,14 @@ impl magnus::IntoValue for LinkStyle {
 
 impl magnus::TryConvert for LinkStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38393,7 +39123,7 @@ impl magnus::TryConvert for LinkStyle {
 unsafe impl IntoValueFromNative for LinkStyle {}
 unsafe impl TryConvertOwned for LinkStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum LinkType {
     Anchor,
@@ -38426,7 +39156,14 @@ impl magnus::IntoValue for LinkType {
 
 impl magnus::TryConvert for LinkType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38448,7 +39185,7 @@ impl magnus::TryConvert for LinkType {
 unsafe impl IntoValueFromNative for LinkType {}
 unsafe impl TryConvertOwned for LinkType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ListIndentType {
     Spaces,
     Tabs,
@@ -38472,7 +39209,14 @@ impl magnus::IntoValue for ListIndentType {
 
 impl magnus::TryConvert for ListIndentType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38490,7 +39234,7 @@ impl magnus::TryConvert for ListIndentType {
 unsafe impl IntoValueFromNative for ListIndentType {}
 unsafe impl TryConvertOwned for ListIndentType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ListType {
     Bullet,
     Numbered,
@@ -38518,7 +39262,14 @@ impl magnus::IntoValue for ListType {
 
 impl magnus::TryConvert for ListType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38538,7 +39289,7 @@ impl magnus::TryConvert for ListType {
 unsafe impl IntoValueFromNative for ListType {}
 unsafe impl TryConvertOwned for ListType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum MergeMode {
     ObjectMerge,
@@ -38565,7 +39316,14 @@ impl magnus::IntoValue for MergeMode {
 
 impl magnus::TryConvert for MergeMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38584,7 +39342,7 @@ impl magnus::TryConvert for MergeMode {
 unsafe impl IntoValueFromNative for MergeMode {}
 unsafe impl TryConvertOwned for MergeMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum MimeDetectionPolicy {
     PreferContent,
@@ -38611,7 +39369,14 @@ impl magnus::IntoValue for MimeDetectionPolicy {
 
 impl magnus::TryConvert for MimeDetectionPolicy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38630,7 +39395,7 @@ impl magnus::TryConvert for MimeDetectionPolicy {
 unsafe impl IntoValueFromNative for MimeDetectionPolicy {}
 unsafe impl TryConvertOwned for MimeDetectionPolicy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum NerBackendKind {
     Onnx,
@@ -38655,7 +39420,14 @@ impl magnus::IntoValue for NerBackendKind {
 
 impl magnus::TryConvert for NerBackendKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38673,7 +39445,7 @@ impl magnus::TryConvert for NerBackendKind {
 unsafe impl IntoValueFromNative for NerBackendKind {}
 unsafe impl TryConvertOwned for NerBackendKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum NewlineStyle {
     Spaces,
     Backslash,
@@ -38697,7 +39469,14 @@ impl magnus::IntoValue for NewlineStyle {
 
 impl magnus::TryConvert for NewlineStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -38754,7 +39533,8 @@ impl magnus::IntoValue for NoChunkingReason {
 
 impl magnus::TryConvert for NoChunkingReason {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -38786,6 +39566,7 @@ impl magnus::TryConvert for NoChunkingReason {
 
 unsafe impl IntoValueFromNative for NoChunkingReason {}
 unsafe impl TryConvertOwned for NoChunkingReason {}
+
 impl NoChunkingReason {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -38881,7 +39662,8 @@ impl magnus::IntoValue for NodeContent {
 
 impl magnus::TryConvert for NodeContent {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -38913,9 +39695,10 @@ impl magnus::TryConvert for NodeContent {
 
 unsafe impl IntoValueFromNative for NodeContent {}
 unsafe impl TryConvertOwned for NodeContent {}
+
 impl NodeContent {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum OcrBackendType {
     Tesseract,
     PaddleOCR,
@@ -38943,7 +39726,14 @@ impl magnus::IntoValue for OcrBackendType {
 
 impl magnus::TryConvert for OcrBackendType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39000,7 +39790,8 @@ impl magnus::IntoValue for OcrBoundingGeometry {
 
 impl magnus::TryConvert for OcrBoundingGeometry {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -39032,9 +39823,10 @@ impl magnus::TryConvert for OcrBoundingGeometry {
 
 unsafe impl IntoValueFromNative for OcrBoundingGeometry {}
 unsafe impl TryConvertOwned for OcrBoundingGeometry {}
+
 impl OcrBoundingGeometry {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum OcrElementLevel {
     Word,
@@ -39063,7 +39855,14 @@ impl magnus::IntoValue for OcrElementLevel {
 
 impl magnus::TryConvert for OcrElementLevel {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39108,7 +39907,8 @@ impl magnus::IntoValue for OcrStrategy {
 
 impl magnus::TryConvert for OcrStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -39140,6 +39940,7 @@ impl magnus::TryConvert for OcrStrategy {
 
 unsafe impl IntoValueFromNative for OcrStrategy {}
 unsafe impl TryConvertOwned for OcrStrategy {}
+
 impl OcrStrategy {}
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -39203,7 +40004,7 @@ impl magnus::TryConvert for OutputFormat {
 unsafe impl IntoValueFromNative for OutputFormat {}
 unsafe impl TryConvertOwned for OutputFormat {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PSMMode {
     OsdOnly,
     AutoOsd,
@@ -39245,7 +40046,14 @@ impl magnus::IntoValue for PSMMode {
 
 impl magnus::TryConvert for PSMMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39272,7 +40080,7 @@ impl magnus::TryConvert for PSMMode {
 unsafe impl IntoValueFromNative for PSMMode {}
 unsafe impl TryConvertOwned for PSMMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PaddleInferenceBackend {
     Ort,
@@ -39297,7 +40105,14 @@ impl magnus::IntoValue for PaddleInferenceBackend {
 
 impl magnus::TryConvert for PaddleInferenceBackend {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39315,7 +40130,7 @@ impl magnus::TryConvert for PaddleInferenceBackend {
 unsafe impl IntoValueFromNative for PaddleInferenceBackend {}
 unsafe impl TryConvertOwned for PaddleInferenceBackend {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PaddleLanguage {
     English,
     Chinese,
@@ -39367,7 +40182,14 @@ impl magnus::IntoValue for PaddleLanguage {
 
 impl magnus::TryConvert for PaddleLanguage {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39399,7 +40221,7 @@ impl magnus::TryConvert for PaddleLanguage {
 unsafe impl IntoValueFromNative for PaddleLanguage {}
 unsafe impl TryConvertOwned for PaddleLanguage {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum PaddleOcrVlTaskKind {
     Ocr,
@@ -39428,7 +40250,14 @@ impl magnus::IntoValue for PaddleOcrVlTaskKind {
 
 impl magnus::TryConvert for PaddleOcrVlTaskKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39448,7 +40277,7 @@ impl magnus::TryConvert for PaddleOcrVlTaskKind {
 unsafe impl IntoValueFromNative for PaddleOcrVlTaskKind {}
 unsafe impl TryConvertOwned for PaddleOcrVlTaskKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PageOrientationHandling {
     SelfCorrecting,
     RecognisesRotatedText,
@@ -39474,7 +40303,14 @@ impl magnus::IntoValue for PageOrientationHandling {
 
 impl magnus::TryConvert for PageOrientationHandling {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39493,7 +40329,7 @@ impl magnus::TryConvert for PageOrientationHandling {
 unsafe impl IntoValueFromNative for PageOrientationHandling {}
 unsafe impl TryConvertOwned for PageOrientationHandling {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PageUnitType {
     Page,
@@ -39520,7 +40356,14 @@ impl magnus::IntoValue for PageUnitType {
 
 impl magnus::TryConvert for PageUnitType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39539,7 +40382,7 @@ impl magnus::TryConvert for PageUnitType {
 unsafe impl IntoValueFromNative for PageUnitType {}
 unsafe impl TryConvertOwned for PageUnitType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PdfAnnotationType {
     Text,
@@ -39596,7 +40439,14 @@ impl magnus::IntoValue for PdfAnnotationType {
 
 impl magnus::TryConvert for PdfAnnotationType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39630,7 +40480,7 @@ impl magnus::TryConvert for PdfAnnotationType {
 unsafe impl IntoValueFromNative for PdfAnnotationType {}
 unsafe impl TryConvertOwned for PdfAnnotationType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PdfBackend {
     Native,
@@ -39655,7 +40505,14 @@ impl magnus::IntoValue for PdfBackend {
 
 impl magnus::TryConvert for PdfBackend {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39740,7 +40597,7 @@ impl magnus::TryConvert for PiiCategory {
 unsafe impl IntoValueFromNative for PiiCategory {}
 unsafe impl TryConvertOwned for PiiCategory {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum PreprocessingPreset {
     Minimal,
     Standard,
@@ -39766,7 +40623,14 @@ impl magnus::IntoValue for PreprocessingPreset {
 
 impl magnus::TryConvert for PreprocessingPreset {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39785,7 +40649,7 @@ impl magnus::TryConvert for PreprocessingPreset {
 unsafe impl IntoValueFromNative for PreprocessingPreset {}
 unsafe impl TryConvertOwned for PreprocessingPreset {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PresetCategory {
     Finance,
@@ -39820,7 +40684,14 @@ impl magnus::IntoValue for PresetCategory {
 
 impl magnus::TryConvert for PresetCategory {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39843,7 +40714,7 @@ impl magnus::TryConvert for PresetCategory {
 unsafe impl IntoValueFromNative for PresetCategory {}
 unsafe impl TryConvertOwned for PresetCategory {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ProbeStatus {
     Pass,
@@ -39872,7 +40743,14 @@ impl magnus::IntoValue for ProbeStatus {
 
 impl magnus::TryConvert for ProbeStatus {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39892,7 +40770,7 @@ impl magnus::TryConvert for ProbeStatus {
 unsafe impl IntoValueFromNative for ProbeStatus {}
 unsafe impl TryConvertOwned for ProbeStatus {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ProcessingStage {
     Early,
     Middle,
@@ -39918,7 +40796,14 @@ impl magnus::IntoValue for ProcessingStage {
 
 impl magnus::TryConvert for ProcessingStage {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39937,7 +40822,7 @@ impl magnus::TryConvert for ProcessingStage {
 unsafe impl IntoValueFromNative for ProcessingStage {}
 unsafe impl TryConvertOwned for ProcessingStage {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RedactionStrategy {
     Mask,
@@ -39966,7 +40851,14 @@ impl magnus::IntoValue for RedactionStrategy {
 
 impl magnus::TryConvert for RedactionStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -39986,7 +40878,7 @@ impl magnus::TryConvert for RedactionStrategy {
 unsafe impl IntoValueFromNative for RedactionStrategy {}
 unsafe impl TryConvertOwned for RedactionStrategy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum ReductionLevel {
     Off,
     Light,
@@ -40016,7 +40908,14 @@ impl magnus::IntoValue for ReductionLevel {
 
 impl magnus::TryConvert for ReductionLevel {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40037,7 +40936,7 @@ impl magnus::TryConvert for ReductionLevel {
 unsafe impl IntoValueFromNative for ReductionLevel {}
 unsafe impl TryConvertOwned for ReductionLevel {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum RegionKind {
     Figure,
     DenseTable,
@@ -40065,7 +40964,14 @@ impl magnus::IntoValue for RegionKind {
 
 impl magnus::TryConvert for RegionKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40085,7 +40991,7 @@ impl magnus::TryConvert for RegionKind {
 unsafe impl IntoValueFromNative for RegionKind {}
 unsafe impl TryConvertOwned for RegionKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RelationshipKind {
     FootnoteReference,
@@ -40120,7 +41026,14 @@ impl magnus::IntoValue for RelationshipKind {
 
 impl magnus::TryConvert for RelationshipKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40143,7 +41056,7 @@ impl magnus::TryConvert for RelationshipKind {
 unsafe impl IntoValueFromNative for RelationshipKind {}
 unsafe impl TryConvertOwned for RelationshipKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RerankerHead {
     CrossEncoder,
@@ -40168,7 +41081,14 @@ impl magnus::IntoValue for RerankerHead {
 
 impl magnus::TryConvert for RerankerHead {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40201,7 +41121,7 @@ pub enum RerankerModelType {
         head: RerankerHead,
     },
     Llm {
-        llm: LlmConfig,
+        llm: Box<LlmConfig>,
     },
     Plugin {
         name: String,
@@ -40227,7 +41147,8 @@ impl magnus::IntoValue for RerankerModelType {
 
 impl magnus::TryConvert for RerankerModelType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -40259,9 +41180,10 @@ impl magnus::TryConvert for RerankerModelType {
 
 unsafe impl IntoValueFromNative for RerankerModelType {}
 unsafe impl TryConvertOwned for RerankerModelType {}
+
 impl RerankerModelType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ResultFormat {
     Unified,
@@ -40286,7 +41208,14 @@ impl magnus::IntoValue for ResultFormat {
 
 impl magnus::TryConvert for ResultFormat {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40334,7 +41263,8 @@ impl magnus::IntoValue for RevisionAnchor {
 
 impl magnus::TryConvert for RevisionAnchor {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -40366,9 +41296,10 @@ impl magnus::TryConvert for RevisionAnchor {
 
 unsafe impl IntoValueFromNative for RevisionAnchor {}
 unsafe impl TryConvertOwned for RevisionAnchor {}
+
 impl RevisionAnchor {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum RevisionKind {
     Insertion,
@@ -40397,7 +41328,14 @@ impl magnus::IntoValue for RevisionKind {
 
 impl magnus::TryConvert for RevisionKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40417,7 +41355,7 @@ impl magnus::TryConvert for RevisionKind {
 unsafe impl IntoValueFromNative for RevisionKind {}
 unsafe impl TryConvertOwned for RevisionKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum SchemaCompliance {
     AllValid,
@@ -40444,7 +41382,14 @@ impl magnus::IntoValue for SchemaCompliance {
 
 impl magnus::TryConvert for SchemaCompliance {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40500,7 +41445,8 @@ impl magnus::IntoValue for SparseEmbeddingModelType {
 
 impl magnus::TryConvert for SparseEmbeddingModelType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -40532,9 +41478,10 @@ impl magnus::TryConvert for SparseEmbeddingModelType {
 
 unsafe impl IntoValueFromNative for SparseEmbeddingModelType {}
 unsafe impl TryConvertOwned for SparseEmbeddingModelType {}
+
 impl SparseEmbeddingModelType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum StructuredDataType {
     #[serde(rename = "json-ld")]
@@ -40563,7 +41510,14 @@ impl magnus::IntoValue for StructuredDataType {
 
 impl magnus::TryConvert for StructuredDataType {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40582,7 +41536,7 @@ impl magnus::TryConvert for StructuredDataType {
 unsafe impl IntoValueFromNative for StructuredDataType {}
 unsafe impl TryConvertOwned for StructuredDataType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum SummaryStrategy {
     Extractive,
@@ -40607,7 +41561,14 @@ impl magnus::IntoValue for SummaryStrategy {
 
 impl magnus::TryConvert for SummaryStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40625,7 +41586,7 @@ impl magnus::TryConvert for SummaryStrategy {
 unsafe impl IntoValueFromNative for SummaryStrategy {}
 unsafe impl TryConvertOwned for SummaryStrategy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TableChunkingMode {
     Split,
@@ -40650,7 +41611,14 @@ impl magnus::IntoValue for TableChunkingMode {
 
 impl magnus::TryConvert for TableChunkingMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40668,7 +41636,7 @@ impl magnus::TryConvert for TableChunkingMode {
 unsafe impl IntoValueFromNative for TableChunkingMode {}
 unsafe impl TryConvertOwned for TableChunkingMode {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TableModel {
     Tatr,
@@ -40701,7 +41669,14 @@ impl magnus::IntoValue for TableModel {
 
 impl magnus::TryConvert for TableModel {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40723,7 +41698,7 @@ impl magnus::TryConvert for TableModel {
 unsafe impl IntoValueFromNative for TableModel {}
 unsafe impl TryConvertOwned for TableModel {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TableOverlapPreference {
     Content,
@@ -40750,7 +41725,14 @@ impl magnus::IntoValue for TableOverlapPreference {
 
 impl magnus::TryConvert for TableOverlapPreference {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40769,7 +41751,7 @@ impl magnus::TryConvert for TableOverlapPreference {
 unsafe impl IntoValueFromNative for TableOverlapPreference {}
 unsafe impl TryConvertOwned for TableOverlapPreference {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum TextDirection {
     #[serde(rename = "ltr")]
@@ -40799,7 +41781,14 @@ impl magnus::IntoValue for TextDirection {
 
 impl magnus::TryConvert for TextDirection {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40818,7 +41807,7 @@ impl magnus::TryConvert for TextDirection {
 unsafe impl IntoValueFromNative for TextDirection {}
 unsafe impl TryConvertOwned for TextDirection {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum TierStrategy {
     Auto,
@@ -40843,7 +41832,14 @@ impl magnus::IntoValue for TierStrategy {
 
 impl magnus::TryConvert for TierStrategy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40861,7 +41857,7 @@ impl magnus::TryConvert for TierStrategy {
 unsafe impl IntoValueFromNative for TierStrategy {}
 unsafe impl TryConvertOwned for TierStrategy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum UriKind {
     Hyperlink,
@@ -40894,7 +41890,14 @@ impl magnus::IntoValue for UriKind {
 
 impl magnus::TryConvert for UriKind {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40916,7 +41919,7 @@ impl magnus::TryConvert for UriKind {
 unsafe impl IntoValueFromNative for UriKind {}
 unsafe impl TryConvertOwned for UriKind {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum UrlEscapeStyle {
     Angle,
     Percent,
@@ -40940,7 +41943,14 @@ impl magnus::IntoValue for UrlEscapeStyle {
 
 impl magnus::TryConvert for UrlEscapeStyle {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -40958,7 +41968,7 @@ impl magnus::TryConvert for UrlEscapeStyle {
 unsafe impl IntoValueFromNative for UrlEscapeStyle {}
 unsafe impl TryConvertOwned for UrlEscapeStyle {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum UrlExtractionMode {
     Auto,
@@ -40985,7 +41995,14 @@ impl magnus::IntoValue for UrlExtractionMode {
 
 impl magnus::TryConvert for UrlExtractionMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -41030,7 +42047,8 @@ impl magnus::IntoValue for VlmFallbackPolicy {
 
 impl magnus::TryConvert for VlmFallbackPolicy {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
+        // Generated Data variants carry native DTOs, not JSON-compatible display strings.
+        let class_name: Option<String> = val.class().funcall("name", ())?; // For data enums with fields (e.g., PageAction), try to deserialize from JSON first.
         // For unit enums or when passed as a string, fall back to string-based conversion.
         let json_str: String = if let Ok(s) = <String as magnus::TryConvert>::try_convert(val) {
             s
@@ -41062,9 +42080,10 @@ impl magnus::TryConvert for VlmFallbackPolicy {
 
 unsafe impl IntoValueFromNative for VlmFallbackPolicy {}
 unsafe impl TryConvertOwned for VlmFallbackPolicy {}
+
 impl VlmFallbackPolicy {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum WhisperModel {
     Tiny,
@@ -41095,7 +42114,14 @@ impl magnus::IntoValue for WhisperModel {
 
 impl magnus::TryConvert for WhisperModel {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -41116,7 +42142,7 @@ impl magnus::TryConvert for WhisperModel {
 unsafe impl IntoValueFromNative for WhisperModel {}
 unsafe impl TryConvertOwned for WhisperModel {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum WhitespaceMode {
     Normalized,
     Strict,
@@ -41140,7 +42166,14 @@ impl magnus::IntoValue for WhitespaceMode {
 
 impl magnus::TryConvert for WhitespaceMode {
     fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
-        let s: String = magnus::TryConvert::try_convert(val)?;
+        // IntoValue emits Symbols, including when this enum is a Hash key.
+        // Accept that exact representation as well as String inputs; do not
+        // coerce arbitrary objects through to_s.
+        let s: String = if let Some(symbol) = magnus::Symbol::from_value(val) {
+            symbol.name()?.into_owned()
+        } else {
+            magnus::TryConvert::try_convert(val)?
+        };
         // Accept the real serde wire value, the legacy always-snake_case symbol Magnus used to
         // emit unconditionally, and the verbatim PascalCase Rust variant name, so fixtures and
         // existing consumer code written in any of those styles keep working.
@@ -41631,7 +42664,7 @@ impl RbOcrBackendBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -41664,33 +42697,47 @@ impl RbOcrBackendBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbOcrBackendBridgeRuntimeJob>,
     ) -> Result<RbOcrBackendBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbOcrBackendBridgeRuntimeJob>,
-            result: Option<Result<RbOcrBackendBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbOcrBackendBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -42914,7 +43961,7 @@ impl RbPostProcessorBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -42947,33 +43994,47 @@ impl RbPostProcessorBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbPostProcessorBridgeRuntimeJob>,
     ) -> Result<RbPostProcessorBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbPostProcessorBridgeRuntimeJob>,
-            result: Option<Result<RbPostProcessorBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbPostProcessorBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -43510,7 +44571,7 @@ impl RbValidatorBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -43543,33 +44604,47 @@ impl RbValidatorBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbValidatorBridgeRuntimeJob>,
     ) -> Result<RbValidatorBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbValidatorBridgeRuntimeJob>,
-            result: Option<Result<RbValidatorBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbValidatorBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -43967,7 +45042,7 @@ impl RbDocumentExtractorBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -44000,33 +45075,47 @@ impl RbDocumentExtractorBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbDocumentExtractorBridgeRuntimeJob>,
     ) -> Result<RbDocumentExtractorBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbDocumentExtractorBridgeRuntimeJob>,
-            result: Option<Result<RbDocumentExtractorBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbDocumentExtractorBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -44469,7 +45558,7 @@ impl RbEmbeddingBackendBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -44502,33 +45591,47 @@ impl RbEmbeddingBackendBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbEmbeddingBackendBridgeRuntimeJob>,
     ) -> Result<RbEmbeddingBackendBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbEmbeddingBackendBridgeRuntimeJob>,
-            result: Option<Result<RbEmbeddingBackendBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbEmbeddingBackendBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -44796,7 +45899,7 @@ impl RbRendererBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -44829,33 +45932,47 @@ impl RbRendererBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbRendererBridgeRuntimeJob>,
     ) -> Result<RbRendererBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbRendererBridgeRuntimeJob>,
-            result: Option<Result<RbRendererBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbRendererBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -45099,7 +46216,7 @@ impl RbRerankerBackendBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -45132,33 +46249,47 @@ impl RbRerankerBackendBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbRerankerBackendBridgeRuntimeJob>,
     ) -> Result<RbRerankerBackendBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbRerankerBackendBridgeRuntimeJob>,
-            result: Option<Result<RbRerankerBackendBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbRerankerBackendBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -45394,7 +46525,7 @@ impl RbTokenizerBackendBridgeRuntimeDispatcher {
         let (sender, receiver) = std::sync::mpsc::sync_channel(Self::QUEUE_CAPACITY);
         let inner = magnus::value::Opaque::from(rb_obj);
         let thread = ruby.thread_create_from_fn(move |ruby| {
-            while let Ok(job) = Self::recv_without_gvl(&receiver) {
+            while let Ok(job) = Self::recv_without_gvl(ruby, &receiver) {
                 let value = inner.get_inner_with(ruby);
                 let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
                     job(ruby, value);
@@ -45427,33 +46558,47 @@ impl RbTokenizerBackendBridgeRuntimeDispatcher {
     }
 
     fn recv_without_gvl(
+        ruby: &magnus::Ruby,
         receiver: &std::sync::mpsc::Receiver<RbTokenizerBackendBridgeRuntimeJob>,
     ) -> Result<RbTokenizerBackendBridgeRuntimeJob, std::sync::mpsc::RecvError> {
         struct ReceiveState<'a> {
             receiver: &'a std::sync::mpsc::Receiver<RbTokenizerBackendBridgeRuntimeJob>,
-            result: Option<Result<RbTokenizerBackendBridgeRuntimeJob, std::sync::mpsc::RecvError>>,
+            result: Option<Result<RbTokenizerBackendBridgeRuntimeJob, std::sync::mpsc::RecvTimeoutError>>,
         }
 
         unsafe extern "C" fn receive(data: *mut std::ffi::c_void) -> *mut std::ffi::c_void {
             // SAFETY: the state pointer remains valid until Ruby returns from the
             // without-GVL callback on this same Ruby-created thread.
             let state = unsafe { &mut *(data as *mut ReceiveState<'_>) };
-            state.result = Some(state.receiver.recv());
+            state.result = Some(state.receiver.recv_timeout(std::time::Duration::from_millis(50)));
             std::ptr::null_mut()
         }
 
-        let mut state = ReceiveState { receiver, result: None };
-        // SAFETY: this runs on the dedicated Ruby-created dispatcher thread. The
-        // callback touches only Rust channel state and the sender disconnect wakes it.
-        unsafe {
-            rb_sys::rb_thread_call_without_gvl(
-                Some(receive),
-                &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
-                None,
-                std::ptr::null_mut(),
-            );
+        loop {
+            let mut state = ReceiveState { receiver, result: None };
+            // SAFETY: the callback only touches Rust channel state, and returns
+            // within 50ms even if a registered sender survives interpreter exit.
+            // The gvl2 API defers interrupts: process them through Magnus below
+            // so a Ruby non-local exit cannot skip Rust stack destructors here.
+            unsafe {
+                rb_sys::rb_thread_call_without_gvl2(
+                    Some(receive),
+                    &mut state as *mut ReceiveState<'_> as *mut std::ffi::c_void,
+                    None,
+                    std::ptr::null_mut(),
+                );
+            }
+            if ruby.thread_check_ints().is_err() {
+                return Err(std::sync::mpsc::RecvError);
+            }
+            match state.result {
+                Some(Ok(job)) => return Ok(job),
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Disconnected)) => {
+                    return Err(std::sync::mpsc::RecvError);
+                }
+                Some(Err(std::sync::mpsc::RecvTimeoutError::Timeout)) | None => continue,
+            }
         }
-        state.result.unwrap_or_else(|| Err(std::sync::mpsc::RecvError))
     }
 }
 
@@ -46808,8 +47953,12 @@ impl From<xberg::candle_ocr::DeepseekOcrBackendOptions> for DeepseekOcrBackendOp
     fn from(val: xberg::candle_ocr::DeepseekOcrBackendOptions) -> Self {
         Self {
             model_path: val.model_path.map(|v| v.to_string()),
+            model_id: val.model_id.map(|v| v.to_string()),
+            hf_revision: val.hf_revision.map(|v| v.to_string()),
+            cache_dir: val.cache_dir.map(|v| v.to_string()),
             device: val.device.map(Into::into),
             version: val.version,
+            dtype: val.dtype.map(Into::into),
         }
     }
 }
@@ -50016,6 +51165,8 @@ impl From<OcrQualityThresholds> for xberg::OcrQualityThresholds {
             min_undecodable_ratio: val.min_undecodable_ratio,
             enable_provenance_ocr_routing: val.enable_provenance_ocr_routing,
             min_provenance_fallback_ratio: val.min_provenance_fallback_ratio,
+            enable_plausibility_ocr_routing: val.enable_plausibility_ocr_routing,
+            min_reliable_language_chunk_ratio: val.min_reliable_language_chunk_ratio,
             ..Default::default()
         }
     }
@@ -50048,6 +51199,8 @@ impl From<xberg::OcrQualityThresholds> for OcrQualityThresholds {
             min_undecodable_ratio: val.min_undecodable_ratio,
             enable_provenance_ocr_routing: val.enable_provenance_ocr_routing,
             min_provenance_fallback_ratio: val.min_provenance_fallback_ratio,
+            enable_plausibility_ocr_routing: val.enable_plausibility_ocr_routing,
+            min_reliable_language_chunk_ratio: val.min_reliable_language_chunk_ratio,
         }
     }
 }
@@ -50614,6 +51767,8 @@ impl From<PdfMetadata> for xberg::pdf::metadata::PdfMetadata {
             page_count: val.page_count,
             scanned_confidence: val.scanned_confidence,
             scanned_pages: val.scanned_pages.map(|v| v.into_iter().collect()),
+            fabricated_text_pages: val.fabricated_text_pages.map(|v| v.into_iter().collect()),
+            implausible_text_pages: val.implausible_text_pages.map(|v| v.into_iter().collect()),
             layout_gated_pages: val.layout_gated_pages.map(|v| v.into_iter().collect()),
             layout_gate_reasons: val.layout_gate_reasons.map(|v| v.into_iter().collect()),
             ..Default::default()
@@ -50634,6 +51789,8 @@ impl From<xberg::pdf::metadata::PdfMetadata> for PdfMetadata {
             page_count: val.page_count,
             scanned_confidence: val.scanned_confidence,
             scanned_pages: val.scanned_pages.map(|v| v.into_iter().collect()),
+            fabricated_text_pages: val.fabricated_text_pages.map(|v| v.into_iter().collect()),
+            implausible_text_pages: val.implausible_text_pages.map(|v| v.into_iter().collect()),
             layout_gated_pages: val.layout_gated_pages.map(|v| v.into_iter().collect()),
             layout_gate_reasons: val.layout_gate_reasons.map(|v| v.into_iter().collect()),
         }
@@ -52422,6 +53579,18 @@ impl From<xberg::CallMode> for CallMode {
     }
 }
 
+#[cfg(feature = "candle-ocr")]
+impl From<xberg::candle_ocr::CandleDeepseekOcrDtype> for CandleDeepseekOcrDtype {
+    fn from(val: xberg::candle_ocr::CandleDeepseekOcrDtype) -> Self {
+        match val {
+            xberg::candle_ocr::CandleDeepseekOcrDtype::Auto => Self::Auto,
+            xberg::candle_ocr::CandleDeepseekOcrDtype::F32 => Self::F32,
+            xberg::candle_ocr::CandleDeepseekOcrDtype::F16 => Self::F16,
+            xberg::candle_ocr::CandleDeepseekOcrDtype::Bf16 => Self::Bf16,
+        }
+    }
+}
+
 #[cfg(feature = "candle-ocr")]
 impl From<xberg::candle_ocr::CandleDevicePreference> for CandleDevicePreference {
     fn from(val: xberg::candle_ocr::CandleDevicePreference) -> Self {
@@ -52624,6 +53793,16 @@ impl From<xberg::CodeDataNodeKind> for CodeDataNodeKind {
     }
 }
 
+impl From<ConfidenceSemantics> for xberg::ConfidenceSemantics {
+    fn from(val: ConfidenceSemantics) -> Self {
+        match val {
+            ConfidenceSemantics::Legibility { scale_max } => Self::Legibility { scale_max },
+            ConfidenceSemantics::Uncalibrated => Self::Uncalibrated,
+            ConfidenceSemantics::None => Self::None,
+        }
+    }
+}
+
 impl From<xberg::ConfidenceSemantics> for ConfidenceSemantics {
     fn from(val: xberg::ConfidenceSemantics) -> Self {
         match val {
@@ -52850,7 +54029,7 @@ impl From<EmbeddingModelType> for xberg::EmbeddingModelType {
             EmbeddingModelType::Preset { name } => Self::Preset { name },
             EmbeddingModelType::Custom { model_id, dimensions } => Self::Custom { model_id, dimensions },
             EmbeddingModelType::Llm { llm } => Self::Llm {
-                llm: Box::new(llm.into()),
+                llm: Box::new((*llm).into()),
             },
             EmbeddingModelType::Plugin { name } => Self::Plugin { name },
         }
@@ -52865,7 +54044,9 @@ impl From<xberg::EmbeddingModelType> for EmbeddingModelType {
                 model_id: model_id.to_string(),
                 dimensions,
             },
-            xberg::EmbeddingModelType::Llm { llm } => Self::Llm { llm: (*llm).into() },
+            xberg::EmbeddingModelType::Llm { llm } => Self::Llm {
+                llm: Box::new((*llm).into()),
+            },
             xberg::EmbeddingModelType::Plugin { name } => Self::Plugin { name: name.to_string() },
         }
     }
@@ -53013,7 +54194,7 @@ impl From<FormatMetadata> for xberg::FormatMetadata {
             #[cfg(feature = "pdf")]
             FormatMetadata::Pdf { _0 } => Self::Pdf(_0.into()),
             #[cfg(feature = "office")]
-            FormatMetadata::Docx { _0 } => Self::Docx(Box::new(_0.into())),
+            FormatMetadata::Docx { _0 } => Self::Docx(Box::new((*_0).into())),
             FormatMetadata::Excel { _0 } => Self::Excel(_0.into()),
             FormatMetadata::Email { _0 } => Self::Email(_0.into()),
             FormatMetadata::Pptx { _0 } => Self::Pptx(_0.into()),
@@ -53021,7 +54202,7 @@ impl From<FormatMetadata> for xberg::FormatMetadata {
             FormatMetadata::Image { _0 } => Self::Image(_0.into()),
             FormatMetadata::Xml { _0 } => Self::Xml(_0.into()),
             FormatMetadata::Text { _0 } => Self::Text(_0.into()),
-            FormatMetadata::Html { _0 } => Self::Html(Box::new(_0.into())),
+            FormatMetadata::Html { _0 } => Self::Html(Box::new((*_0).into())),
             FormatMetadata::Ocr { _0 } => Self::Ocr(_0.into()),
             FormatMetadata::Csv { _0 } => Self::Csv(_0.into()),
             #[cfg(feature = "office")]
@@ -53051,7 +54232,9 @@ impl From<xberg::FormatMetadata> for FormatMetadata {
             #[cfg(feature = "pdf")]
             xberg::FormatMetadata::Pdf(_0) => Self::Pdf { _0: _0.into() },
             #[cfg(feature = "office")]
-            xberg::FormatMetadata::Docx(_0) => Self::Docx { _0: (*_0).into() },
+            xberg::FormatMetadata::Docx(_0) => Self::Docx {
+                _0: Box::new((*_0).into()),
+            },
             xberg::FormatMetadata::Excel(_0) => Self::Excel { _0: _0.into() },
             xberg::FormatMetadata::Email(_0) => Self::Email { _0: _0.into() },
             xberg::FormatMetadata::Pptx(_0) => Self::Pptx { _0: _0.into() },
@@ -53059,7 +54242,9 @@ impl From<xberg::FormatMetadata> for FormatMetadata {
             xberg::FormatMetadata::Image(_0) => Self::Image { _0: _0.into() },
             xberg::FormatMetadata::Xml(_0) => Self::Xml { _0: _0.into() },
             xberg::FormatMetadata::Text(_0) => Self::Text { _0: _0.into() },
-            xberg::FormatMetadata::Html(_0) => Self::Html { _0: (*_0).into() },
+            xberg::FormatMetadata::Html(_0) => Self::Html {
+                _0: Box::new((*_0).into()),
+            },
             xberg::FormatMetadata::Ocr(_0) => Self::Ocr { _0: _0.into() },
             xberg::FormatMetadata::Csv(_0) => Self::Csv { _0: _0.into() },
             #[cfg(feature = "office")]
@@ -53792,6 +54977,17 @@ impl From<xberg::NodeContent> for NodeContent {
     }
 }
 
+impl From<OcrBackendType> for xberg::OcrBackendType {
+    fn from(val: OcrBackendType) -> Self {
+        match val {
+            OcrBackendType::Tesseract => Self::Tesseract,
+            OcrBackendType::PaddleOCR => Self::PaddleOCR,
+            OcrBackendType::Candle => Self::Candle,
+            OcrBackendType::Custom => Self::Custom,
+        }
+    }
+}
+
 impl From<xberg::OcrBackendType> for OcrBackendType {
     fn from(val: xberg::OcrBackendType) -> Self {
         match val {
@@ -53988,6 +55184,16 @@ impl From<xberg::candle_ocr::PaddleOcrVlTaskKind> for PaddleOcrVlTaskKind {
     }
 }
 
+impl From<PageOrientationHandling> for xberg::PageOrientationHandling {
+    fn from(val: PageOrientationHandling) -> Self {
+        match val {
+            PageOrientationHandling::SelfCorrecting => Self::SelfCorrecting,
+            PageOrientationHandling::RecognisesRotatedText => Self::RecognisesRotatedText,
+            PageOrientationHandling::RequiresUpright => Self::RequiresUpright,
+        }
+    }
+}
+
 impl From<xberg::PageOrientationHandling> for PageOrientationHandling {
     fn from(val: xberg::PageOrientationHandling) -> Self {
         match val {
@@ -54200,6 +55406,16 @@ impl From<xberg::ProbeStatus> for ProbeStatus {
     }
 }
 
+impl From<ProcessingStage> for xberg::ProcessingStage {
+    fn from(val: ProcessingStage) -> Self {
+        match val {
+            ProcessingStage::Early => Self::Early,
+            ProcessingStage::Middle => Self::Middle,
+            ProcessingStage::Late => Self::Late,
+        }
+    }
+}
+
 impl From<xberg::ProcessingStage> for ProcessingStage {
     fn from(val: xberg::ProcessingStage) -> Self {
         match val {
@@ -54333,7 +55549,7 @@ impl From<RerankerModelType> for xberg::RerankerModelType {
                 head: head.into(),
             },
             RerankerModelType::Llm { llm } => Self::Llm {
-                llm: Box::new(llm.into()),
+                llm: Box::new((*llm).into()),
             },
             RerankerModelType::Plugin { name } => Self::Plugin { name },
         }
@@ -54357,7 +55573,9 @@ impl From<xberg::RerankerModelType> for RerankerModelType {
                 max_length,
                 head: head.into(),
             },
-            xberg::RerankerModelType::Llm { llm } => Self::Llm { llm: (*llm).into() },
+            xberg::RerankerModelType::Llm { llm } => Self::Llm {
+                llm: Box::new((*llm).into()),
+            },
             xberg::RerankerModelType::Plugin { name } => Self::Plugin { name: name.to_string() },
         }
     }
@@ -55594,12 +56812,24 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[cfg(feature = "candle-ocr")]
     class.define_method("model_path", method!(DeepseekOcrBackendOptions::model_path, 0))?;
 
+    #[cfg(feature = "candle-ocr")]
+    class.define_method("model_id", method!(DeepseekOcrBackendOptions::model_id, 0))?;
+
+    #[cfg(feature = "candle-ocr")]
+    class.define_method("hf_revision", method!(DeepseekOcrBackendOptions::hf_revision, 0))?;
+
+    #[cfg(feature = "candle-ocr")]
+    class.define_method("cache_dir", method!(DeepseekOcrBackendOptions::cache_dir, 0))?;
+
     #[cfg(feature = "candle-ocr")]
     class.define_method("device", method!(DeepseekOcrBackendOptions::device, 0))?;
 
     #[cfg(feature = "candle-ocr")]
     class.define_method("version", method!(DeepseekOcrBackendOptions::version, 0))?;
 
+    #[cfg(feature = "candle-ocr")]
+    class.define_method("dtype", method!(DeepseekOcrBackendOptions::dtype, 0))?;
+
     let class = module.define_class("DetectResponse", ruby.class_object())?;
 
     #[cfg(feature = "api")]
@@ -56485,6 +57715,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("needs_image_data", method!(ExtractionConfig::needs_image_data, 0))?;
 
+    class.define_method(
+        "runs_ocr_on_embedded_images",
+        method!(ExtractionConfig::runs_ocr_on_embedded_images, 0),
+    )?;
+
+    class.define_method(
+        "wants_own_bytes_in_result",
+        method!(ExtractionConfig::wants_own_bytes_in_result, 0),
+    )?;
+
     class.define_method(
         "needs_image_processing",
         method!(ExtractionConfig::needs_image_processing, 0),
@@ -57966,6 +59206,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         method!(OcrQualityThresholds::min_provenance_fallback_ratio, 0),
     )?;
 
+    class.define_method(
+        "enable_plausibility_ocr_routing",
+        method!(OcrQualityThresholds::enable_plausibility_ocr_routing, 0),
+    )?;
+
+    class.define_method(
+        "min_reliable_language_chunk_ratio",
+        method!(OcrQualityThresholds::min_reliable_language_chunk_ratio, 0),
+    )?;
+
     let class = module.define_class("OcrRotation", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(OcrRotation::new, -1))?;
@@ -58450,6 +59700,15 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
     #[cfg(feature = "pdf")]
     class.define_method("scanned_pages", method!(PdfMetadata::scanned_pages, 0))?;
 
+    #[cfg(feature = "pdf")]
+    class.define_method("fabricated_text_pages", method!(PdfMetadata::fabricated_text_pages, 0))?;
+
+    #[cfg(feature = "pdf")]
+    class.define_method(
+        "implausible_text_pages",
+        method!(PdfMetadata::implausible_text_pages, 0),
+    )?;
+
     #[cfg(feature = "pdf")]
     class.define_method("layout_gated_pages", method!(PdfMetadata::layout_gated_pages, 0))?;