kreuzberg 4.2.13 → 4.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c2053b10256948a215ff0d3552894991e801497ac4b2480eca3c98bb645cc27
-  data.tar.gz: 324b6147e172ecedb2338fab1b14ce2022a8b9c2d6be7fd86ac0f862d81ef7ce
+  metadata.gz: da61e06dfa4643e485c13636998888f03699816b7462087c9df6c9639d53fc45
+  data.tar.gz: 20a9c88f3eac809d2d158e15ea3747c425d47b3af0e2bf93825c831c9aa11aa9
 SHA512:
-  metadata.gz: 84a6636111d240c99eb17546f80c1df31117c700d78282c18a67a79aa613021d33988cbc1b00d5bc62bb2ffeef8c2a8f1759e137329de8f30af7f61b6db1a55b
-  data.tar.gz: 7628ecce3c6fb44c06a9546f2db696ae3486de35e0a05195cbea752bc6f78e573162e6305aec8c8ae0ca0fdbb6709a3e75752b822dbd8aed637eff9577c3e020
+  metadata.gz: 7be55db6494d45de03b3fee1271e1bc151193709098bdfe94fb7a5fb33159dd9a0b8b08fffd5ed2d3b24f3f3766c0bb1e81b42319d25b529088afe7e6a4c52d6
+  data.tar.gz: bd94796f90094ca64775c0ded247bc216fdfe6ee50d4c6258685ccc5b5b33e1a69546cd892ac7dce77eee72123cbaf6ce239ee932a117c8ad5dfe801a9a548bf

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kreuzberg (4.2.13)
+    kreuzberg (4.2.14)
       rb_sys (~> 0.9.119)
 
 GEM
@@ -209,7 +209,7 @@ CHECKSUMS
   i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
   io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
   json (2.18.1) sha256=fe112755501b8d0466b5ada6cf50c8c3f41e897fa128ac5d263ec09eedc9f986
-  kreuzberg (4.2.13)
+  kreuzberg (4.2.14)
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
   listen (3.10.0) sha256=c6e182db62143aeccc2e1960033bebe7445309c7272061979bb098d03760c9d2

data/README.md

@@ -22,7 +22,7 @@
     <img src="https://img.shields.io/maven-central/v/dev.kreuzberg/kreuzberg?label=Java&color=007ec6" alt="Java">
   </a>
   <a href="https://github.com/kreuzberg-dev/kreuzberg/releases">
-    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.2.13" alt="Go">
+    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.2.14" alt="Go">
   </a>
   <a href="https://www.nuget.org/packages/Kreuzberg/">
     <img src="https://img.shields.io/nuget/v/Kreuzberg?label=C%23&color=007ec6" alt="C#">

data/ext/kreuzberg_rb/native/Cargo.toml

@@ -37,7 +37,7 @@ collapsible_if = "allow"
 
 [package]
 name = "kreuzberg-rb"
-version = "4.2.13"
+version = "4.2.14"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/lib/kreuzberg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kreuzberg
-  VERSION = '4.2.13'
+  VERSION = '4.2.14'
 end

data/vendor/Cargo.toml

@@ -3,7 +3,7 @@ members = ["kreuzberg", "kreuzberg-tesseract", "kreuzberg-ffi"]
 resolver = "2"
 
 [workspace.package]
-version = "4.2.13"
+version = "4.2.14"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/vendor/kreuzberg/Cargo.toml

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

data/vendor/kreuzberg/README.md

@@ -17,7 +17,7 @@ High-performance document intelligence library for Rust. Extract text, metadata,
 
 This is the core Rust library that powers the Python, TypeScript, and Ruby bindings.
 
-> **🚀 Version 4.2.13 Release**
+> **🚀 Version 4.2.14 Release**
 > This is a pre-release version. We invite you to test the library and [report any issues](https://github.com/kreuzberg-dev/kreuzberg/issues) you encounter.
 >
 > **Note**: The Rust crate is not currently published to crates.io for this RC. Use git dependencies or language bindings (Python, TypeScript, Ruby) instead.

data/vendor/kreuzberg/src/core/extractor/helpers.rs

@@ -3,7 +3,7 @@
 //! This module provides shared utilities used across extraction modules.
 
 use crate::plugins::DocumentExtractor;
-#[cfg(feature = "office")]
+#[cfg(all(feature = "office", not(target_arch = "wasm32")))]
 use crate::utils::intern_mime_type;
 use crate::utils::{PoolSizeHint, estimate_pool_size};
 use crate::{KreuzbergError, Result};
@@ -65,7 +65,7 @@ pub fn get_pool_sizing_hint(file_size: u64, mime_type: &str) -> PoolSizeHint {
 ///
 /// For pre-interned MIME types (all common types), this is O(1) pointer dereference.
 /// For unknown MIME types, this allocates once per unique type and caches the result.
-#[cfg(feature = "office")]
+#[cfg(all(feature = "office", not(target_arch = "wasm32")))]
 pub(in crate::core::extractor) fn pool_mime_type(mime_type: &str) -> String {
     intern_mime_type(mime_type).to_string()
 }

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

@@ -104,7 +104,7 @@ static EXT_TO_MIME: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
     m.insert("zip", "application/zip");
     m.insert("tar", "application/x-tar");
     m.insert("gz", "application/gzip");
-    m.insert("tgz", "application/x-tar");
+    m.insert("tgz", "application/gzip");
     m.insert("7z", "application/x-7z-compressed");
 
     m.insert("rst", "text/x-rst");

data/vendor/kreuzberg/src/extraction/archive/gzip.rs

@@ -2,6 +2,10 @@
 //!
 //! Provides functions for decompressing gzip files and extracting
 //! metadata and text content from the compressed data.
+//!
+//! When a gzip file contains a TAR archive (e.g., .tar.gz files),
+//! this module automatically detects the TAR format and delegates
+//! to the TAR extraction functions.
 
 use super::{ArchiveEntry, ArchiveMetadata};
 use crate::error::{KreuzbergError, Result};
@@ -10,6 +14,14 @@ use flate2::read::GzDecoder;
 use std::collections::HashMap;
 use std::io::Read;
 
+/// Check if data looks like a TAR archive (has "ustar" magic at offset 257).
+///
+/// The TAR format has a standard USTAR header starting at offset 257,
+/// which helps identify TAR archives that have been gzip-compressed.
+fn is_tar_archive(data: &[u8]) -> bool {
+    data.len() > 262 && &data[257..262] == b"ustar"
+}
+
 /// Decompress gzip bytes with a size limit to prevent decompression bombs.
 fn decompress_gzip_limited(bytes: &[u8], max_size: u64) -> Result<Vec<u8>> {
     let decoder = GzDecoder::new(bytes);
@@ -38,9 +50,19 @@ pub fn decompress_gzip(bytes: &[u8], limits: &SecurityLimits) -> Result<Vec<u8>>
 ///
 /// This avoids the overhead of decompressing the data multiple times when both
 /// metadata and text content are needed.
+///
+/// If the decompressed data is a TAR archive, delegates to TAR extraction functions.
 pub fn extract_gzip(bytes: &[u8], limits: &SecurityLimits) -> Result<(ArchiveMetadata, HashMap<String, String>)> {
     let decompressed = decompress_gzip_limited(bytes, limits.max_archive_size as u64)?;
 
+    // Check if the decompressed data is a TAR archive
+    if is_tar_archive(&decompressed) {
+        let mut metadata = super::tar::extract_tar_metadata(&decompressed, limits)?;
+        metadata.format = "GZIP+TAR".to_string();
+        let contents = super::tar::extract_tar_text_content(&decompressed, limits)?;
+        return Ok((metadata, contents));
+    }
+
     // Re-read header for filename (lightweight - no decompression)
     let mut decoder = GzDecoder::new(bytes);
     let mut _discard = [0u8; 1];
@@ -77,9 +99,18 @@ pub fn extract_gzip(bytes: &[u8], limits: &SecurityLimits) -> Result<(ArchiveMet
 ///
 /// Gzip wraps a single stream, so the metadata contains one entry
 /// with the original filename (from gzip header) and decompressed size.
+///
+/// If the decompressed data is a TAR archive, delegates to TAR extraction.
 pub fn extract_gzip_metadata(bytes: &[u8], limits: &SecurityLimits) -> Result<ArchiveMetadata> {
     let decompressed = decompress_gzip_limited(bytes, limits.max_archive_size as u64)?;
 
+    // Check if the decompressed data is a TAR archive
+    if is_tar_archive(&decompressed) {
+        let mut metadata = super::tar::extract_tar_metadata(&decompressed, limits)?;
+        metadata.format = "GZIP+TAR".to_string();
+        return Ok(metadata);
+    }
+
     let mut decoder = GzDecoder::new(bytes);
     let mut _discard = [0u8; 1];
     let _ = decoder.read(&mut _discard);
@@ -107,9 +138,16 @@ pub fn extract_gzip_metadata(bytes: &[u8], limits: &SecurityLimits) -> Result<Ar
 /// Extract text content from a gzip-compressed file.
 ///
 /// Decompresses and attempts to read the result as UTF-8 text.
+///
+/// If the decompressed data is a TAR archive, delegates to TAR extraction.
 pub fn extract_gzip_text_content(bytes: &[u8], limits: &SecurityLimits) -> Result<HashMap<String, String>> {
     let decompressed = decompress_gzip_limited(bytes, limits.max_archive_size as u64)?;
 
+    // Check if the decompressed data is a TAR archive
+    if is_tar_archive(&decompressed) {
+        return super::tar::extract_tar_text_content(&decompressed, limits);
+    }
+
     let mut decoder = GzDecoder::new(bytes);
     let mut _discard = [0u8; 1];
     let _ = decoder.read(&mut _discard);

data/vendor/kreuzberg/src/extraction/archive/mod.rs

@@ -878,4 +878,126 @@ mod tests {
         let result = extract_gzip_metadata(&compressed, &limits);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_extract_gzip_compressed_tar_metadata() {
+        use flate2::Compression;
+        use flate2::write::GzEncoder;
+        use std::io::Write;
+
+        // Create a tar archive
+        let mut tar_data = Vec::new();
+        {
+            let mut tar = TarBuilder::new(&mut tar_data);
+
+            let data1 = b"Hello from tar.gz!";
+            let mut header1 = ::tar::Header::new_gnu();
+            header1.set_path("test.txt").unwrap();
+            header1.set_size(data1.len() as u64);
+            header1.set_cksum();
+            tar.append(&header1, &data1[..]).unwrap();
+
+            let data2 = b"# Markdown file";
+            let mut header2 = ::tar::Header::new_gnu();
+            header2.set_path("readme.md").unwrap();
+            header2.set_size(data2.len() as u64);
+            header2.set_cksum();
+            tar.append(&header2, &data2[..]).unwrap();
+
+            tar.finish().unwrap();
+        }
+
+        // Gzip compress the tar data
+        let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+        encoder.write_all(&tar_data).unwrap();
+        let gzip_compressed = encoder.finish().unwrap();
+
+        // Extract metadata from the gzip-compressed tar
+        let metadata = extract_gzip_metadata(&gzip_compressed, &default_limits()).unwrap();
+
+        assert_eq!(metadata.format, "GZIP+TAR");
+        assert_eq!(metadata.file_count, 2);
+        assert_eq!(metadata.file_list.len(), 2);
+        assert!(metadata.total_size > 0);
+
+        // Verify file paths are preserved
+        let paths: Vec<&str> = metadata.file_list.iter().map(|e| e.path.as_str()).collect();
+        assert!(paths.contains(&"test.txt"));
+        assert!(paths.contains(&"readme.md"));
+    }
+
+    #[test]
+    fn test_extract_gzip_compressed_tar_text_content() {
+        use flate2::Compression;
+        use flate2::write::GzEncoder;
+        use std::io::Write;
+
+        // Create a tar archive
+        let mut tar_data = Vec::new();
+        {
+            let mut tar = TarBuilder::new(&mut tar_data);
+
+            let data1 = b"Hello from tar.gz!";
+            let mut header1 = ::tar::Header::new_gnu();
+            header1.set_path("test.txt").unwrap();
+            header1.set_size(data1.len() as u64);
+            header1.set_cksum();
+            tar.append(&header1, &data1[..]).unwrap();
+
+            let data2 = b"# Markdown content";
+            let mut header2 = ::tar::Header::new_gnu();
+            header2.set_path("readme.md").unwrap();
+            header2.set_size(data2.len() as u64);
+            header2.set_cksum();
+            tar.append(&header2, &data2[..]).unwrap();
+
+            tar.finish().unwrap();
+        }
+
+        // Gzip compress the tar data
+        let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+        encoder.write_all(&tar_data).unwrap();
+        let gzip_compressed = encoder.finish().unwrap();
+
+        // Extract text content from the gzip-compressed tar
+        let contents = extract_gzip_text_content(&gzip_compressed, &default_limits()).unwrap();
+
+        assert_eq!(contents.len(), 2);
+        assert_eq!(contents.get("test.txt").unwrap(), "Hello from tar.gz!");
+        assert_eq!(contents.get("readme.md").unwrap(), "# Markdown content");
+    }
+
+    #[test]
+    fn test_extract_gzip_compressed_tar_both() {
+        use flate2::Compression;
+        use flate2::write::GzEncoder;
+        use std::io::Write;
+
+        // Create a tar archive
+        let mut tar_data = Vec::new();
+        {
+            let mut tar = TarBuilder::new(&mut tar_data);
+
+            let data = b"Combined test content";
+            let mut header = ::tar::Header::new_gnu();
+            header.set_path("combined.txt").unwrap();
+            header.set_size(data.len() as u64);
+            header.set_cksum();
+            tar.append(&header, &data[..]).unwrap();
+
+            tar.finish().unwrap();
+        }
+
+        // Gzip compress the tar data
+        let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
+        encoder.write_all(&tar_data).unwrap();
+        let gzip_compressed = encoder.finish().unwrap();
+
+        // Extract both metadata and content in one call
+        let (metadata, contents) = extract_gzip(&gzip_compressed, &default_limits()).unwrap();
+
+        assert_eq!(metadata.format, "GZIP+TAR");
+        assert_eq!(metadata.file_count, 1);
+        assert_eq!(contents.get("combined.txt").unwrap(), "Combined test content");
+    }
 }

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

@@ -68,18 +68,63 @@ pub fn read_excel_file(file_path: &str) -> Result<ExcelWorkbook> {
     #[cfg(not(feature = "office"))]
     let office_metadata: Option<HashMap<String, String>> = None;
 
-    // For XLSX files, use specialized handler with OOM protection
-    if lower_path.ends_with(".xlsx")
-        || lower_path.ends_with(".xlsm")
-        || lower_path.ends_with(".xlam")
-        || lower_path.ends_with(".xltm")
-    {
+    // For standard XLSX-format files, use specialized handler with OOM protection
+    if lower_path.ends_with(".xlsx") || lower_path.ends_with(".xlsm") || lower_path.ends_with(".xltm") {
         let file = std::fs::File::open(file_path)?;
         let workbook = calamine::Xlsx::new(std::io::BufReader::new(file))
             .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLSX: {}", e)))?;
         return process_xlsx_workbook(workbook, office_metadata);
     }
 
+    // For .xlam (Excel add-in), try XLSX parsing but gracefully return empty workbook on failure
+    if lower_path.ends_with(".xlam") {
+        let file = std::fs::File::open(file_path)?;
+        match calamine::Xlsx::new(std::io::BufReader::new(file)) {
+            Ok(workbook) => {
+                return process_xlsx_workbook(workbook, office_metadata);
+            }
+            Err(_) => {
+                // .xlam files may not contain proper workbook data - return empty workbook
+                return Ok(ExcelWorkbook {
+                    sheets: vec![],
+                    metadata: office_metadata.unwrap_or_default(),
+                });
+            }
+        }
+    }
+
+    // For .xla (legacy add-in), try XLS parsing but gracefully return empty workbook on failure
+    if lower_path.ends_with(".xla") {
+        let file = std::fs::File::open(file_path)?;
+        match calamine::Xls::new(std::io::BufReader::new(file)) {
+            Ok(workbook) => {
+                return process_workbook(workbook, office_metadata);
+            }
+            Err(_) => {
+                return Ok(ExcelWorkbook {
+                    sheets: vec![],
+                    metadata: office_metadata.unwrap_or_default(),
+                });
+            }
+        }
+    }
+
+    // For .xlsb (binary spreadsheet), try XLSB parsing but gracefully return empty workbook on failure
+    if lower_path.ends_with(".xlsb") {
+        let file = std::fs::File::open(file_path)?;
+        match calamine::Xlsb::new(std::io::BufReader::new(file)) {
+            Ok(workbook) => {
+                return process_workbook(workbook, office_metadata);
+            }
+            Err(_) => {
+                return Ok(ExcelWorkbook {
+                    sheets: vec![],
+                    metadata: office_metadata.unwrap_or_default(),
+                });
+            }
+        }
+    }
+
     // For other formats, use open_workbook_auto
     let workbook = match open_workbook_auto(Path::new(file_path)) {
         Ok(wb) => wb,
@@ -109,25 +154,66 @@ pub fn read_excel_bytes(data: &[u8], file_extension: &str) -> Result<ExcelWorkbo
     #[cfg(not(feature = "office"))]
     let office_metadata: Option<HashMap<String, String>> = None;
 
-    let cursor = Cursor::new(data);
-
     match file_extension.to_lowercase().as_str() {
-        ".xlsx" | ".xlsm" | ".xlam" | ".xltm" => {
+        // Standard XLSX-format files: propagate errors
+        ".xlsx" | ".xlsm" | ".xltm" => {
+            let cursor = Cursor::new(data);
             let workbook = calamine::Xlsx::new(cursor)
                 .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLSX: {}", e)))?;
             process_xlsx_workbook(workbook, office_metadata)
         }
-        ".xls" | ".xla" => {
+        // Exotic format: .xlam (Excel add-in) - may not contain proper workbook data
+        ".xlam" => {
+            let cursor = Cursor::new(data);
+            match calamine::Xlsx::new(cursor) {
+                Ok(workbook) => process_xlsx_workbook(workbook, office_metadata),
+                Err(_) => {
+                    // .xlam files may not contain proper workbook data - return empty workbook
+                    Ok(ExcelWorkbook {
+                        sheets: vec![],
+                        metadata: office_metadata.unwrap_or_default(),
+                    })
+                }
+            }
+        }
+        // Standard XLS format: propagate errors
+        ".xls" => {
+            let cursor = Cursor::new(data);
             let workbook = calamine::Xls::new(cursor)
                 .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLS: {}", e)))?;
             process_workbook(workbook, office_metadata)
         }
+        // Exotic format: .xla (legacy add-in) - may not contain proper workbook data
+        ".xla" => {
+            let cursor = Cursor::new(data);
+            match calamine::Xls::new(cursor) {
+                Ok(workbook) => process_workbook(workbook, office_metadata),
+                Err(_) => {
+                    // .xla files may not contain proper workbook data - return empty workbook
+                    Ok(ExcelWorkbook {
+                        sheets: vec![],
+                        metadata: office_metadata.unwrap_or_default(),
+                    })
+                }
+            }
+        }
+        // Exotic format: .xlsb (binary spreadsheet) - may not contain proper workbook data
         ".xlsb" => {
-            let workbook = calamine::Xlsb::new(cursor)
-                .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLSB: {}", e)))?;
-            process_workbook(workbook, office_metadata)
+            let cursor = Cursor::new(data);
+            match calamine::Xlsb::new(cursor) {
+                Ok(workbook) => process_workbook(workbook, office_metadata),
+                Err(_) => {
+                    // .xlsb files may not contain proper workbook data - return empty workbook
+                    Ok(ExcelWorkbook {
+                        sheets: vec![],
+                        metadata: office_metadata.unwrap_or_default(),
+                    })
+                }
+            }
         }
+        // Standard OpenDocument format
         ".ods" => {
+            let cursor = Cursor::new(data);
             let workbook = calamine::Ods::new(cursor)
                 .map_err(|e| KreuzbergError::parsing(format!("Failed to parse ODS: {}", e)))?;
             process_workbook(workbook, office_metadata)

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

@@ -96,14 +96,31 @@ impl DocumentExtractor for PdfExtractor {
                         }
                     })?;
 
-                let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                    let err_msg = crate::pdf::error::format_pdfium_error(e);
-                    if err_msg.contains("password") || err_msg.contains("Password") {
-                        PdfError::PasswordRequired
-                    } else {
-                        PdfError::InvalidPdf(err_msg)
+                let document = match pdfium.load_pdf_from_byte_slice(content, None) {
+                    Ok(doc) => doc,
+                    Err(e) => {
+                        let err_msg = crate::pdf::error::format_pdfium_error(e);
+                        if err_msg.contains("password") || err_msg.contains("Password") {
+                            #[cfg(feature = "otel")]
+                            tracing::warn!("Password-protected PDF encountered in WASM, returning empty result");
+                        } else {
+                            #[cfg(feature = "otel")]
+                            tracing::warn!("Malformed or invalid PDF encountered in WASM: {}", err_msg);
+                        }
+                        return Ok(ExtractionResult {
+                            content: String::new(),
+                            mime_type: mime_type.to_string().into(),
+                            metadata: Metadata::default(),
+                            tables: vec![],
+                            detected_languages: None,
+                            chunks: None,
+                            images: None,
+                            pages: None,
+                            djot_content: None,
+                            elements: None,
+                        });
                     }
-                })?;
+                };
 
                 extract_all_from_document(&document, config)?
             }
@@ -113,23 +130,27 @@ impl DocumentExtractor for PdfExtractor {
                     let content_owned = content.to_vec();
                     let span = tracing::Span::current();
                     let config_owned = config.clone();
-                    tokio::task::spawn_blocking(move || {
+                    let result = tokio::task::spawn_blocking(move || {
                         let _guard = span.entered();
 
                         let pdfium =
                             crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                        let document = pdfium.load_pdf_from_byte_slice(&content_owned, None).map_err(|e| {
-                            let err_msg = crate::pdf::error::format_pdfium_error(e);
-                            if err_msg.contains("password") || err_msg.contains("Password") {
-                                PdfError::PasswordRequired
-                            } else {
-                                PdfError::InvalidPdf(err_msg)
+                        let document = match pdfium.load_pdf_from_byte_slice(&content_owned, None) {
+                            Ok(doc) => doc,
+                            Err(e) => {
+                                let err_msg = crate::pdf::error::format_pdfium_error(e);
+                                if err_msg.contains("password") || err_msg.contains("Password") {
+                                    return Err(PdfError::PasswordRequired);
+                                } else {
+                                    return Err(PdfError::InvalidPdf(err_msg));
+                                }
                             }
-                        })?;
+                        };
 
                         let (pdf_metadata, native_text, tables, page_contents, _boundaries) =
-                            extract_all_from_document(&document, &config_owned)?;
+                            extract_all_from_document(&document, &config_owned)
+                                .map_err(|e| PdfError::ExtractionFailed(e.to_string()))?;
 
                         if let Some(page_cfg) = config_owned.pages.as_ref()
                             && page_cfg.extract_pages
@@ -138,11 +159,10 @@ impl DocumentExtractor for PdfExtractor {
                             return Err(PdfError::ExtractionFailed(
                                 "Page extraction was configured but no page data was extracted in batch mode"
                                     .to_string(),
-                            )
-                            .into());
+                            ));
                         }
 
-                        Ok::<_, crate::error::KreuzbergError>((
+                        Ok::<_, crate::pdf::error::PdfError>((
                             pdf_metadata,
                             native_text,
                             tables,
@@ -151,19 +171,67 @@ impl DocumentExtractor for PdfExtractor {
                         ))
                     })
                     .await
-                    .map_err(|e| crate::error::KreuzbergError::Other(format!("PDF extraction task failed: {}", e)))??
+                    .map_err(|e| crate::error::KreuzbergError::Other(format!("PDF extraction task failed: {}", e)))?;
+
+                    match result {
+                        Ok(tuple) => tuple,
+                        Err(e) => {
+                            let err_msg = e.to_string();
+                            if err_msg.contains("password")
+                                || err_msg.contains("Password")
+                                || err_msg.contains("password-protected")
+                            {
+                                #[cfg(feature = "otel")]
+                                tracing::warn!(
+                                    "Password-protected PDF encountered in batch mode, returning empty result"
+                                );
+                            } else {
+                                #[cfg(feature = "otel")]
+                                tracing::warn!("Malformed or invalid PDF encountered in batch mode: {}", err_msg);
+                            }
+                            return Ok(ExtractionResult {
+                                content: String::new(),
+                                mime_type: mime_type.to_string().into(),
+                                metadata: Metadata::default(),
+                                tables: vec![],
+                                detected_languages: None,
+                                chunks: None,
+                                images: None,
+                                pages: None,
+                                djot_content: None,
+                                elements: None,
+                            });
+                        }
+                    }
                 } else {
                     let pdfium =
                         crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                    let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                        let err_msg = crate::pdf::error::format_pdfium_error(e);
-                        if err_msg.contains("password") || err_msg.contains("Password") {
-                            PdfError::PasswordRequired
-                        } else {
-                            PdfError::InvalidPdf(err_msg)
+                    let document = match pdfium.load_pdf_from_byte_slice(content, None) {
+                        Ok(doc) => doc,
+                        Err(e) => {
+                            let err_msg = crate::pdf::error::format_pdfium_error(e);
+                            if err_msg.contains("password") || err_msg.contains("Password") {
+                                #[cfg(feature = "otel")]
+                                tracing::warn!("Password-protected PDF encountered, returning empty result");
+                            } else {
+                                #[cfg(feature = "otel")]
+                                tracing::warn!("Malformed or invalid PDF encountered: {}", err_msg);
+                            }
+                            return Ok(ExtractionResult {
+                                content: String::new(),
+                                mime_type: mime_type.to_string().into(),
+                                metadata: Metadata::default(),
+                                tables: vec![],
+                                detected_languages: None,
+                                chunks: None,
+                                images: None,
+                                pages: None,
+                                djot_content: None,
+                                elements: None,
+                            });
                         }
-                    })?;
+                    };
 
                     extract_all_from_document(&document, config)?
                 }
@@ -173,14 +241,31 @@ impl DocumentExtractor for PdfExtractor {
                 let pdfium =
                     crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                    let err_msg = crate::pdf::error::format_pdfium_error(e);
-                    if err_msg.contains("password") || err_msg.contains("Password") {
-                        PdfError::PasswordRequired
-                    } else {
-                        PdfError::InvalidPdf(err_msg)
+                let document = match pdfium.load_pdf_from_byte_slice(content, None) {
+                    Ok(doc) => doc,
+                    Err(e) => {
+                        let err_msg = crate::pdf::error::format_pdfium_error(e);
+                        if err_msg.contains("password") || err_msg.contains("Password") {
+                            #[cfg(feature = "otel")]
+                            tracing::warn!("Password-protected PDF encountered, returning empty result");
+                        } else {
+                            #[cfg(feature = "otel")]
+                            tracing::warn!("Malformed or invalid PDF encountered: {}", err_msg);
+                        }
+                        return Ok(ExtractionResult {
+                            content: String::new(),
+                            mime_type: mime_type.to_string().into(),
+                            metadata: Metadata::default(),
+                            tables: vec![],
+                            detected_languages: None,
+                            chunks: None,
+                            images: None,
+                            pages: None,
+                            djot_content: None,
+                            elements: None,
+                        });
                     }
-                })?;
+                };
 
                 extract_all_from_document(&document, config)?
             }
@@ -628,4 +713,52 @@ mod tests {
         let extractor = PdfExtractor::new();
         assert_eq!(extractor.name(), "pdf-extractor");
     }
+
+    #[tokio::test]
+    #[cfg(feature = "pdf")]
+    async fn test_pdf_gracefully_handles_malformed_pdf() {
+        let extractor = PdfExtractor::new();
+        let config = ExtractionConfig::default();
+
+        // Create a malformed PDF: just some random bytes that start with %PDF but are incomplete
+        let malformed_pdf = b"%PDF-1.4\nmalformed content that is not a valid PDF".to_vec();
+
+        let result = extractor
+            .extract_bytes(&malformed_pdf, "application/pdf", &config)
+            .await;
+
+        assert!(
+            result.is_ok(),
+            "Malformed PDF should be handled gracefully, not return an error"
+        );
+
+        let extraction_result = result.unwrap();
+        assert_eq!(extraction_result.content, "", "Malformed PDF should have empty content");
+        assert_eq!(extraction_result.tables.len(), 0, "Malformed PDF should have no tables");
+        assert_eq!(
+            extraction_result.mime_type.as_ref() as &str,
+            "application/pdf",
+            "MIME type should be preserved"
+        );
+    }
+
+    #[tokio::test]
+    #[cfg(feature = "pdf")]
+    async fn test_pdf_gracefully_handles_invalid_bytes() {
+        let extractor = PdfExtractor::new();
+        let config = ExtractionConfig::default();
+
+        // Create completely invalid data (not a PDF at all)
+        let invalid_data = b"This is not a PDF file, just random text".to_vec();
+
+        let result = extractor.extract_bytes(&invalid_data, "application/pdf", &config).await;
+
+        assert!(
+            result.is_ok(),
+            "Invalid PDF data should be handled gracefully, not return an error"
+        );
+
+        let extraction_result = result.unwrap();
+        assert_eq!(extraction_result.content, "", "Invalid PDF should have empty content");
+    }
 }

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

@@ -254,14 +254,17 @@ pub(crate) fn bind_pdfium(
 mod tests {
     use super::*;
     use crate::pdf::error::PdfError;
+    use serial_test::serial;
 
     #[test]
+    #[serial]
     fn test_bind_pdfium_lazy_initialization() {
         let result = bind_pdfium(PdfError::TextExtractionFailed, "test context");
         assert!(result.is_ok(), "First bind_pdfium call should succeed");
     }
 
     #[test]
+    #[serial]
     fn test_bind_pdfium_multiple_calls() {
         // First call - acquire lock, test success, then drop handle to release lock
         {
@@ -277,6 +280,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_bind_pdfium_returns_same_instance() {
         // Get pointer from first handle, then drop it to release lock
         let ptr1 = {
@@ -295,6 +299,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_bind_pdfium_error_mapping() {
         let map_err = |msg: String| PdfError::TextExtractionFailed(msg);
 
@@ -308,6 +313,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_pdfium_handle_deref() {
         let handle = bind_pdfium(PdfError::TextExtractionFailed, "test").unwrap();
 

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

@@ -486,6 +486,7 @@ mod tests {
     }
 
     #[test]
+    #[serial_test::serial]
     fn test_extract_metadata_invalid_pdf() {
         let result = extract_metadata(b"not a pdf");
         assert!(result.is_err());

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

@@ -169,14 +169,17 @@ fn calculate_optimal_dpi(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     #[test]
+    #[serial]
     fn test_renderer_creation() {
         let result = PdfRenderer::new();
         assert!(result.is_ok());
     }
 
     #[test]
+    #[serial]
     fn test_render_invalid_pdf() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();
@@ -186,6 +189,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_page_not_found() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();
@@ -242,6 +246,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_all_pages_empty_pdf() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();
@@ -250,6 +255,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_page_with_password_none() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();
@@ -258,6 +264,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_all_pages_with_password_none() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();
@@ -266,6 +273,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_page_to_image_function() {
         let options = PageRenderOptions::default();
         let result = render_page_to_image(b"not a pdf", 0, &options);
@@ -348,6 +356,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_render_empty_bytes() {
         let renderer = PdfRenderer::new().unwrap();
         let options = PageRenderOptions::default();

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

@@ -441,14 +441,17 @@ fn extract_page_hierarchy(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     #[test]
+    #[serial]
     fn test_extractor_creation() {
         let result = PdfTextExtractor::new();
         assert!(result.is_ok());
     }
 
     #[test]
+    #[serial]
     fn test_extract_empty_pdf() {
         let extractor = PdfTextExtractor::new().unwrap();
         let result = extractor.extract_text(b"");
@@ -456,6 +459,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_extract_invalid_pdf() {
         let extractor = PdfTextExtractor::new().unwrap();
         let result = extractor.extract_text(b"not a pdf");
@@ -464,6 +468,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_password_required_detection() {
         let extractor = PdfTextExtractor::new().unwrap();
         let encrypted_pdf = b"%PDF-1.4\n%\xE2\xE3\xCF\xD3\n";
@@ -475,6 +480,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_extract_text_with_passwords_empty_list() {
         let extractor = PdfTextExtractor::new().unwrap();
         let result = extractor.extract_text_with_passwords(b"not a pdf", &[]);
@@ -485,6 +491,7 @@ mod tests {
 #[cfg(test)]
 mod cache_regression_tests {
     use super::*;
+    use serial_test::serial;
     use std::time::Instant;
 
     /// Test that multiple extractions of the same document produce consistent results.
@@ -497,6 +504,7 @@ mod cache_regression_tests {
     /// 1. Multiple extractions produce identical text content
     /// 2. The singleton pattern provides consistent extraction behavior
     #[test]
+    #[serial]
     fn test_no_global_cache_between_documents() {
         let pdf_bytes = std::fs::read("../../test_documents/pdf/fake_memo.pdf").expect("Failed to read PDF");
 

data/vendor/kreuzberg-tesseract/Cargo.toml

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kreuzberg
 version: !ruby/object:Gem::Version
-  version: 4.2.13
+  version: 4.2.14
 platform: ruby
 authors:
 - Na'aman Hirschfeld