kreuzberg 4.0.0.pre.rc.8 → 4.0.0.pre.rc.11

data/vendor/kreuzberg/src/embeddings.rs

@@ -11,6 +11,30 @@
 //! - Batch processing for efficient embedding generation
 //! - Optional GPU acceleration via ONNX Runtime execution providers
 //!
+//! # ONNX Runtime Requirement
+//!
+//! **CRITICAL**: This module requires ONNX Runtime to be installed on the system.
+//! The `embeddings` feature uses dynamic loading (`ort-load-dynamic`), which detects
+//! the ONNX Runtime library at runtime.
+//!
+//! ## Installation Instructions
+//!
+//! - **macOS**: `brew install onnxruntime`
+//! - **Linux (Ubuntu/Debian)**: `apt install libonnxruntime libonnxruntime-dev`
+//! - **Linux (Fedora)**: `dnf install onnxruntime onnxruntime-devel`
+//! - **Linux (Arch)**: `pacman -S onnxruntime`
+//! - **Windows (MSVC)**: Download from https://github.com/microsoft/onnxruntime/releases and add to PATH
+//!
+//! Alternatively, set the `ORT_DYLIB_PATH` environment variable to the ONNX Runtime library path.
+//!
+//! For Docker/containers, install via package manager in your base image.
+//! Verified packages: Ubuntu 22.04+, Fedora 38+, Arch Linux.
+//!
+//! ## Platform Limitations
+//!
+//! **Windows MinGW builds are not supported**. ONNX Runtime requires the MSVC toolchain on Windows.
+//! Please use Windows MSVC builds or disable the embeddings feature.
+//!
 //! # Example
 //!
 //! ```rust,ignore
@@ -145,6 +169,35 @@ lazy_static! {
     static ref MODEL_CACHE: RwLock<HashMap<String, CachedEmbedding>> = RwLock::new(HashMap::new());
 }
 
+/// Returns installation instructions for ONNX Runtime.
+#[cfg(feature = "embeddings")]
+fn onnx_runtime_install_message() -> String {
+    #[cfg(all(windows, target_env = "gnu"))]
+    {
+        return "ONNX Runtime embeddings are not supported on Windows MinGW builds. \
+        ONNX Runtime requires MSVC toolchain. \
+        Please use Windows MSVC builds or disable embeddings feature."
+            .to_string();
+    }
+
+    #[cfg(not(all(windows, target_env = "gnu")))]
+    {
+        "ONNX Runtime is required for embeddings functionality. \
+        Install: \
+        macOS: 'brew install onnxruntime', \
+        Linux (Ubuntu/Debian): 'apt install libonnxruntime libonnxruntime-dev', \
+        Linux (Fedora): 'dnf install onnxruntime onnxruntime-devel', \
+        Linux (Arch): 'pacman -S onnxruntime', \
+        Windows (MSVC): Download from https://github.com/microsoft/onnxruntime/releases and add to PATH. \
+        \
+        Alternatively, set ORT_DYLIB_PATH environment variable to the ONNX Runtime library path. \
+        \
+        For Docker/containers: Install via package manager in your base image. \
+        Verified packages: Ubuntu 22.04+, Fedora 38+, Arch Linux."
+            .to_string()
+    }
+}
+
 /// Get or initialize a text embedding model from cache.
 ///
 /// This function ensures models are initialized only once and reused across
