kreuzberg 4.2.6 → 4.2.7

data/vendor/kreuzberg/tests/registry_integration_tests.rs

@@ -12,6 +12,7 @@ use kreuzberg::plugins::registry::{DocumentExtractorRegistry, ValidatorRegistry}
 use kreuzberg::plugins::{DocumentExtractor, Plugin, Validator};
 use kreuzberg::types::{ExtractionResult, Metadata};
 use kreuzberg::{KreuzbergError, Result};
+use std::borrow::Cow;
 use std::path::Path;
 use std::sync::Arc;
 
@@ -119,7 +120,7 @@ impl DocumentExtractor for MockExtractor {
     ) -> Result<ExtractionResult> {
         Ok(ExtractionResult {
             content: format!("Extracted by {}: {}", self.name, String::from_utf8_lossy(content)),
-            mime_type: mime_type.to_string(),
+            mime_type: Cow::Owned(mime_type.to_string()),
             metadata: Metadata::default(),
             tables: vec![],
             detected_languages: None,

data/vendor/kreuzberg-ffi/Cargo.toml

@@ -28,9 +28,10 @@ serde_json = { workspace = true }
 serde = { workspace = true }
 async-trait = { workspace = true }
 tokio = { workspace = true }
-html-to-markdown-rs = { version = "2.24.1", default-features = false }
+html-to-markdown-rs = { version = "2.24.4", default-features = false }
 rayon = { version = "1.11", optional = true }
 log = "0.4"
+ahash = "0.8"
 
 [target.'cfg(all(windows, target_env = "gnu"))'.dependencies]
 kreuzberg = { path = "../kreuzberg", features = [

data/vendor/kreuzberg-ffi/benches/result_view_benchmark.rs

@@ -1,6 +1,7 @@
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use kreuzberg::types::{Chunk, ChunkMetadata, ExtractionResult, Metadata, PageStructure, PageUnitType};
 use kreuzberg_ffi::{CExtractionResultView, kreuzberg_get_result_view};
+use std::borrow::Cow;
 use std::ffi::CString;
 use std::hint;
 use std::mem;
@@ -63,7 +64,7 @@ fn create_test_result(content_size: usize, chunk_count: usize) -> ExtractionResu
 
     ExtractionResult {
         content,
-        mime_type: "application/pdf".to_string(),
+        mime_type: Cow::Borrowed("application/pdf"),
         metadata,
         tables: vec![],
         detected_languages: Some(vec!["en".to_string(), "de".to_string()]),
@@ -109,7 +110,7 @@ fn bench_copy_based_approach(c: &mut Criterion) {
 
             b.iter(|| {
                 let content_cstr = CString::new(result.content.as_str()).unwrap();
-                let mime_cstr = CString::new(result.mime_type.as_str()).unwrap();
+                let mime_cstr = CString::new(&*result.mime_type).unwrap();
                 let language_cstr = result
                     .metadata
                     .language

data/vendor/kreuzberg-ffi/kreuzberg.h

@@ -1208,6 +1208,38 @@ const char *kreuzberg_error_code_description(uint32_t code);
  */
 struct CErrorDetails kreuzberg_get_error_details(void);
 
+/**
+ * Heap-allocated variant of `kreuzberg_get_error_details` that returns a pointer.
+ *
+ * This is the preferred variant for language bindings (Java, Go, C#) where
+ * returning structs by value across FFI boundaries causes ABI issues,
+ * particularly on ARM64.
+ *
+ * The returned pointer must be freed with `kreuzberg_free_error_details()`.
+ * Returns NULL if allocation fails.
+ *
+ * # C Signature
+ *
+ * ```c
+ * CErrorDetails* kreuzberg_get_error_details_ptr(void);
+ * ```
+ */
+struct CErrorDetails *kreuzberg_get_error_details_ptr(void);
+
+/**
+ * Frees a `CErrorDetails` pointer returned by `kreuzberg_get_error_details_ptr()`.
+ *
+ * This function frees all internal string fields and the struct itself.
+ * Passing NULL is a no-op.
+ *
+ * # C Signature
+ *
+ * ```c
+ * void kreuzberg_free_error_details(CErrorDetails* details);
+ * ```
+ */
+void kreuzberg_free_error_details(struct CErrorDetails *details);
+
 /**
  * Classifies an error based on the error message string.
  *

data/vendor/kreuzberg-ffi/src/error.rs

@@ -540,6 +540,62 @@ pub extern "C" fn kreuzberg_get_error_details() -> CErrorDetails {
     }
 }
 
+/// Heap-allocated variant of `kreuzberg_get_error_details` that returns a pointer.
+///
+/// This is the preferred variant for language bindings (Java, Go, C#) where
+/// returning structs by value across FFI boundaries causes ABI issues,
+/// particularly on ARM64.
+///
+/// The returned pointer must be freed with `kreuzberg_free_error_details()`.
+/// Returns NULL if allocation fails.
+///
+/// # C Signature
+///
+/// ```c
+/// CErrorDetails* kreuzberg_get_error_details_ptr(void);
+/// ```
+#[unsafe(no_mangle)]
+pub extern "C" fn kreuzberg_get_error_details_ptr() -> *mut CErrorDetails {
+    let details = kreuzberg_get_error_details();
+    Box::into_raw(Box::new(details))
+}
+
+/// Frees a `CErrorDetails` pointer returned by `kreuzberg_get_error_details_ptr()`.
+///
+/// This function frees all internal string fields and the struct itself.
+/// Passing NULL is a no-op.
+///
+/// # C Signature
+///
+/// ```c
+/// void kreuzberg_free_error_details(CErrorDetails* details);
+/// ```
+#[unsafe(no_mangle)]
+pub extern "C" fn kreuzberg_free_error_details(details: *mut CErrorDetails) {
+    if details.is_null() {
+        return;
+    }
+    unsafe {
+        let details = Box::from_raw(details);
+        // Free all non-null string fields
+        if !details.message.is_null() {
+            let _ = CString::from_raw(details.message);
+        }
+        if !details.error_type.is_null() {
+            let _ = CString::from_raw(details.error_type);
+        }
+        if !details.source_file.is_null() {
+            let _ = CString::from_raw(details.source_file);
+        }
+        if !details.source_function.is_null() {
+            let _ = CString::from_raw(details.source_function);
+        }
+        if !details.context_info.is_null() {
+            let _ = CString::from_raw(details.context_info);
+        }
+    }
+}
+
 /// Classifies an error based on the error message string.
 ///
 /// Analyzes an error message and attempts to classify it into one of the standard

data/vendor/kreuzberg-ffi/src/helpers.rs

@@ -81,7 +81,7 @@ pub fn to_c_extraction_result(result: ExtractionResult) -> std::result::Result<*
     );
 
     let mime_type_guard = CStringGuard::new(
-        CString::new(mime_type).map_err(|e| format!("Failed to convert MIME type to C string: {}", e))?,
+        CString::new(mime_type.to_string()).map_err(|e| format!("Failed to convert MIME type to C string: {}", e))?,
     );
 
     let language_guard = match &metadata.language {
@@ -213,6 +213,7 @@ pub fn to_c_extraction_result(result: ExtractionResult) -> std::result::Result<*
 mod tests {
     use super::*;
     use kreuzberg::types::{Chunk, ChunkMetadata, ExtractionResult, Metadata, Table};
+    use std::borrow::Cow;
     use std::ffi::CStr;
 
     #[test]
@@ -352,7 +353,7 @@ mod tests {
     fn test_to_c_extraction_result_basic() {
         let result = ExtractionResult {
             content: "Test content".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata: Metadata::default(),
             tables: vec![],
             detected_languages: None,
@@ -391,7 +392,7 @@ mod tests {
     fn test_to_c_extraction_result_with_null_bytes() {
         let result = ExtractionResult {
             content: "Test\0content with null".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata: Metadata::default(),
             tables: vec![],
             detected_languages: None,
@@ -440,7 +441,7 @@ mod tests {
 
         let result = ExtractionResult {
             content: "Test content".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata,
             tables: vec![],
             detected_languages: Some(vec!["en".to_string(), "de".to_string()]),
@@ -519,7 +520,7 @@ mod tests {
 
         let result = ExtractionResult {
             content: "Test content".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata: Metadata::default(),
             tables: vec![table],
             detected_languages: None,

data/vendor/kreuzberg-ffi/src/plugins/ocr_backend.rs

@@ -160,7 +160,7 @@ impl OcrBackend for FfiOcrBackend {
 
         Ok(ExtractionResult {
             content: result_text,
-            mime_type: "text/plain".to_string(),
+            mime_type: std::borrow::Cow::Borrowed("text/plain"),
             metadata: kreuzberg::types::Metadata::default(),
             tables: vec![],
             detected_languages: None,

data/vendor/kreuzberg-ffi/src/result.rs

@@ -368,6 +368,7 @@ pub unsafe extern "C" fn kreuzberg_result_get_metadata_field(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::borrow::Cow;
     use std::ffi::CStr;
 
     fn create_test_result() -> ExtractionResult {
@@ -389,7 +390,7 @@ mod tests {
 
         ExtractionResult {
             content: "Sample content for testing".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata,
             tables: vec![],
             detected_languages: Some(vec!["en".to_string(), "de".to_string()]),

data/vendor/kreuzberg-ffi/src/result_view.rs

@@ -398,6 +398,7 @@ pub unsafe extern "C" fn kreuzberg_view_get_mime_type(
 mod tests {
     use super::*;
     use kreuzberg::types::{Metadata, PageStructure, PageUnitType};
+    use std::borrow::Cow;
     use std::mem;
 
     fn create_test_result() -> ExtractionResult {
@@ -419,7 +420,7 @@ mod tests {
 
         ExtractionResult {
             content: "Sample content for zero-copy testing".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata,
             tables: vec![],
             detected_languages: Some(vec!["en".to_string(), "de".to_string()]),
@@ -712,7 +713,7 @@ mod tests {
     fn test_view_all_counts_zero() {
         let result = ExtractionResult {
             content: "Minimal content".to_string(),
-            mime_type: "text/plain".to_string(),
+            mime_type: Cow::Borrowed("text/plain"),
             metadata: Metadata::default(),
             tables: vec![],
             detected_languages: None,

data/vendor/kreuzberg-ffi/src/string_intern.rs

@@ -39,7 +39,7 @@
 //! ```
 
 use crate::{clear_last_error, set_last_error};
-use std::collections::HashMap;
+use ahash::AHashMap;
 use std::ffi::{CStr, CString};
 use std::os::raw::c_char;
 use std::ptr;
@@ -82,7 +82,7 @@ struct InternedString {
 /// Global string interning table.
 struct StringInternTable {
     /// Map from string content to interned entry
-    strings: HashMap<String, InternedString>,
+    strings: AHashMap<String, InternedString>,
 
     /// Total number of intern requests
     total_requests: usize,
@@ -95,7 +95,7 @@ impl StringInternTable {
     /// Create new intern table with pre-populated common strings.
     fn new() -> Self {
         let mut table = Self {
-            strings: HashMap::new(),
+            strings: AHashMap::new(),
             total_requests: 0,
             cache_hits: 0,
         };

data/vendor/kreuzberg-ffi/tests.disabled/config_loading_tests.rs

@@ -72,8 +72,8 @@ ocr:
   enabled: true
   backend: tesseract
 chunking:
-  max_chars: 1000
-  max_overlap: 100
+  max_characters: 1000
+  overlap: 100
 "#;
 
     fs::write(&config_path, yaml_content).unwrap();

data/vendor/kreuzberg-tesseract/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg-tesseract"
-version = "4.2.6"
+version = "4.2.7"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kreuzberg
 version: !ruby/object:Gem::Version
-  version: 4.2.6
+  version: 4.2.7
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-31 00:00:00.000000000 Z
+date: 2026-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler