kreuzberg 4.0.0.pre.rc.7 → 4.0.0.pre.rc.11

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

@@ -1,5 +1,3 @@
-#![cfg(feature = "api")]
-
 //! REST API server for Kreuzberg document extraction.
 //!
 //! This module provides an Axum-based HTTP server for document extraction

data/vendor/kreuzberg/src/core/pipeline.rs

@@ -653,6 +653,18 @@ mod tests {
     #[tokio::test]
     #[cfg(any(feature = "keywords-yake", feature = "keywords-rake"))]
     async fn test_pipeline_with_keyword_extraction() {
+        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        crate::plugins::registry::get_validator_registry()
+            .write()
+            .unwrap()
+            .shutdown_all()
+            .unwrap();
+        crate::plugins::registry::get_post_processor_registry()
+            .write()
+            .unwrap()
+            .shutdown_all()
+            .unwrap();
+
         let _ = crate::keywords::register_keyword_processor();
 
         let result = ExtractionResult {
@@ -703,6 +715,7 @@ Natural language processing enables computers to understand human language.
     #[tokio::test]
     #[cfg(any(feature = "keywords-yake", feature = "keywords-rake"))]
     async fn test_pipeline_without_keyword_config() {
+        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
         let result = ExtractionResult {
             content: "Machine learning and artificial intelligence.".to_string(),
             mime_type: "text/plain".to_string(),

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/docx.rs

@@ -384,7 +384,7 @@ mod tests {
     #[test]
     fn test_extract_text_with_page_breaks_no_breaks() {
         let docx_path =
-            "/Users/naamanhirschfeld/workspace/kreuzberg-dev/kreuzberg/test_documents/documents/lorem_ipsum.docx";
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test_documents/documents/lorem_ipsum.docx");
         if let Ok(bytes) = std::fs::read(docx_path) {
             let result = extract_text_with_page_breaks(&bytes);
             if let Ok((text, boundaries)) = result {

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")]
@@ -585,7 +634,8 @@ mod tests {
             ..Default::default()
         };
 
-        let pdf_path = "/Users/naamanhirschfeld/workspace/kreuzberg-dev/kreuzberg/fixtures/pdf/simple_text.pdf";
+        let pdf_path =
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test_documents/pdfs/google_doc_document.pdf");
         if let Ok(content) = std::fs::read(pdf_path) {
             let result = extractor.extract_bytes(&content, "application/pdf", &config).await;
             assert!(
@@ -608,7 +658,8 @@ mod tests {
         let extractor = PdfExtractor::new();
         let config = ExtractionConfig::default();
 
-        let pdf_path = "/Users/naamanhirschfeld/workspace/kreuzberg-dev/kreuzberg/fixtures/pdf/simple_text.pdf";
+        let pdf_path =
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test_documents/pdfs/google_doc_document.pdf");
         if let Ok(content) = std::fs::read(pdf_path) {
             let result = extractor.extract_bytes(&content, "application/pdf", &config).await;
             assert!(
@@ -641,7 +692,8 @@ mod tests {
             ..Default::default()
         };
 
-        let pdf_path = "/Users/naamanhirschfeld/workspace/kreuzberg-dev/kreuzberg/fixtures/pdf/simple_text.pdf";
+        let pdf_path =
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test_documents/pdfs/multi_page.pdf");
         if let Ok(content) = std::fs::read(pdf_path) {
             let result = extractor.extract_bytes(&content, "application/pdf", &config).await;
             assert!(

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

@@ -1,5 +1,3 @@
-#![cfg(feature = "mcp")]
-
 //! Model Context Protocol (MCP) server implementation.
 //!
 //! Provides an MCP server that exposes Kreuzberg's document extraction
@@ -28,6 +26,9 @@ mod server;
 
 pub use server::{start_mcp_server, start_mcp_server_with_config};
 
+#[cfg(feature = "mcp-http")]
+pub use server::{start_mcp_server_http, start_mcp_server_http_with_config};
+
 pub use server::{BatchExtractFilesParams, DetectMimeTypeParams, ExtractBytesParams, ExtractFileParams, KreuzbergMcp};
 
 #[doc(hidden)]

data/vendor/kreuzberg/src/mcp/server.rs

@@ -12,6 +12,9 @@ use rmcp::{
     transport::stdio,
 };
 
+#[cfg(feature = "mcp-http")]
+use rmcp::transport::streamable_http_server::{StreamableHttpService, session::local::LocalSessionManager};
+
 use crate::{
     ExtractionConfig, ExtractionResult as KreuzbergResult, KreuzbergError, batch_extract_file, batch_extract_file_sync,
     cache, detect_mime_type, extract_bytes, extract_bytes_sync, extract_file, extract_file_sync,
@@ -453,6 +456,109 @@ pub async fn start_mcp_server_with_config(
     Ok(())
 }
 
+/// Start MCP server with HTTP Stream transport.
+///
+/// Uses rmcp's built-in StreamableHttpService for HTTP/SSE support per MCP spec.
+///
+/// # Arguments
+///
+/// * `host` - Host to bind to (e.g., "127.0.0.1" or "0.0.0.0")
+/// * `port` - Port number (e.g., 8001)
+///
+/// # Example
+///
+/// ```no_run
+/// use kreuzberg::mcp::start_mcp_server_http;
+///
+/// #[tokio::main]
+/// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+///     start_mcp_server_http("127.0.0.1", 8001).await?;
+///     Ok(())
+/// }
+/// ```
+#[cfg(feature = "mcp-http")]
+pub async fn start_mcp_server_http(
+    host: impl AsRef<str>,
+    port: u16,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    use axum::Router;
+    use std::net::SocketAddr;
+
+    let http_service = StreamableHttpService::new(
+        || KreuzbergMcp::new().map_err(|e| std::io::Error::other(e.to_string())),
+        LocalSessionManager::default().into(),
+        Default::default(),
+    );
+
+    let router = Router::new().nest_service("/mcp", http_service);
+
+    let addr: SocketAddr = format!("{}:{}", host.as_ref(), port)
+        .parse()
+        .map_err(|e| format!("Invalid address: {}", e))?;
+
+    #[cfg(feature = "api")]
+    tracing::info!("Starting MCP HTTP server on http://{}", addr);
+
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, router).await?;
+
+    Ok(())
+}
+
+/// Start MCP HTTP server with custom extraction config.
+///
+/// This variant allows specifying a custom extraction configuration
+/// while using HTTP Stream transport.
+///
+/// # Arguments
+///
+/// * `host` - Host to bind to (e.g., "127.0.0.1" or "0.0.0.0")
+/// * `port` - Port number (e.g., 8001)
+/// * `config` - Custom extraction configuration
+///
+/// # Example
+///
+/// ```no_run
+/// use kreuzberg::mcp::start_mcp_server_http_with_config;
+/// use kreuzberg::ExtractionConfig;
+///
+/// #[tokio::main]
+/// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+///     let config = ExtractionConfig::default();
+///     start_mcp_server_http_with_config("127.0.0.1", 8001, config).await?;
+///     Ok(())
+/// }
+/// ```
+#[cfg(feature = "mcp-http")]
+pub async fn start_mcp_server_http_with_config(
+    host: impl AsRef<str>,
+    port: u16,
+    config: ExtractionConfig,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    use axum::Router;
+    use std::net::SocketAddr;
+
+    let http_service = StreamableHttpService::new(
+        move || Ok(KreuzbergMcp::with_config(config.clone())),
+        LocalSessionManager::default().into(),
+        Default::default(),
+    );
+
+    let router = Router::new().nest_service("/mcp", http_service);
+
+    let addr: SocketAddr = format!("{}:{}", host.as_ref(), port)
+        .parse()
+        .map_err(|e| format!("Invalid address: {}", e))?;
+
+    #[cfg(feature = "api")]
+    tracing::info!("Starting MCP HTTP server on http://{}", addr);
+
+    let listener = tokio::net::TcpListener::bind(addr).await?;
+    axum::serve(listener, router).await?;
+
+    Ok(())
+}
+
 /// Build extraction config from MCP parameters.
 ///
 /// Starts with the default config and overlays OCR settings from request parameters.

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)))
+    }
+}