@@ -193,9 +246,24 @@ pub fn get_or_init_model(
         let mut init_options = InitOptions::new(model);
         init_options = init_options.with_cache_dir(cache_directory);
 
-        let embedding_model = TextEmbedding::try_new(init_options).map_err(|e| crate::KreuzbergError::Plugin {
-            message: format!("Failed to initialize embedding model: {}", e),
-            plugin_name: "embeddings".to_string(),
+        let embedding_model = TextEmbedding::try_new(init_options).map_err(|e| {
+            let error_msg = e.to_string();
+
+            // Detect ONNX Runtime loading errors by checking for common patterns
+            if error_msg.contains("onnxruntime")
+                || error_msg.contains("ORT")
+                || error_msg.contains("libonnxruntime")
+                || error_msg.contains("onnxruntime.dll")
+                || error_msg.contains("Unable to load")
+                || error_msg.contains("library load failed")
+            {
+                crate::KreuzbergError::MissingDependency(format!("ONNX Runtime - {}", onnx_runtime_install_message()))
+            } else {
+                crate::KreuzbergError::Plugin {
+                    message: format!("Failed to initialize embedding model: {}", e),
+                    plugin_name: "embeddings".to_string(),
+                }
+            }
         })?;
 
         let leaked_model = LeakedModel::new(embedding_model);

data/vendor/kreuzberg/src/error.rs

@@ -177,7 +177,7 @@ impl From<crate::pdf::error::PdfError> for KreuzbergError {
 
 macro_rules! error_constructor {
     ($name:ident, $variant:ident) => {
-        paste::paste! {
+        pastey::paste! {
             #[doc = "Create a " $variant " error"]
             pub fn $name<S: Into<String>>(message: S) -> Self {
                 Self::$variant {

data/vendor/kreuzberg/src/extraction/html.rs

@@ -31,14 +31,26 @@ use html_to_markdown_rs::{
     convert as convert_html, convert_with_inline_images,
 };
 use serde::{Deserialize, Serialize};
-use std::{any::Any, collections::HashMap, thread};
+use std::collections::HashMap;
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::{any::Any, thread};
 
 pub use html_to_markdown_rs::{
     CodeBlockStyle, HeadingStyle, HighlightStyle, ListIndentType, NewlineStyle, PreprocessingOptions,
     PreprocessingPreset, WhitespaceMode,
 };
 
+// WASM has a much smaller stack, so we need a lower threshold
+// In practice, WASM can't spawn threads anyway, so this threshold doesn't help much
+// We set it very high to avoid the overhead of the "large stack" path which is a no-op in WASM
+#[cfg(target_arch = "wasm32")]
+const LARGE_HTML_STACK_THRESHOLD_BYTES: usize = usize::MAX;
+
+#[cfg(not(target_arch = "wasm32"))]
 const LARGE_HTML_STACK_THRESHOLD_BYTES: usize = 512 * 1024;
+
+#[cfg(not(target_arch = "wasm32"))]
 const HTML_CONVERSION_STACK_SIZE_BYTES: usize = 16 * 1024 * 1024;
 
 /// Result of HTML extraction with optional images and warnings.
@@ -132,10 +144,6 @@ fn convert_html_with_options(html: &str, options: ConversionOptions) -> Result<S
         .map_err(|e| KreuzbergError::parsing(format!("Failed to convert HTML to Markdown: {}", e)))
 }
 
-fn convert_html_with_options_large_stack(html: String, options: ConversionOptions) -> Result<String> {
-    run_on_dedicated_stack(move || convert_html_with_options(&html, options))
-}
-
 fn convert_inline_images_with_options(
     html: &str,
     options: ConversionOptions,
@@ -145,6 +153,13 @@ fn convert_inline_images_with_options(
         .map_err(|e| KreuzbergError::parsing(format!("Failed to convert HTML to Markdown with images: {}", e)))
 }
 
+// Native (non-WASM) implementations use dedicated thread stack for large HTML documents
+#[cfg(not(target_arch = "wasm32"))]
+fn convert_html_with_options_large_stack(html: String, options: ConversionOptions) -> Result<String> {
+    run_on_dedicated_stack(move || convert_html_with_options(&html, options))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
 fn convert_inline_images_with_large_stack(
     html: String,
     options: ConversionOptions,
@@ -153,6 +168,7 @@ fn convert_inline_images_with_large_stack(
     run_on_dedicated_stack(move || convert_inline_images_with_options(&html, options, image_config))
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn run_on_dedicated_stack<T, F>(job: F) -> Result<T>
 where
     T: Send + 'static,
@@ -173,6 +189,7 @@ where
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 fn extract_panic_reason(panic: &Box<dyn Any + Send + 'static>) -> String {
     if let Some(msg) = panic.downcast_ref::<&str>() {
         (*msg).to_string()
@@ -183,6 +200,21 @@ fn extract_panic_reason(panic: &Box<dyn Any + Send + 'static>) -> String {
     }
 }
 
+// WASM implementations skip dedicated stack (not supported) and process inline
+#[cfg(target_arch = "wasm32")]
+fn convert_html_with_options_large_stack(html: String, options: ConversionOptions) -> Result<String> {
+    convert_html_with_options(&html, options)
+}
+
+#[cfg(target_arch = "wasm32")]
+fn convert_inline_images_with_large_stack(
+    html: String,
+    options: ConversionOptions,
+    image_config: LibInlineImageConfig,
+) -> Result<HtmlExtraction> {
+    convert_inline_images_with_options(&html, options, image_config)
+}
+
 /// Convert HTML to markdown with optional configuration.
 ///
 /// Uses sensible defaults if no configuration is provided:

data/vendor/kreuzberg/src/extractors/pdf.rs

@@ -325,19 +325,33 @@ impl DocumentExtractor for PdfExtractor {
         config: &ExtractionConfig,
     ) -> Result<ExtractionResult> {
         #[cfg(feature = "pdf")]
-        let (pdf_metadata, native_text, tables, page_contents) = if crate::core::batch_mode::is_batch_mode() {
-            let content_owned = content.to_vec();
-            let span = tracing::Span::current();
-            let pages_config = config.pages.clone();
-            tokio::task::spawn_blocking(move || {
-                let _guard = span.entered();
-                let bindings = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
-                    .or_else(|_| Pdfium::bind_to_system_library())
-                    .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
-
+        let (pdf_metadata, native_text, tables, page_contents) = {
+            // WASM target: always synchronous (no tokio::task::spawn_blocking)
+            // Other targets: use spawn_blocking in batch mode for better parallelism
+            #[cfg(target_arch = "wasm32")]
+            {
+                // SAFETY: For WASM targets, this code path should only be reached if the
+                // WASM environment has properly initialized PDFium. The error message
+                // will direct users to the documentation for setup requirements.
+                let bindings =
+                    crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")
+                        .map_err(|pdf_err| {
+                            // Provide context-specific error for WASM PDF failures
+                            if pdf_err.to_string().contains("WASM") || pdf_err.to_string().contains("Module") {
+                                crate::error::KreuzbergError::Parsing {
+                                    message: "PDF extraction requires proper WASM module initialization. \
+                                         Ensure your WASM environment is set up with PDFium support. \
+                                         See: https://docs.kreuzberg.dev/wasm/pdf"
+                                        .to_string(),
+                                    source: None,
+                                }
+                            } else {
+                                pdf_err.into()
+                            }
+                        })?;
                 let pdfium = Pdfium::new(bindings);
 
-                let document = pdfium.load_pdf_from_byte_slice(&content_owned, None).map_err(|e| {
+                let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
                     let err_msg = e.to_string();
                     if err_msg.contains("password") || err_msg.contains("Password") {
                         PdfError::PasswordRequired
@@ -347,51 +361,86 @@ impl DocumentExtractor for PdfExtractor {
                 })?;
 
                 let (native_text, boundaries, page_contents) =
-                    crate::pdf::text::extract_text_from_pdf_document(&document, pages_config.as_ref())?;
+                    crate::pdf::text::extract_text_from_pdf_document(&document, config.pages.as_ref())?;
 
                 let pdf_metadata =
                     crate::pdf::metadata::extract_metadata_from_document(&document, boundaries.as_deref())?;
 
                 let tables = extract_tables_from_document(&document, &pdf_metadata)?;
 
-                if let Some(ref page_cfg) = pages_config
-                    && page_cfg.extract_pages
-                    && page_contents.is_none()
-                {
-                    return Err(PdfError::ExtractionFailed(
-                        "Page extraction was configured but no page data was extracted in batch mode".to_string(),
-                    )
-                    .into());
-                }
-
-                Ok::<_, crate::error::KreuzbergError>((pdf_metadata, native_text, tables, page_contents))
-            })
-            .await
-            .map_err(|e| crate::error::KreuzbergError::Other(format!("PDF extraction task failed: {}", e)))??
-        } else {
-            let bindings = Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path("./"))
-                .or_else(|_| Pdfium::bind_to_system_library())
-                .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+                (pdf_metadata, native_text, tables, page_contents)
+            }
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                if crate::core::batch_mode::is_batch_mode() {
+                    let content_owned = content.to_vec();
+                    let span = tracing::Span::current();
+                    let pages_config = config.pages.clone();
+                    tokio::task::spawn_blocking(move || {
+                        let _guard = span.entered();
+                        let bindings =
+                            crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
+
+                        let pdfium = Pdfium::new(bindings);
+
+                        let document = pdfium.load_pdf_from_byte_slice(&content_owned, None).map_err(|e| {
+                            let err_msg = e.to_string();
+                            if err_msg.contains("password") || err_msg.contains("Password") {
+                                PdfError::PasswordRequired
+                            } else {
+                                PdfError::InvalidPdf(err_msg)
+                            }
+                        })?;
+
+                        let (native_text, boundaries, page_contents) =
+                            crate::pdf::text::extract_text_from_pdf_document(&document, pages_config.as_ref())?;
+
+                        let pdf_metadata =
+                            crate::pdf::metadata::extract_metadata_from_document(&document, boundaries.as_deref())?;
+
+                        let tables = extract_tables_from_document(&document, &pdf_metadata)?;
+
+                        if let Some(ref page_cfg) = pages_config
+                            && page_cfg.extract_pages
+                            && page_contents.is_none()
+                        {
+                            return Err(PdfError::ExtractionFailed(
+                                "Page extraction was configured but no page data was extracted in batch mode"
+                                    .to_string(),
+                            )
+                            .into());
+                        }
+
+                        Ok::<_, crate::error::KreuzbergError>((pdf_metadata, native_text, tables, page_contents))
+                    })
+                    .await
+                    .map_err(|e| crate::error::KreuzbergError::Other(format!("PDF extraction task failed: {}", e)))??
+                } else {
+                    let bindings =
+                        crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-            let pdfium = Pdfium::new(bindings);
+                    let pdfium = Pdfium::new(bindings);
 
-            let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                let err_msg = e.to_string();
-                if err_msg.contains("password") || err_msg.contains("Password") {
-                    PdfError::PasswordRequired
-                } else {
-                    PdfError::InvalidPdf(err_msg)
-                }
-            })?;
+                    let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
+                        let err_msg = e.to_string();
+                        if err_msg.contains("password") || err_msg.contains("Password") {
+                            PdfError::PasswordRequired
+                        } else {
+                            PdfError::InvalidPdf(err_msg)
+                        }
+                    })?;
 
-            let (native_text, boundaries, page_contents) =
-                crate::pdf::text::extract_text_from_pdf_document(&document, config.pages.as_ref())?;
+                    let (native_text, boundaries, page_contents) =
+                        crate::pdf::text::extract_text_from_pdf_document(&document, config.pages.as_ref())?;
 
-            let pdf_metadata = crate::pdf::metadata::extract_metadata_from_document(&document, boundaries.as_deref())?;
+                    let pdf_metadata =
+                        crate::pdf::metadata::extract_metadata_from_document(&document, boundaries.as_deref())?;
 
-            let tables = extract_tables_from_document(&document, &pdf_metadata)?;
+                    let tables = extract_tables_from_document(&document, &pdf_metadata)?;
 
-            (pdf_metadata, native_text, tables, page_contents)
+                    (pdf_metadata, native_text, tables, page_contents)
+                }
+            }
         };
 
         #[cfg(feature = "ocr")]

data/vendor/kreuzberg/src/pdf/bindings.rs

@@ -0,0 +1,44 @@
+use super::error::PdfError;
+use pdfium_render::prelude::*;
+
+pub(crate) fn bind_pdfium(
+    map_err: fn(String) -> PdfError,
+    context: &'static str,
+) -> Result<Box<dyn PdfiumLibraryBindings>, PdfError> {
+    #[cfg(all(feature = "pdf", feature = "pdf-bundled"))]
+    {
+        // WASM target: use dynamic binding to WASM module
+        // SAFETY: pdfium-render handles WASM module lifecycle internally.
+        // For WASM builds, the PDFium library is linked at compile time
+        // and the WASM runtime manages initialization.
+        #[cfg(target_arch = "wasm32")]
+        {
+            Pdfium::bind_to_system_library()
+                .map_err(|e| map_err(format!("Failed to initialize Pdfium for WASM ({}): {}", context, e)))
+        }
+
+        // Non-WASM targets: extract and link dynamically
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let lib_path = crate::pdf::extract_bundled_pdfium()
+                .map_err(|e| map_err(format!("Failed to extract bundled Pdfium ({}): {}", context, e)))?;
+
+            let lib_dir = lib_path.parent().ok_or_else(|| {
+                map_err(format!(
+                    "Failed to determine Pdfium extraction directory for '{}' ({})",
+                    lib_path.display(),
+                    context
+                ))
+            })?;
+
+            Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path(lib_dir))
+                .map_err(|e| map_err(format!("Failed to initialize Pdfium ({}): {}", context, e)))
+        }
+    }
+
+    #[cfg(all(feature = "pdf", not(feature = "pdf-bundled")))]
+    {
+        Pdfium::bind_to_system_library()
+            .map_err(|e| map_err(format!("Failed to initialize Pdfium ({}): {}", context, e)))
+    }
+}

data/vendor/kreuzberg/src/pdf/bundled.rs

@@ -89,17 +89,24 @@ fn is_extracted_library_valid(lib_path: &Path, embedded_size: usize) -> bool {
 /// # Behavior
 ///
 /// - Embeds PDFium library using `include_bytes!`
-/// - Extracts to `$TMPDIR/kreuzberg-pdfium/`
+/// - Extracts to `$TMPDIR/kreuzberg-pdfium/` (non-WASM only)
 /// - Reuses extracted library if size matches
 /// - Sets permissions to 0755 on Unix
 /// - Returns path to extracted library
 ///
+/// # WASM Handling
+///
+/// On WASM targets (wasm32-*), this function returns an error with a helpful
+/// message directing users to use WASM-specific initialization. WASM PDFium
+/// is initialized through the runtime, not via file extraction.
+///
 /// # Errors
 ///
 /// Returns `std::io::Error` if:
 /// - Cannot create extraction directory
 /// - Cannot write library file
 /// - Cannot set file permissions (Unix only)
+/// - Target is WASM (filesystem access not available)
 ///
 /// # Platform-Specific Library Names
 ///
@@ -107,6 +114,17 @@ fn is_extracted_library_valid(lib_path: &Path, embedded_size: usize) -> bool {
 /// - macOS: `libpdfium.dylib`
 /// - Windows: `pdfium.dll`
 pub fn extract_bundled_pdfium() -> io::Result<PathBuf> {
+    // WASM targets cannot use file extraction
+    #[cfg(target_arch = "wasm32")]
+    {
+        return Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "File extraction is not available in WASM. \
+             PDFium for WASM must be initialized via the WebAssembly runtime. \
+             Use a WASM-compatible environment with proper module initialization.",
+        ));
+    }
+
     let (lib_name, _) = bundled_library_info();
     let extract_dir = get_extraction_dir()?;
 

data/vendor/kreuzberg/src/pdf/metadata.rs

@@ -1,3 +1,4 @@
+use super::bindings::bind_pdfium;
 use super::error::{PdfError, Result};
 use crate::types::{PageBoundary, PageInfo, PageStructure, PageUnitType};
 use pdfium_render::prelude::*;
@@ -85,8 +86,7 @@ pub fn extract_metadata(pdf_bytes: &[u8]) -> Result<PdfMetadata> {
 ///
 /// Returns only PDF-specific metadata (version, producer, encryption status, dimensions).
 pub fn extract_metadata_with_password(pdf_bytes: &[u8], password: Option<&str>) -> Result<PdfMetadata> {
-    let bindings = Pdfium::bind_to_system_library()
-        .map_err(|e| PdfError::MetadataExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+    let bindings = bind_pdfium(PdfError::MetadataExtractionFailed, "metadata extraction")?;
 
     let pdfium = Pdfium::new(bindings);
 

data/vendor/kreuzberg/src/pdf/mod.rs

@@ -35,6 +35,8 @@
 //!
 //! This module requires the `pdf` feature. The `ocr` feature enables additional
 //! functionality in the PDF extractor for rendering pages to images.
+#[cfg(feature = "pdf")]
+pub(crate) mod bindings;
 #[cfg(all(feature = "pdf", feature = "pdf-bundled"))]
 pub mod bundled;
 #[cfg(feature = "pdf")]

data/vendor/kreuzberg/src/pdf/rendering.rs

@@ -1,3 +1,4 @@
+use super::bindings::bind_pdfium;
 use super::error::{PdfError, Result};
 use image::DynamicImage;
 use pdfium_render::prelude::*;
@@ -32,8 +33,7 @@ pub struct PdfRenderer {
 
 impl PdfRenderer {
     pub fn new() -> Result<Self> {
-        let binding = Pdfium::bind_to_system_library()
-            .map_err(|e| PdfError::RenderingFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+        let binding = bind_pdfium(PdfError::RenderingFailed, "page rendering")?;
 
         let pdfium = Pdfium::new(binding);
         Ok(Self { pdfium })

data/vendor/kreuzberg/src/pdf/table.rs

@@ -13,9 +13,11 @@ use pdfium_render::prelude::*;
 /// Spacing threshold for word boundary detection (in PDF units).
 ///
 /// Characters separated by more than this distance are considered separate words.
+#[cfg(feature = "ocr")]
 const WORD_SPACING_THRESHOLD: f32 = 3.0;
 
 /// Minimum word length for table detection (filter out noise).
+#[cfg(feature = "ocr")]
 const MIN_WORD_LENGTH: usize = 1;
 
 /// Extract words with positions from PDF page for table detection.
@@ -80,6 +82,7 @@ pub fn extract_words_from_page(_page: &PdfPage, _min_confidence: f64) -> Result<
 }
 
 /// Character with position information extracted from PDF.
+#[cfg(feature = "ocr")]
 #[derive(Debug, Clone)]
 struct CharInfo {
     text: char,

data/vendor/kreuzberg/src/pdf/text.rs

@@ -1,3 +1,4 @@
+use super::bindings::bind_pdfium;
 use super::error::{PdfError, Result};
 use crate::core::config::PageConfig;
 use crate::types::{PageBoundary, PageContent};
@@ -13,8 +14,7 @@ pub struct PdfTextExtractor {
 
 impl PdfTextExtractor {
     pub fn new() -> Result<Self> {
-        let binding = Pdfium::bind_to_system_library()
-            .map_err(|e| PdfError::TextExtractionFailed(format!("Failed to initialize Pdfium: {}", e)))?;
+        let binding = bind_pdfium(PdfError::TextExtractionFailed, "text extraction")?;
 
         let pdfium = Pdfium::new(binding);
         Ok(Self { pdfium })

data/vendor/kreuzberg/src/text/quality_processor.rs

@@ -19,7 +19,7 @@ use async_trait::async_trait;
 ///
 /// ```rust,no_run
 /// use kreuzberg::plugins::{Plugin, PostProcessor};
-/// use kreuzberg::text::quality::processor::QualityProcessor;
+/// use kreuzberg::text::QualityProcessor;
 ///
 /// let processor = QualityProcessor;
 /// assert_eq!(processor.name(), "quality-processing");

data/vendor/kreuzberg/tests/concurrency_stress.rs

@@ -244,7 +244,7 @@ async fn test_concurrent_ocr_processing() {
 #[test]
 fn test_concurrent_ocr_cache_stress() {
     use helpers::{get_test_file_path, skip_if_missing};
-    use std::sync::atomic::Ordering;
+    use std::sync::atomic::{AtomicUsize, Ordering};
 
     if skip_if_missing("images/ocr_image.jpg") {
         tracing::debug!("Skipping OCR cache stress test: test file not available");

data/vendor/kreuzberg/tests/format_integration.rs

@@ -9,7 +9,10 @@
 
 mod helpers;
 
-use helpers::{assert_mime_type, assert_non_empty_content, get_test_file_path, test_documents_available};
+use helpers::{assert_mime_type, get_test_file_path, test_documents_available};
+
+#[cfg(any(feature = "office", feature = "ocr"))]
+use helpers::assert_non_empty_content;
 use kreuzberg::core::config::ExtractionConfig;
 use kreuzberg::core::extractor::extract_file;
 

data/vendor/kreuzberg-ffi/Cargo.toml

@@ -0,0 +1,63 @@
+[package]
+name = "kreuzberg-ffi"
+version = "4.0.0-rc.11"
+edition = "2024"
+rust-version = "1.91"
+authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
+description = "C FFI bindings for Kreuzberg document intelligence library"
+license = "MIT"
+repository = "https://github.com/kreuzberg-dev/kreuzberg"
+homepage = "https://kreuzberg.dev"
+documentation = "https://docs.rs/kreuzberg-ffi"
+readme = "README.md"
+keywords = ["ffi", "bindings", "document", "extraction", "api"]
+categories = ["development-tools::ffi", "text-processing"]
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[features]
+# Mirror embeddings feature availability from kreuzberg dependency
+embeddings = []
+
+[dependencies]
+# On Windows MinGW, disable embeddings/ort since ONNX Runtime is not available
+# in MinGW-compatible form. Use all other features but exclude embeddings.
+[target.'cfg(all(windows, target_env = "gnu"))'.dependencies]
+kreuzberg = { path = "../kreuzberg", features = [
+    "pdf",
+    "excel",
+    "office",
+    "email",
+    "html",
+    "xml",
+    "archives",
+    "ocr",
+    "language-detection",
+    "chunking",
+    "quality",
+    "keywords",
+    "api",
+    "mcp",
+    "otel",
+    "bundled-pdfium",
+] }
+serde_json = "1.0.145"
+serde = { version = "1.0.228", features = ["derive"] }
+async-trait = "0.1.89"
+tokio = { version = "1.48.0", features = ["rt", "rt-multi-thread", "macros", "sync", "process", "fs", "time", "io-util"] }
+html-to-markdown-rs = { version = "2.14.11", default-features = false }
+
+[target.'cfg(not(all(windows, target_env = "gnu")))'.dependencies]
+kreuzberg = { path = "../kreuzberg", features = ["full", "bundled-pdfium"] }
+serde_json = "1.0.145"
+serde = { version = "1.0.228", features = ["derive"] }
+async-trait = "0.1.89"
+tokio = { version = "1.48.0", features = ["rt", "rt-multi-thread", "macros", "sync", "process", "fs", "time", "io-util"] }
+html-to-markdown-rs = { version = "2.14.11", default-features = false }
+
+[build-dependencies]
+cbindgen = "0.29"
+
+[dev-dependencies]
+tempfile = "3.23.0"