xberg 1.2.9 → 1.3.0

data/ext/xberg_rb/src/lib.rs

@@ -1,5 +1,5 @@
 // This file is auto-generated by alef. DO NOT EDIT.
-// alef:hash:9fd93c9044f1bedf7b944452cf36003a6468e2f40f9fe5a1d4e78bea797a60a3
+// alef:hash:7b7e0e3e79a8cf968d66bcaa7adae77d99bdb0dc86ad64a75c1e785c57a13371
 // Re-generate with: alef generate
 #![allow(dead_code, unused_imports, unused_variables)]
 #![allow(
@@ -1134,6 +1134,8 @@ pub struct BrowserConfig {
     endpoint: Option<String>,
     #[serde(default = "default_timeout")]
     timeout: u64,
+    overall_timeout: u64,
+    shutdown_timeout: u64,
     wait: BrowserWait,
     wait_selector: Option<String>,
     extra_wait: Option<u64>,
@@ -1230,6 +1232,24 @@ impl BrowserConfig {
                 })?,
                 None => 30000,
             },
+            overall_timeout: match kwargs.get(ruby.to_symbol("overall_timeout")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `overall_timeout`: {}", e),
+                    )
+                })?,
+                None => 60000,
+            },
+            shutdown_timeout: match kwargs.get(ruby.to_symbol("shutdown_timeout")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `shutdown_timeout`: {}", e),
+                    )
+                })?,
+                None => 5000,
+            },
             wait: match kwargs.get(ruby.to_symbol("wait")) {
                 Some(v) => BrowserWait::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -1330,6 +1350,14 @@ impl BrowserConfig {
         self.timeout.clone()
     }
 
+    fn overall_timeout(&self) -> u64 {
+        self.overall_timeout.clone()
+    }
+
+    fn shutdown_timeout(&self) -> u64 {
+        self.shutdown_timeout.clone()
+    }
+
     fn wait(&self) -> BrowserWait {
         self.wait.clone()
     }
@@ -3582,6 +3610,7 @@ pub struct ContentConfig {
     wrap: bool,
     wrap_width: usize,
     include_document_structure: bool,
+    extract_metadata: bool,
 }
 
 unsafe impl IntoValueFromNative for ContentConfig {}
@@ -3741,6 +3770,15 @@ impl ContentConfig {
                 })?,
                 None => true,
             },
+            extract_metadata: match kwargs.get(ruby.to_symbol("extract_metadata")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `extract_metadata`: {}", e),
+                    )
+                })?,
+                None => true,
+            },
         })
     }
 
@@ -3791,6 +3829,10 @@ impl ContentConfig {
     fn include_document_structure(&self) -> bool {
         self.include_document_structure
     }
+
+    fn extract_metadata(&self) -> bool {
+        self.extract_metadata
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -4041,6 +4083,7 @@ pub struct ConversionOptions {
     max_depth: Option<usize>,
     exclude_selectors: Vec<String>,
     tier_strategy: TierStrategy,
+    base_url: Option<String>,
 }
 
 unsafe impl IntoValueFromNative for ConversionOptions {}
@@ -4471,6 +4514,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,
+            },
         })
     }
 
@@ -4645,6 +4697,10 @@ impl ConversionOptions {
     fn tier_strategy(&self) -> TierStrategy {
         self.tier_strategy.clone()
     }
+
+    fn base_url(&self) -> Option<String> {
+        self.base_url.clone()
+    }
 }
 
 #[cfg(feature = "office")]
@@ -4933,6 +4989,10 @@ pub struct CrawlConfig {
     allow_subdomains: bool,
     include_paths: Vec<String>,
     exclude_paths: Vec<String>,
+    path_patterns_match_query: bool,
+    dedup_include_query: bool,
+    strip_tracking_params: bool,
+    tracking_params: Vec<String>,
     custom_headers: HashMap<String, String>,
     #[serde(default = "default_timeout")]
     request_timeout: u64,
@@ -4940,6 +5000,9 @@ pub struct CrawlConfig {
     max_redirects: usize,
     retry_count: usize,
     retry_codes: Vec<u16>,
+    retry_initial_delay_ms: u64,
+    retry_max_delay_ms: u64,
+    rate_limit_jitter_ratio: f64,
     cookies_enabled: bool,
     auth: Option<AuthConfig>,
     max_body_size: Option<usize>,
@@ -5144,6 +5207,47 @@ impl CrawlConfig {
                 })?,
                 None => Default::default(),
             },
