html-to-markdown 3.14.3 → 3.15.0

data/ext/html_to_markdown_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:b89f28165748578716b78d7870c438b5394d9c847ec7718f9620057ca8fb0688
+// alef:hash:adcf6160cdf7035806744fc3efe8b3116ce330a5c164ade234e6c2fe49fbe748
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -105,6 +105,7 @@ pub struct ConversionOptions {
     max_depth: Option<usize>,
     exclude_selectors: Vec<String>,
     tier_strategy: TierStrategy,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -535,6 +536,15 @@ impl ConversionOptions {
                 })?,
                 None => TierStrategy::Auto,
             },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).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 `base_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -709,6 +719,10 @@ impl ConversionOptions {
     fn tier_strategy(&self) -> TierStrategy {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -758,6 +772,7 @@ pub struct ConversionOptionsUpdate {
     max_depth: Option<usize>,
     exclude_selectors: Option<Vec<String>>,
     tier_strategy: Option<TierStrategy>,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptionsUpdate {}
@@ -1194,6 +1209,15 @@ impl ConversionOptionsUpdate {
                 })?),
                 None => None,
             },
+            base_url: match kwargs.get(ruby.to_symbol("base_url")).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 `base_url`: {}", e),
+                    )
+                })?),
+                None => None,
+            },
         })
     }
 
@@ -1368,6 +1392,10 @@ impl ConversionOptionsUpdate {
     fn tier_strategy(&self) -> Option<TierStrategy> {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -3642,7 +3670,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
@@ -3674,9 +3703,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)]
 pub enum CodeBlockStyle {
     Indented,
     Backticks,
@@ -3702,7 +3732,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.
@@ -3721,7 +3758,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)]
 pub enum HeadingStyle {
     Underlined,
     Atx,
@@ -3747,7 +3784,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.
@@ -3766,7 +3810,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,
@@ -3794,7 +3838,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.
@@ -3814,7 +3865,7 @@ impl magnus::TryConvert for HighlightStyle {
 unsafe impl IntoValueFromNative for HighlightStyle {}
 unsafe impl TryConvertOwned for HighlightStyle {}
 
-#[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 ImageType {
     DataUri,
@@ -3843,7 +3894,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.
@@ -3863,7 +3921,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)]
 pub enum LinkStyle {
     Inline,
     Reference,
@@ -3887,7 +3945,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.
@@ -3905,7 +3970,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 = "snake_case")]
 pub enum LinkType {
     Anchor,
@@ -3938,7 +4003,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.
@@ -3960,7 +4032,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,
@@ -3984,7 +4056,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.
@@ -4002,7 +4081,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 NewlineStyle {
     Spaces,
     Backslash,
@@ -4026,7 +4105,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.
@@ -4113,7 +4199,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
@@ -4145,9 +4232,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 NodeType {
     Text,
     Element,
@@ -4343,7 +4431,14 @@ impl magnus::IntoValue for NodeType {
 
 impl magnus::TryConvert for NodeType {
     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.
@@ -4447,7 +4542,7 @@ impl magnus::TryConvert for NodeType {
 unsafe impl IntoValueFromNative for NodeType {}
 unsafe impl TryConvertOwned for NodeType {}
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
 pub enum OutputFormat {
     Markdown,
     Djot,
@@ -4473,7 +4568,14 @@ impl magnus::IntoValue for OutputFormat {
 
 impl magnus::TryConvert for OutputFormat {
     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.
@@ -4492,7 +4594,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 PreprocessingPreset {
     Minimal,
     Standard,
@@ -4518,7 +4620,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.
@@ -4537,7 +4646,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 StructuredDataType {
     #[serde(rename = "json_ld")]
@@ -4566,7 +4675,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.
@@ -4585,7 +4701,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)]
 pub enum TextDirection {
     #[serde(rename = "ltr")]
     LeftToRight,
@@ -4614,7 +4730,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.
@@ -4633,7 +4756,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,
@@ -4660,7 +4783,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.
@@ -4679,7 +4809,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)]
 pub enum UrlEscapeStyle {
     Angle,
     Percent,
@@ -4703,7 +4833,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.
@@ -4749,7 +4886,8 @@ impl magnus::IntoValue for VisitResult {
 
 impl magnus::TryConvert for VisitResult {
     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
@@ -4781,6 +4919,7 @@ impl magnus::TryConvert for VisitResult {
 
 unsafe impl IntoValueFromNative for VisitResult {}
 unsafe impl TryConvertOwned for VisitResult {}
+
 impl VisitResult {
     pub fn custom(&self) -> Option<&String> {
         match self {
@@ -4796,7 +4935,7 @@ impl VisitResult {
     }
 }
 
-#[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 WarningKind {
     ImageExtractionFailed,
@@ -4829,7 +4968,14 @@ impl magnus::IntoValue for WarningKind {
 
 impl magnus::TryConvert for WarningKind {
     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.
@@ -4851,7 +4997,7 @@ impl magnus::TryConvert for WarningKind {
 unsafe impl IntoValueFromNative for WarningKind {}
 unsafe impl TryConvertOwned for WarningKind {}
 
-#[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,
@@ -4875,7 +5021,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.
@@ -6675,12 +6828,13 @@ impl From<ConversionOptions> for html_to_markdown_rs::options::ConversionOptions
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url,
             ..Default::default()
         }
     }
 }
 
-#[allow(clippy::useless_conversion)]
+#[allow(clippy::redundant_closure, clippy::useless_conversion)]
 impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions {
     fn from(val: html_to_markdown_rs::options::ConversionOptions) -> Self {
         Self {
@@ -6727,6 +6881,7 @@ impl From<html_to_markdown_rs::options::ConversionOptions> for ConversionOptions
             max_depth: val.max_depth,
             exclude_selectors: val.exclude_selectors.into_iter().collect(),
             tier_strategy: val.tier_strategy.into(),
+            base_url: val.base_url.map(|v| v.to_string()),
         }
     }
 }
@@ -6778,6 +6933,7 @@ impl From<html_to_markdown_rs::options::ConversionOptionsUpdate> for ConversionO
             max_depth: val.max_depth.flatten(),
             exclude_selectors: val.exclude_selectors.map(|v| v.into_iter().collect()),
             tier_strategy: val.tier_strategy.map(Into::into),
+            base_url: val.base_url.flatten().map(|v| v.to_string()),
         }
     }
 }
@@ -7889,6 +8045,19 @@ impl From<html_to_markdown_rs::options::UrlEscapeStyle> for UrlEscapeStyle {
     }
 }
 
+#[cfg(feature = "visitor")]
+impl From<VisitResult> for html_to_markdown_rs::VisitResult {
+    fn from(val: VisitResult) -> Self {
+        match val {
+            VisitResult::Continue => Self::Continue,
+            VisitResult::Custom(_0) => Self::Custom(_0),
+            VisitResult::Skip => Self::Skip,
+            VisitResult::PreserveHtml => Self::PreserveHtml,
+            VisitResult::Error(_0) => Self::Error(_0),
+        }
+    }
+}
+
 #[cfg(feature = "visitor")]
 impl From<html_to_markdown_rs::VisitResult> for VisitResult {
     fn from(val: html_to_markdown_rs::VisitResult) -> Self {
@@ -8056,6 +8225,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tier_strategy", method!(ConversionOptions::tier_strategy, 0))?;
 
+    class.define_method("base_url", method!(ConversionOptions::base_url, 0))?;
+
     let class = module.define_class("ConversionOptionsUpdate", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ConversionOptionsUpdate::new, -1))?;
@@ -8185,6 +8356,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tier_strategy", method!(ConversionOptionsUpdate::tier_strategy, 0))?;
 
+    class.define_method("base_url", method!(ConversionOptionsUpdate::base_url, 0))?;
+
     let class = module.define_class("ConversionResult", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ConversionResult::new, -1))?;