+            path_patterns_match_query: match kwargs.get(ruby.to_symbol("path_patterns_match_query")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `path_patterns_match_query`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            dedup_include_query: match kwargs.get(ruby.to_symbol("dedup_include_query")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `dedup_include_query`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            strip_tracking_params: match kwargs.get(ruby.to_symbol("strip_tracking_params")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `strip_tracking_params`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
+            tracking_params: match kwargs.get(ruby.to_symbol("tracking_params")) {
+                Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `tracking_params`: {}", e),
+                    )
+                })?,
+                None => vec![
+                    "utm_*".to_string(),
+                    "fbclid".to_string(),
+                    "gclid".to_string(),
+                    "ref".to_string(),
+                ],
+            },
             custom_headers: match kwargs.get(ruby.to_symbol("custom_headers")) {
                 Some(v) => <HashMap<String, String>>::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -5198,6 +5302,33 @@ impl CrawlConfig {
                 })?,
                 None => Default::default(),
             },
+            retry_initial_delay_ms: match kwargs.get(ruby.to_symbol("retry_initial_delay_ms")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `retry_initial_delay_ms`: {}", e),
+                    )
+                })?,
+                None => 100,
+            },
+            retry_max_delay_ms: match kwargs.get(ruby.to_symbol("retry_max_delay_ms")) {
+                Some(v) => u64::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `retry_max_delay_ms`: {}", e),
+                    )
+                })?,
+                None => 60000,
+            },
+            rate_limit_jitter_ratio: match kwargs.get(ruby.to_symbol("rate_limit_jitter_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 `rate_limit_jitter_ratio`: {}", e),
+                    )
+                })?,
+                None => 0.0,
+            },
             cookies_enabled: match kwargs.get(ruby.to_symbol("cookies_enabled")) {
                 Some(v) => bool::try_convert(v).map_err(|e| {
                     magnus::Error::new(
@@ -5504,6 +5635,22 @@ impl CrawlConfig {
         self.exclude_paths.clone()
     }
 
+    fn path_patterns_match_query(&self) -> bool {
+        self.path_patterns_match_query
+    }
+
+    fn dedup_include_query(&self) -> bool {
+        self.dedup_include_query
+    }
+
+    fn strip_tracking_params(&self) -> bool {
+        self.strip_tracking_params
+    }
+
+    fn tracking_params(&self) -> Vec<String> {
+        self.tracking_params.clone()
+    }
+
     fn custom_headers(&self) -> HashMap<String, String> {
         self.custom_headers.clone()
     }
@@ -5528,6 +5675,18 @@ impl CrawlConfig {
         self.retry_codes.clone()
     }
 
+    fn retry_initial_delay_ms(&self) -> u64 {
+        self.retry_initial_delay_ms
+    }
+
+    fn retry_max_delay_ms(&self) -> u64 {
+        self.retry_max_delay_ms
+    }
+
+    fn rate_limit_jitter_ratio(&self) -> f64 {
+        self.rate_limit_jitter_ratio
+    }
+
     fn cookies_enabled(&self) -> bool {
         self.cookies_enabled
     }
@@ -17266,6 +17425,7 @@ pub struct ImagePreprocessingConfig {
     contrast_enhance: bool,
     binarization_method: String,
     invert_colors: bool,
+    normalize_shaded_rows: bool,
 }
 
 unsafe impl IntoValueFromNative for ImagePreprocessingConfig {}
@@ -17380,6 +17540,15 @@ impl ImagePreprocessingConfig {
                 })?,
                 None => false,
             },
+            normalize_shaded_rows: match kwargs.get(ruby.to_symbol("normalize_shaded_rows")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `normalize_shaded_rows`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
         })
     }
 
@@ -17410,6 +17579,10 @@ impl ImagePreprocessingConfig {
     fn invert_colors(&self) -> bool {
         self.invert_colors
     }
+
+    fn normalize_shaded_rows(&self) -> bool {
+        self.normalize_shaded_rows
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
@@ -21932,6 +22105,7 @@ pub struct OcrConfig {
     security_limits: Option<SecurityLimits>,
     tessdata_bytes: Option<HashMap<String, Vec<u8>>>,
     tessdata_path: Option<String>,
+    numeric_repair: bool,
 }
 
 unsafe impl IntoValueFromNative for OcrConfig {}
@@ -22145,6 +22319,15 @@ impl OcrConfig {
                 })?),
                 None => None,
             },
+            numeric_repair: match kwargs.get(ruby.to_symbol("numeric_repair")) {
+                Some(v) => bool::try_convert(v).map_err(|e| {
+                    magnus::Error::new(
+                        unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
+                        format!("invalid value for `numeric_repair`: {}", e),
+                    )
+                })?,
+                None => false,
+            },
         })
     }
 
@@ -22219,6 +22402,10 @@ impl OcrConfig {
     fn tessdata_path(&self) -> Option<String> {
         self.tessdata_path.clone()
     }
+
+    fn numeric_repair(&self) -> bool {
+        self.numeric_repair
+    }
 }
 
 #[derive(Clone, Debug, serde::Serialize)]
@@ -32956,7 +33143,7 @@ pub struct TesseractConfig {
     tessedit_char_blacklist: String,
     tessedit_use_primary_params_model: bool,
     textord_space_size_is_variable: bool,
-    thresholding_method: bool,
+    thresholding_method: i32,
 }
 
 unsafe impl IntoValueFromNative for TesseractConfig {}
@@ -33189,13 +33376,13 @@ impl TesseractConfig {
                 None => true,
             },
             thresholding_method: match kwargs.get(ruby.to_symbol("thresholding_method")) {
-                Some(v) => bool::try_convert(v).map_err(|e| {
+                Some(v) => i32::try_convert(v).map_err(|e| {
                     magnus::Error::new(
                         unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
                         format!("invalid value for `thresholding_method`: {}", e),
                     )
                 })?,
-                None => false,
+                None => 0,
             },
         })
     }
@@ -33280,7 +33467,7 @@ impl TesseractConfig {
         self.textord_space_size_is_variable
     }
 
-    fn thresholding_method(&self) -> bool {
+    fn thresholding_method(&self) -> i32 {
         self.thresholding_method
     }
 }
@@ -42549,6 +42736,31 @@ fn list_ocr_backend_capabilities() -> Result<Vec<OcrBackendCapabilities>, Error>
     Ok(result.into_iter().map(Into::into).collect())
 }
 
+fn list_ocr_backend_capabilities_for(args: &[magnus::Value]) -> Result<Vec<OcrBackendCapabilities>, Error> {
+    let args = magnus::scan_args::scan_args::<(), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (config,) = args.optional;
+
+    let config_core: xberg::OcrConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: OcrConfig = OcrConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let result = xberg::list_ocr_backend_capabilities_for(&config_core).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result.into_iter().map(Into::into).collect())
+}
+
 fn list_ocr_backends() -> Result<Vec<String>, Error> {
     let result = xberg::list_ocr_backends().map_err(|e| {
         magnus::Error::new(
@@ -42734,6 +42946,57 @@ fn ocr_backend_supports_language(backend: String, language: String) -> Result<bo
     Ok(result)
 }
 
+fn ocr_backend_supports_language_for(args: &[magnus::Value]) -> Result<bool, Error> {
+    let args = magnus::scan_args::scan_args::<(String, String), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (backend, language) = args.required;
+
+    let (config,) = args.optional;
+
+    let config_core: xberg::OcrConfig = match config {
+        Some(_v) if !_v.is_nil() => {
+            let binding_val: OcrConfig = OcrConfig::try_convert(_v).map_err(|e| {
+                magnus::Error::new(
+                    unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+                    e.to_string(),
+                )
+            })?;
+            binding_val.into()
+        }
+        _ => Default::default(),
+    };
+    let result = xberg::ocr_backend_supports_language_for(&backend, &language, &config_core).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
+#[cfg(feature = "pdf")]
+fn pdf_page_count(args: &[magnus::Value]) -> Result<usize, Error> {
+    let args = magnus::scan_args::scan_args::<(Vec<u8>,), (Option<magnus::Value>,), (), (), (), ()>(args)?;
+    let (pdf_bytes,) = args.required;
+
+    let (password,) = args.optional;
+
+    let password: Option<String> = password.and_then(|v| {
+        if v.is_nil() {
+            None
+        } else {
+            Some(String::try_convert(v).unwrap_or_default())
+        }
+    });
+
+    let result = xberg::pdf_page_count(&pdf_bytes, password.as_deref()).map_err(|e| {
+        magnus::Error::new(
+            unsafe { Ruby::get_unchecked() }.exception_runtime_error(),
+            e.to_string(),
+        )
+    })?;
+    Ok(result)
+}
+
 #[cfg(feature = "markdown-footnotes")]
 fn verify_excerpt(excerpt: String, source_text: String) -> bool {
     xberg::verify_excerpt(&excerpt, &source_text)
@@ -42842,6 +43105,8 @@ pub struct RbOcrBackendBridge {
     cached_name: String,
     has_process_image_file: bool,
     has_supported_languages: bool,
+    has_supported_languages_for: bool,
+    has_supports_language_for: bool,
     has_supports_table_detection: bool,
     has_supports_document_processing: bool,
     has_emits_structured_markdown: bool,
@@ -42894,6 +43159,8 @@ impl RbOcrBackendBridge {
             runtime_dispatcher,
             has_process_image_file: rb_obj.respond_to("process_image_file", false).unwrap_or(false),
             has_supported_languages: rb_obj.respond_to("supported_languages", false).unwrap_or(false),
+            has_supported_languages_for: rb_obj.respond_to("supported_languages_for", false).unwrap_or(false),
+            has_supports_language_for: rb_obj.respond_to("supports_language_for", false).unwrap_or(false),
             has_supports_table_detection: rb_obj.respond_to("supports_table_detection", false).unwrap_or(false),
             has_supports_document_processing: rb_obj
                 .respond_to("supports_document_processing", false)
@@ -43220,6 +43487,88 @@ impl xberg::OcrBackend for RbOcrBackendBridge {
         }
     }
 
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        if !(self.has_supported_languages_for) {
+            return RbOcrBackendBridgeDefaultSupportedLanguagesFor(self).supported_languages_for(config);
+        }
+        let config = config.clone();
+        let callback = move |ruby: &magnus::Ruby, value: magnus::Value| -> Vec<String> {
+            let val: magnus::Value = match value.funcall::<_, _, magnus::Value>(
+                "supported_languages_for",
+                ({
+                    use magnus::IntoValue;
+                    OcrConfig::from(config.clone()).into_value_with(&ruby)
+                },),
+            ) {
+                Ok(v) => v,
+                Err(e) => {
+                    // This method's Rust signature is infallible, so a Ruby exception cannot
+                    // propagate. Log before substituting the default — a silent default is
+                    // indistinguishable from a real result to the caller.
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", error = %e, "host callback raised; returning default");
+                    return Default::default();
+                }
+            };
+            <Vec<String> as magnus::TryConvert>::try_convert(val).unwrap_or_else(|e| {
+                tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", error = %e, "host returned an unconvertible value; returning default");
+                Default::default()
+            })
+        };
+        match magnus::Ruby::get() {
+            Ok(ruby) => callback(&ruby, self.inner.get_inner_with(&ruby)),
+            Err(_) => match self.runtime_dispatcher.dispatch(callback) {
+                Ok(result) => result,
+                Err(error) => {
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supported_languages_for", %error, "Ruby runtime dispatcher failed; returning default");
+                    Default::default()
+                }
+            },
+        }
+    }
+
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        if !(self.has_supports_language_for) {
+            return RbOcrBackendBridgeDefaultSupportsLanguageFor(self).supports_language_for(config, language);
+        }
+        let config = config.clone();
+        let language = language.to_string();
+        let callback = move |ruby: &magnus::Ruby, value: magnus::Value| -> bool {
+            let val: magnus::Value = match value.funcall::<_, _, magnus::Value>(
+                "supports_language_for",
+                (
+                    {
+                        use magnus::IntoValue;
+                        OcrConfig::from(config.clone()).into_value_with(&ruby)
+                    },
+                    ruby.str_new(AsRef::<str>::as_ref(&language)).as_value(),
+                ),
+            ) {
+                Ok(v) => v,
+                Err(e) => {
+                    // This method's Rust signature is infallible, so a Ruby exception cannot
+                    // propagate. Log before substituting the default — a silent default is
+                    // indistinguishable from a real result to the caller.
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", error = %e, "host callback raised; returning default");
+                    return Default::default();
+                }
+            };
+            <bool as magnus::TryConvert>::try_convert(val).unwrap_or_else(|e| {
+                tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", error = %e, "host returned an unconvertible value; returning default");
+                Default::default()
+            })
+        };
+        match magnus::Ruby::get() {
+            Ok(ruby) => callback(&ruby, self.inner.get_inner_with(&ruby)),
+            Err(_) => match self.runtime_dispatcher.dispatch(callback) {
+                Ok(result) => result,
+                Err(error) => {
+                    tracing::warn!(wrapper = "RbOcrBackendBridge", method = "supports_language_for", %error, "Ruby runtime dispatcher failed; returning default");
+                    Default::default()
+                }
+            },
+        }
+    }
+
     fn supports_table_detection(&self) -> bool {
         if !(self.has_supports_table_detection) {
             return RbOcrBackendBridgeDefaultSupportsTableDetection(self).supports_table_detection();
@@ -43502,6 +43851,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultProcessImageFile<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43570,6 +43925,160 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportedLanguages<'_> {
     fn backend_type(&self) -> xberg::OcrBackendType {
         xberg::OcrBackend::backend_type(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
+    fn supports_table_detection(&self) -> bool {
+        xberg::OcrBackend::supports_table_detection(self.0)
+    }
+    fn supports_document_processing(&self) -> bool {
+        xberg::OcrBackend::supports_document_processing(self.0)
+    }
+    fn emits_structured_markdown(&self) -> bool {
+        xberg::OcrBackend::emits_structured_markdown(self.0)
+    }
+    fn confidence_semantics(&self) -> xberg::ConfidenceSemantics {
+        xberg::OcrBackend::confidence_semantics(self.0)
+    }
+    fn page_orientation_handling(&self) -> xberg::PageOrientationHandling {
+        xberg::OcrBackend::page_orientation_handling(self.0)
+    }
+    async fn process_document(
+        &self,
+        _path: &std::path::Path,
+        _config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_document(self.0, _path, _config).await
+    }
+}
+
+/// Runs `supported_languages_for`'s Rust default body for [`RbOcrBackendBridge`] while routing
+/// every other trait method back through the bridge, so the default body's `self.*`
+/// calls still reach host overrides.
+#[derive(Debug)]
+struct RbOcrBackendBridgeDefaultSupportedLanguagesFor<'a>(&'a RbOcrBackendBridge);
+impl xberg::plugins::Plugin for RbOcrBackendBridgeDefaultSupportedLanguagesFor<'_> {
+    fn name(&self) -> &str {
+        xberg::plugins::Plugin::name(self.0)
+    }
+
+    fn version(&self) -> String {
+        xberg::plugins::Plugin::version(self.0)
+    }
+
+    fn initialize(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::initialize(self.0)
+    }
+
+    fn shutdown(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::shutdown(self.0)
+    }
+}
+#[async_trait::async_trait]
+impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportedLanguagesFor<'_> {
+    async fn process_image(
+        &self,
+        image_bytes: &[u8],
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image(self.0, image_bytes, config).await
+    }
+    async fn process_image_file(
+        &self,
+        path: &std::path::Path,
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image_file(self.0, path, config).await
+    }
+    fn supports_language(&self, lang: &str) -> bool {
+        xberg::OcrBackend::supports_language(self.0, lang)
+    }
+    fn backend_type(&self) -> xberg::OcrBackendType {
+        xberg::OcrBackend::backend_type(self.0)
+    }
+    fn supported_languages(&self) -> Vec<String> {
+        xberg::OcrBackend::supported_languages(self.0)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
+    fn supports_table_detection(&self) -> bool {
+        xberg::OcrBackend::supports_table_detection(self.0)
+    }
+    fn supports_document_processing(&self) -> bool {
+        xberg::OcrBackend::supports_document_processing(self.0)
+    }
+    fn emits_structured_markdown(&self) -> bool {
+        xberg::OcrBackend::emits_structured_markdown(self.0)
+    }
+    fn confidence_semantics(&self) -> xberg::ConfidenceSemantics {
+        xberg::OcrBackend::confidence_semantics(self.0)
+    }
+    fn page_orientation_handling(&self) -> xberg::PageOrientationHandling {
+        xberg::OcrBackend::page_orientation_handling(self.0)
+    }
+    async fn process_document(
+        &self,
+        _path: &std::path::Path,
+        _config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_document(self.0, _path, _config).await
+    }
+}
+
+/// Runs `supports_language_for`'s Rust default body for [`RbOcrBackendBridge`] while routing
+/// every other trait method back through the bridge, so the default body's `self.*`
+/// calls still reach host overrides.
+#[derive(Debug)]
+struct RbOcrBackendBridgeDefaultSupportsLanguageFor<'a>(&'a RbOcrBackendBridge);
+impl xberg::plugins::Plugin for RbOcrBackendBridgeDefaultSupportsLanguageFor<'_> {
+    fn name(&self) -> &str {
+        xberg::plugins::Plugin::name(self.0)
+    }
+
+    fn version(&self) -> String {
+        xberg::plugins::Plugin::version(self.0)
+    }
+
+    fn initialize(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::initialize(self.0)
+    }
+
+    fn shutdown(&self) -> std::result::Result<(), xberg::XbergError> {
+        xberg::plugins::Plugin::shutdown(self.0)
+    }
+}
+#[async_trait::async_trait]
+impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsLanguageFor<'_> {
+    async fn process_image(
+        &self,
+        image_bytes: &[u8],
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image(self.0, image_bytes, config).await
+    }
+    async fn process_image_file(
+        &self,
+        path: &std::path::Path,
+        config: &xberg::OcrConfig,
+    ) -> std::result::Result<xberg::ExtractedDocument, xberg::XbergError> {
+        xberg::OcrBackend::process_image_file(self.0, path, config).await
+    }
+    fn supports_language(&self, lang: &str) -> bool {
+        xberg::OcrBackend::supports_language(self.0, lang)
+    }
+    fn backend_type(&self) -> xberg::OcrBackendType {
+        xberg::OcrBackend::backend_type(self.0)
+    }
+    fn supported_languages(&self) -> Vec<String> {
+        xberg::OcrBackend::supported_languages(self.0)
+    }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43641,6 +44150,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsTableDetection<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_document_processing(&self) -> bool {
         xberg::OcrBackend::supports_document_processing(self.0)
     }
@@ -43709,6 +44224,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultSupportsDocumentProcessing<'
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43777,6 +44298,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultEmitsStructuredMarkdown<'_>
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43845,6 +44372,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultConfidenceSemantics<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43913,6 +44446,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultPageOrientationHandling<'_>
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -43981,6 +44520,12 @@ impl xberg::OcrBackend for RbOcrBackendBridgeDefaultProcessDocument<'_> {
     fn supported_languages(&self) -> Vec<String> {
         xberg::OcrBackend::supported_languages(self.0)
     }
+    fn supported_languages_for(&self, config: &xberg::OcrConfig) -> Vec<String> {
+        xberg::OcrBackend::supported_languages_for(self.0, config)
+    }
+    fn supports_language_for(&self, config: &xberg::OcrConfig, language: &str) -> bool {
+        xberg::OcrBackend::supports_language_for(self.0, config, language)
+    }
     fn supports_table_detection(&self) -> bool {
         xberg::OcrBackend::supports_table_detection(self.0)
     }
@@ -47128,6 +47673,8 @@ impl From<BrowserConfig> for crawlberg::BrowserConfig {
             backend: val.backend.into(),
             endpoint: val.endpoint,
             timeout: std::time::Duration::from_millis(val.timeout),
+            overall_timeout: std::time::Duration::from_millis(val.overall_timeout),
+            shutdown_timeout: std::time::Duration::from_millis(val.shutdown_timeout),
             wait: val.wait.into(),
             wait_selector: val.wait_selector,
             extra_wait: val.extra_wait.map(std::time::Duration::from_millis),
@@ -47150,6 +47697,8 @@ impl From<crawlberg::BrowserConfig> for BrowserConfig {
             backend: val.backend.into(),
             endpoint: val.endpoint.map(|v| v.to_string()),
             timeout: val.timeout.as_millis() as u64,
+            overall_timeout: val.overall_timeout.as_millis() as u64,
+            shutdown_timeout: val.shutdown_timeout.as_millis() as u64,
             wait: val.wait.into(),
             wait_selector: val.wait_selector.map(|v| v.to_string()),
             extra_wait: val.extra_wait.map(|d| d.as_millis() as u64),
@@ -47611,6 +48160,7 @@ impl From<ContentConfig> for crawlberg::ContentConfig {
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             include_document_structure: val.include_document_structure,
+            extract_metadata: val.extract_metadata,
             ..Default::default()
         }
     }
@@ -47631,6 +48181,7 @@ impl From<crawlberg::ContentConfig> for ContentConfig {
             wrap: val.wrap,
             wrap_width: val.wrap_width,
             include_document_structure: val.include_document_structure,
+            extract_metadata: val.extract_metadata,
         }
     }
 }
@@ -47728,12 +48279,13 @@ impl From<ConversionOptions> for html_to_markdown_rs::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::ConversionOptions> for ConversionOptions {
     fn from(val: html_to_markdown_rs::ConversionOptions) -> Self {
         Self {
@@ -47780,6 +48332,7 @@ impl From<html_to_markdown_rs::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()),
         }
     }
 }
@@ -47853,6 +48406,10 @@ impl From<CrawlConfig> for crawlberg::CrawlConfig {
             allow_subdomains: val.allow_subdomains,
             include_paths: val.include_paths.into_iter().collect(),
             exclude_paths: val.exclude_paths.into_iter().collect(),
+            path_patterns_match_query: val.path_patterns_match_query,
+            dedup_include_query: val.dedup_include_query,
+            strip_tracking_params: val.strip_tracking_params,
+            tracking_params: val.tracking_params.into_iter().collect(),
             custom_headers: val
                 .custom_headers
                 .into_iter()
@@ -47863,6 +48420,9 @@ impl From<CrawlConfig> for crawlberg::CrawlConfig {
             max_redirects: val.max_redirects,
             retry_count: val.retry_count,
             retry_codes: val.retry_codes.into_iter().collect(),
+            retry_initial_delay_ms: val.retry_initial_delay_ms,
+            retry_max_delay_ms: val.retry_max_delay_ms,
+            rate_limit_jitter_ratio: val.rate_limit_jitter_ratio,
             cookies_enabled: val.cookies_enabled,
             auth: val.auth.map(Into::into),
             max_body_size: val.max_body_size,
@@ -47913,6 +48473,10 @@ impl From<crawlberg::CrawlConfig> for CrawlConfig {
             allow_subdomains: val.allow_subdomains,
             include_paths: val.include_paths.into_iter().collect(),
             exclude_paths: val.exclude_paths.into_iter().collect(),
+            path_patterns_match_query: val.path_patterns_match_query,
+            dedup_include_query: val.dedup_include_query,
+            strip_tracking_params: val.strip_tracking_params,
+            tracking_params: val.tracking_params.into_iter().collect(),
             custom_headers: val
                 .custom_headers
                 .into_iter()
@@ -47923,6 +48487,9 @@ impl From<crawlberg::CrawlConfig> for CrawlConfig {
             max_redirects: val.max_redirects,
             retry_count: val.retry_count,
             retry_codes: val.retry_codes.into_iter().collect(),
+            retry_initial_delay_ms: val.retry_initial_delay_ms,
+            retry_max_delay_ms: val.retry_max_delay_ms,
+            rate_limit_jitter_ratio: val.rate_limit_jitter_ratio,
             cookies_enabled: val.cookies_enabled,
             auth: val.auth.map(Into::into),
             max_body_size: val.max_body_size,
@@ -50074,6 +50641,7 @@ impl From<ImagePreprocessingConfig> for xberg::ImagePreprocessingConfig {
             contrast_enhance: val.contrast_enhance,
             binarization_method: val.binarization_method,
             invert_colors: val.invert_colors,
+            normalize_shaded_rows: val.normalize_shaded_rows,
             ..Default::default()
         }
     }
@@ -50089,6 +50657,7 @@ impl From<xberg::ImagePreprocessingConfig> for ImagePreprocessingConfig {
             contrast_enhance: val.contrast_enhance,
             binarization_method: val.binarization_method.to_string(),
             invert_colors: val.invert_colors,
+            normalize_shaded_rows: val.normalize_shaded_rows,
         }
     }
 }
@@ -51024,6 +51593,7 @@ impl From<OcrConfig> for xberg::OcrConfig {
                 .tessdata_bytes
                 .map(|m| m.into_iter().map(|(k, v)| (k, v.to_vec().into())).collect()),
             tessdata_path: val.tessdata_path.map(Into::into),
+            numeric_repair: val.numeric_repair,
             ..Default::default()
         }
     }
@@ -51053,6 +51623,7 @@ impl From<xberg::OcrConfig> for OcrConfig {
                 .tessdata_bytes
                 .map(|m| m.into_iter().map(|(k, v)| (k, v.to_vec().into())).collect()),
             tessdata_path: val.tessdata_path.map(|p| p.to_string_lossy().to_string()),
+            numeric_repair: val.numeric_repair,
         }
     }
 }
@@ -56254,6 +56825,10 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("timeout", method!(BrowserConfig::timeout, 0))?;
 
+    class.define_method("overall_timeout", method!(BrowserConfig::overall_timeout, 0))?;
+
+    class.define_method("shutdown_timeout", method!(BrowserConfig::shutdown_timeout, 0))?;
+
     class.define_method("wait", method!(BrowserConfig::wait, 0))?;
 
     class.define_method("wait_selector", method!(BrowserConfig::wait_selector, 0))?;
@@ -56591,6 +57166,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         method!(ContentConfig::include_document_structure, 0),
     )?;
 
+    class.define_method("extract_metadata", method!(ContentConfig::extract_metadata, 0))?;
+
     let class = module.define_class("ContentFilterConfig", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ContentFilterConfig::new, -1))?;
@@ -56715,6 +57292,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("CoreProperties", ruby.class_object())?;
 
     #[cfg(feature = "office")]
@@ -56799,6 +57378,17 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("exclude_paths", method!(CrawlConfig::exclude_paths, 0))?;
 
+    class.define_method(
+        "path_patterns_match_query",
+        method!(CrawlConfig::path_patterns_match_query, 0),
+    )?;
+
+    class.define_method("dedup_include_query", method!(CrawlConfig::dedup_include_query, 0))?;
+
+    class.define_method("strip_tracking_params", method!(CrawlConfig::strip_tracking_params, 0))?;
+
+    class.define_method("tracking_params", method!(CrawlConfig::tracking_params, 0))?;
+
     class.define_method("custom_headers", method!(CrawlConfig::custom_headers, 0))?;
 
     class.define_method("request_timeout", method!(CrawlConfig::request_timeout, 0))?;
@@ -56811,6 +57401,18 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("retry_codes", method!(CrawlConfig::retry_codes, 0))?;
 
+    class.define_method(
+        "retry_initial_delay_ms",
+        method!(CrawlConfig::retry_initial_delay_ms, 0),
+    )?;
+
+    class.define_method("retry_max_delay_ms", method!(CrawlConfig::retry_max_delay_ms, 0))?;
+
+    class.define_method(
+        "rate_limit_jitter_ratio",
+        method!(CrawlConfig::rate_limit_jitter_ratio, 0),
+    )?;
+
     class.define_method("cookies_enabled", method!(CrawlConfig::cookies_enabled, 0))?;
 
     class.define_method("auth", method!(CrawlConfig::auth, 0))?;
@@ -58479,6 +59081,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("invert_colors", method!(ImagePreprocessingConfig::invert_colors, 0))?;
 
+    class.define_method(
+        "normalize_shaded_rows",
+        method!(ImagePreprocessingConfig::normalize_shaded_rows, 0),
+    )?;
+
     let class = module.define_class("ImagePreprocessingMetadata", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(ImagePreprocessingMetadata::new, -1))?;
@@ -59107,6 +59714,8 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
 
     class.define_method("tessdata_path", method!(OcrConfig::tessdata_path, 0))?;
 
+    class.define_method("numeric_repair", method!(OcrConfig::numeric_repair, 0))?;
+
     let class = module.define_class("OcrElement", ruby.class_object())?;
 
     class.define_singleton_method("new", function!(OcrElement::new, -1))?;
@@ -61046,6 +61655,11 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         function!(list_ocr_backend_capabilities, 0),
     )?;
 
+    module.define_module_function(
+        "list_ocr_backend_capabilities_for",
+        function!(list_ocr_backend_capabilities_for, -1),
+    )?;
+
     module.define_module_function("list_ocr_backends", function!(list_ocr_backends, 0))?;
 
     module.define_module_function("list_post_processors", function!(list_post_processors, 0))?;
@@ -61080,6 +61694,14 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
         function!(ocr_backend_supports_language, 2),
     )?;
 
+    module.define_module_function(
+        "ocr_backend_supports_language_for",
+        function!(ocr_backend_supports_language_for, -1),
+    )?;
+
+    #[cfg(feature = "pdf")]
+    module.define_module_function("pdf_page_count", function!(pdf_page_count, -1))?;
+
     #[cfg(feature = "markdown-footnotes")]
     module.define_module_function("verify_excerpt", function!(verify_excerpt, 2))?;