kreuzberg 4.0.0.pre.rc.20 → 4.0.0.pre.rc.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f4c578323928e218a33fd0941a5b98e598da2a67567ecf59e1f76ac02299ac1
-  data.tar.gz: dde6bdee61e7baf36f2028ca3d06a746fa254263ee597fa2e47e28879d4afa06
+  metadata.gz: bc17da6af86a2e71001e5e5844c764fbabdc29e1b777b368d179fd505f8440f1
+  data.tar.gz: eae32510b4c628b8aa73dd943fc0adf60c316efc2e20d2910e84a0f60bf9da24
 SHA512:
-  metadata.gz: d1e0a132d36eb9f6ce3abe27ac258a37f08b3028dafe6cebff55145a2218ea324682c3273134fd4626f1f5bd9f326cdf6e18270d9db759a1caafd2447052c1b4
-  data.tar.gz: a62f75e8d66d289532a5943c472c30642f3215e3d46555618632c4bfaf8826ea077b2ecb585e46b180706df12808b5206ff8ce697ff4962e76ea674c7eeaf952
+  metadata.gz: 869652660b57b61427d58ef01d832efc6854aa20c232db1c5fe0d1ce8601a70368c675d4b904be18d86f5b8d8b4730dbbfb050744457b03cf69063060c7521e8
+  data.tar.gz: 0c534272a1ddf5427221fde1917ab682b86adc7c1773d49865612240134b7576959f2bb2e4101fd00a5193016e6e141e0d01d1d29cfd82e4e1f25d057185be8a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kreuzberg (4.0.0.pre.rc.20)
+    kreuzberg (4.0.0.pre.rc.21)
 
 GEM
   remote: https://rubygems.org/
@@ -66,7 +66,7 @@ GEM
     rb-fsevent (0.11.2)
     rb-inotify (0.11.1)
       ffi (~> 1.0)
-    rb_sys (0.9.123)
+    rb_sys (0.9.119)
       rake-compiler-dock (= 1.10.0)
     rbs (3.10.0)
       logger
@@ -147,7 +147,7 @@ DEPENDENCIES
   pry-byebug (~> 3.10)
   rake (~> 13.0)
   rake-compiler (~> 1.2)
-  rb_sys (~> 0.9.119)
+  rb_sys (= 0.9.119)
   rbs (~> 3.0)
   rspec (~> 3.12)
   rubocop (~> 1.66)

data/ext/kreuzberg_rb/native/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "kreuzberg-rb"
-version = "4.0.0-rc.20"
+version = "4.0.0-rc.21"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/kreuzberg.gemspec

@@ -201,7 +201,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 4.0'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rake-compiler', '~> 1.2'
-  spec.add_development_dependency 'rb_sys', '~> 0.9.119'
+  spec.add_development_dependency 'rb_sys', '0.9.119'
   spec.add_development_dependency 'rspec', '~> 3.12'
   unless Gem.win_platform?
     spec.add_development_dependency 'rbs', '~> 3.0'

data/lib/kreuzberg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kreuzberg
-  VERSION = '4.0.0-rc.20'
+  VERSION = '4.0.0-rc.21'
 end

data/vendor/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["kreuzberg", "kreuzberg-tesseract", "kreuzberg-ffi"]
 
 [workspace.package]
-version = "4.0.0-rc.20"
+version = "4.0.0-rc.21"
 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.0.0-rc.20"
+version = "4.0.0-rc.21"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

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

@@ -1254,6 +1254,9 @@ enable_quality_processing = true
         let config1 = ExtractionConfig::from_toml_file(&config_path).unwrap();
         assert!(!config1.use_cache);
 
+        // Sleep to ensure mtime changes (some filesystems have 1-second granularity)
+        std::thread::sleep(std::time::Duration::from_secs(1));
+
         fs::write(
             &config_path,
             r#"

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

@@ -293,49 +293,32 @@ impl EpubExtractor {
     }
 
     /// Extract metadata from EPUB OPF file
-    fn extract_metadata(opf_xml: &str) -> Result<BTreeMap<String, serde_json::Value>> {
-        let mut metadata = BTreeMap::new();
+    fn extract_metadata(opf_xml: &str) -> Result<(OepbMetadata, BTreeMap<String, serde_json::Value>)> {
+        let mut additional_metadata = BTreeMap::new();
 
         let (epub_metadata, _) = Self::parse_opf(opf_xml)?;
 
-        if let Some(title) = epub_metadata.title {
-            metadata.insert("title".to_string(), serde_json::json!(title));
+        if let Some(identifier) = epub_metadata.identifier.clone() {
+            additional_metadata.insert("identifier".to_string(), serde_json::json!(identifier));
         }
 
-        if let Some(creator) = epub_metadata.creator {
-            metadata.insert("creator".to_string(), serde_json::json!(creator.clone()));
-            metadata.insert("authors".to_string(), serde_json::json!(vec![creator]));
+        if let Some(publisher) = epub_metadata.publisher.clone() {
+            additional_metadata.insert("publisher".to_string(), serde_json::json!(publisher));
         }
 
-        if let Some(date) = epub_metadata.date {
-            metadata.insert("date".to_string(), serde_json::json!(date));
+        if let Some(subject) = epub_metadata.subject.clone() {
+            additional_metadata.insert("subject".to_string(), serde_json::json!(subject));
         }
 
-        if let Some(language) = epub_metadata.language {
-            metadata.insert("language".to_string(), serde_json::json!(language));
+        if let Some(description) = epub_metadata.description.clone() {
+            additional_metadata.insert("description".to_string(), serde_json::json!(description));
         }
 
-        if let Some(identifier) = epub_metadata.identifier {
-            metadata.insert("identifier".to_string(), serde_json::json!(identifier));
+        if let Some(rights) = epub_metadata.rights.clone() {
+            additional_metadata.insert("rights".to_string(), serde_json::json!(rights));
         }
 
-        if let Some(publisher) = epub_metadata.publisher {
-            metadata.insert("publisher".to_string(), serde_json::json!(publisher));
-        }
-
-        if let Some(subject) = epub_metadata.subject {
-            metadata.insert("subject".to_string(), serde_json::json!(subject));
-        }
-
-        if let Some(description) = epub_metadata.description {
-            metadata.insert("description".to_string(), serde_json::json!(description));
-        }
-
-        if let Some(rights) = epub_metadata.rights {
-            metadata.insert("rights".to_string(), serde_json::json!(rights));
-        }
-
-        Ok(metadata)
+        Ok((epub_metadata, additional_metadata))
     }
 
     /// Parse container.xml to find the OPF file path
@@ -564,13 +547,18 @@ impl DocumentExtractor for EpubExtractor {
 
         let extracted_content = Self::extract_content(&mut archive, &opf_path, &manifest_dir)?;
 
-        let metadata_btree = Self::extract_metadata(&opf_xml)?;
-        let metadata_map: std::collections::HashMap<String, serde_json::Value> = metadata_btree.into_iter().collect();
+        let (epub_metadata, additional_metadata) = Self::extract_metadata(&opf_xml)?;
+        let metadata_map: std::collections::HashMap<String, serde_json::Value> =
+            additional_metadata.into_iter().collect();
 
         Ok(ExtractionResult {
             content: extracted_content,
             mime_type: mime_type.to_string(),
             metadata: Metadata {
+                title: epub_metadata.title,
+                authors: epub_metadata.creator.map(|c| vec![c]),
+                language: epub_metadata.language,
+                created_at: epub_metadata.date,
                 additional: metadata_map,
                 ..Default::default()
             },

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

@@ -408,10 +408,10 @@ impl DocumentExtractor for PdfExtractor {
                         }
                     },
                 )?;
-                let pdfium = Pdfium {};
+                let pdfium = Pdfium;
 
                 let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                    let err_msg = e.to_string();
+                    let err_msg = crate::pdf::error::format_pdfium_error(e);
                     if err_msg.contains("password") || err_msg.contains("Password") {
                         PdfError::PasswordRequired
                     } else {
@@ -433,10 +433,10 @@ impl DocumentExtractor for PdfExtractor {
 
                         crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                        let pdfium = Pdfium {};
+                        let pdfium = Pdfium;
 
                         let document = pdfium.load_pdf_from_byte_slice(&content_owned, None).map_err(|e| {
-                            let err_msg = e.to_string();
+                            let err_msg = crate::pdf::error::format_pdfium_error(e);
                             if err_msg.contains("password") || err_msg.contains("Password") {
                                 PdfError::PasswordRequired
                             } else {
@@ -465,10 +465,10 @@ impl DocumentExtractor for PdfExtractor {
                 } else {
                     crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                    let pdfium = Pdfium {};
+                    let pdfium = Pdfium;
 
                     let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                        let err_msg = e.to_string();
+                        let err_msg = crate::pdf::error::format_pdfium_error(e);
                         if err_msg.contains("password") || err_msg.contains("Password") {
                             PdfError::PasswordRequired
                         } else {
@@ -484,10 +484,10 @@ impl DocumentExtractor for PdfExtractor {
             {
                 crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                let pdfium = Pdfium {};
+                let pdfium = Pdfium;
 
                 let document = pdfium.load_pdf_from_byte_slice(content, None).map_err(|e| {
-                    let err_msg = e.to_string();
+                    let err_msg = crate::pdf::error::format_pdfium_error(e);
                     if err_msg.contains("password") || err_msg.contains("Password") {
                         PdfError::PasswordRequired
                     } else {

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

@@ -82,7 +82,7 @@ fn bind_pdfium_impl() -> Result<(Option<PathBuf>, Box<dyn PdfiumLibraryBindings>
 /// Instead of failing permanently, we recover by extracting the inner value from the
 /// poisoned lock and proceeding. This ensures PDF extraction can continue even if an
 /// earlier panic occurred, as long as the state is consistent.
-pub(crate) fn bind_pdfium(map_err: fn(String) -> PdfError, context: &'static str) -> Result<(), PdfError> {
+pub(crate) fn bind_pdfium(map_err: fn(String) -> PdfError, context: &'static str) -> Result<Pdfium, PdfError> {
     let mut state = PDFIUM_STATE.lock().unwrap_or_else(|poisoned| {
         // SAFETY: Recovering from a poisoned lock is safe here because:
         // 1. The poisoned state still contains valid data (just a guard from a panicked thread)
@@ -95,27 +95,25 @@ pub(crate) fn bind_pdfium(map_err: fn(String) -> PdfError, context: &'static str
     match &*state {
         InitializationState::Uninitialized => match bind_pdfium_impl() {
             Ok((lib_dir, bindings)) => {
-                // Initialize Pdfium singleton with the bindings
-                let _ = Pdfium::new(bindings);
+                // Initialize Pdfium singleton with the bindings and return it
+                let pdfium = Pdfium::new(bindings);
                 *state = InitializationState::Initialized { lib_dir };
+                Ok(pdfium)
             }
             Err(err) => {
                 *state = InitializationState::Failed(err.clone());
-                return Err(map_err(format!("Pdfium initialization failed ({}): {}", context, err)));
+                Err(map_err(format!("Pdfium initialization failed ({}): {}", context, err)))
             }
         },
-        InitializationState::Failed(err) => {
-            return Err(map_err(format!(
-                "Pdfium initialization previously failed ({}): {}",
-                context, err
-            )));
-        }
+        InitializationState::Failed(err) => Err(map_err(format!(
+            "Pdfium initialization previously failed ({}): {}",
+            context, err
+        ))),
         InitializationState::Initialized { .. } => {
-            // Already initialized, nothing to do
+            // Already initialized, return a new accessor to the singleton
+            Ok(Pdfium)
         }
     }
-
-    Ok(())
 }
 
 #[cfg(test)]
@@ -128,6 +126,9 @@ mod tests {
         // First call should initialize
         let result = bind_pdfium(PdfError::TextExtractionFailed, "test context");
         assert!(result.is_ok(), "First bind_pdfium call should succeed");
+        // Verify the returned Pdfium instance is usable
+        let pdfium = result.unwrap();
+        assert!(pdfium.is_pdfium_ready(), "Pdfium should be initialized");
     }
 
     #[test]

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

@@ -52,6 +52,34 @@ impl From<lopdf::Error> for PdfError {
 
 pub type Result<T> = std::result::Result<T, PdfError>;
 
+/// Format a pdfium error for display.
+///
+/// The kreuzberg-pdfium-render fork's error type doesn't implement Display,
+/// so Debug formatting produces messages like "PdfiumLibraryInternalError(FormatError,)"
+/// with trailing commas and parentheses. This function cleans up the formatting.
+pub(crate) fn format_pdfium_error<E: std::fmt::Debug>(error: E) -> String {
+    let debug_msg = format!("{:?}", error);
+
+    // Extract the variant name and clean up Debug formatting
+    // "PdfiumLibraryInternalError(FormatError,)" -> "PdfiumLibraryInternalError: FormatError"
+    // "SomeError" -> "SomeError"
+    if let Some(paren_idx) = debug_msg.find('(') {
+        let variant = &debug_msg[..paren_idx];
+        let inner = &debug_msg[paren_idx + 1..];
+
+        // Remove trailing ",)" or ")"
+        let inner_clean = inner.trim_end_matches(')').trim_end_matches(',');
+
+        if inner_clean.is_empty() {
+            variant.to_string()
+        } else {
+            format!("{}: {}", variant, inner_clean)
+        }
+    } else {
+        debug_msg
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -135,4 +163,65 @@ mod tests {
         let err = PdfError::FontLoadingFailed("missing font file".to_string());
         assert_eq!(err.to_string(), "Font loading failed: missing font file");
     }
+
+    #[test]
+    fn test_format_pdfium_error_with_inner_value() {
+        // Simulate pdfium error: "PdfiumLibraryInternalError(FormatError,)"
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        struct MockError(String);
+
+        let error = MockError("FormatError,".to_string());
+        let formatted = format_pdfium_error(error);
+        // Should clean up the trailing comma
+        assert!(formatted.contains("MockError"));
+        assert!(formatted.contains("FormatError"));
+    }
+
+    #[test]
+    fn test_format_pdfium_error_simple() {
+        // Simulate simple error without parentheses
+        #[derive(Debug)]
+        struct SimpleError;
+
+        let formatted = format_pdfium_error(SimpleError);
+        assert_eq!(formatted, "SimpleError");
+    }
+
+    #[test]
+    fn test_format_pdfium_error_empty_inner() {
+        // Simulate error with empty inner: "SomeError()"
+        #[derive(Debug)]
+        struct EmptyInner;
+
+        let formatted = format_pdfium_error(EmptyInner);
+        // Will be "EmptyInner" since the formatting doesn't add parentheses
+        assert_eq!(formatted, "EmptyInner");
+    }
+
+    #[test]
+    fn test_format_pdfium_error_cleans_trailing_comma() {
+        // This test simulates the actual pdfium error format
+        // "PdfiumLibraryInternalError(FormatError,)" should become
+        // "PdfiumLibraryInternalError: FormatError"
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        enum PdfiumError {
+            PdfiumLibraryInternalError(InternalError),
+        }
+
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        enum InternalError {
+            FormatError,
+        }
+
+        let error = PdfiumError::PdfiumLibraryInternalError(InternalError::FormatError);
+        let formatted = format_pdfium_error(error);
+
+        // Should not contain trailing comma or redundant parentheses
+        assert!(!formatted.contains(",)"));
+        assert!(formatted.contains("PdfiumLibraryInternalError"));
+        assert!(formatted.contains("FormatError"));
+    }
 }

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

@@ -86,12 +86,10 @@ 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> {
-    bind_pdfium(PdfError::MetadataExtractionFailed, "metadata extraction")?;
-
-    let pdfium = Pdfium {};
+    let pdfium = bind_pdfium(PdfError::MetadataExtractionFailed, "metadata extraction")?;
 
     let document = pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-        let err_msg = e.to_string();
+        let err_msg = super::error::format_pdfium_error(e);
         if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
             PdfError::InvalidPassword
         } else if err_msg.contains("password") || err_msg.contains("Password") {

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

@@ -33,9 +33,7 @@ pub struct PdfRenderer {
 
 impl PdfRenderer {
     pub fn new() -> Result<Self> {
-        bind_pdfium(PdfError::RenderingFailed, "page rendering")?;
-
-        let pdfium = Pdfium {};
+        let pdfium = bind_pdfium(PdfError::RenderingFailed, "page rendering")?;
         Ok(Self { pdfium })
     }
 
@@ -56,7 +54,7 @@ impl PdfRenderer {
         password: Option<&str>,
     ) -> Result<DynamicImage> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-            let err_msg = e.to_string();
+            let err_msg = super::error::format_pdfium_error(e);
             if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
                 PdfError::InvalidPassword
             } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -114,7 +112,7 @@ impl PdfRenderer {
         password: Option<&str>,
     ) -> Result<Vec<DynamicImage>> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-            let err_msg = e.to_string();
+            let err_msg = super::error::format_pdfium_error(e);
             if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
                 PdfError::InvalidPassword
             } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -241,7 +239,12 @@ mod tests {
 
     #[test]
     fn test_renderer_size() {
-        assert!(size_of::<PdfRenderer>() > 0);
+        // PdfRenderer may be a zero-sized type (ZST) since Pdfium is a ZST.
+        // The important thing is that the size is consistent and the type is valid.
+        // We just verify the type can be instantiated rather than checking specific size.
+        use std::mem::size_of;
+        let _size = size_of::<PdfRenderer>();
+        // If this compiles and runs, the type is valid regardless of size
     }
 
     #[test]

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

@@ -19,9 +19,7 @@ pub struct PdfTextExtractor {
 
 impl PdfTextExtractor {
     pub fn new() -> Result<Self> {
-        bind_pdfium(PdfError::TextExtractionFailed, "text extraction")?;
-
-        let pdfium = Pdfium {};
+        let pdfium = bind_pdfium(PdfError::TextExtractionFailed, "text extraction")?;
         Ok(Self { pdfium })
     }
 
@@ -31,7 +29,7 @@ impl PdfTextExtractor {
 
     pub fn extract_text_with_password(&self, pdf_bytes: &[u8], password: Option<&str>) -> Result<String> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, password).map_err(|e| {
-            let err_msg = e.to_string();
+            let err_msg = super::error::format_pdfium_error(e);
             if (err_msg.contains("password") || err_msg.contains("Password")) && password.is_some() {
                 PdfError::InvalidPassword
             } else if err_msg.contains("password") || err_msg.contains("Password") {
@@ -67,7 +65,7 @@ impl PdfTextExtractor {
 
     pub fn get_page_count(&self, pdf_bytes: &[u8]) -> Result<usize> {
         let document = self.pdfium.load_pdf_from_byte_slice(pdf_bytes, None).map_err(|e| {
-            let err_msg = e.to_string();
+            let err_msg = super::error::format_pdfium_error(e);
             if err_msg.contains("password") || err_msg.contains("Password") {
                 PdfError::PasswordRequired
             } else {

data/vendor/kreuzberg-ffi/build.rs

@@ -154,6 +154,17 @@ fn copy_pdfium_from_dir(src_dir: &Path, dest_dir: &Path) -> Result<(), String> {
 
         if file_name_str.starts_with("libpdfium") || file_name_str.starts_with("pdfium") {
             let dest_file = dest_dir.join(file_name);
+
+            // On Windows, skip copy if destination already exists and is accessible
+            // This avoids "Access denied" errors when the DLL is in use
+            if dest_file.exists() {
+                eprintln!(
+                    "PDFium library already exists at {}, skipping copy",
+                    dest_file.display()
+                );
+                return Ok(());
+            }
+
             match fs::copy(&path, &dest_file) {
                 Ok(bytes_copied) => {
                     eprintln!(

data/vendor/kreuzberg-tesseract/Cargo.toml

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kreuzberg
 version: !ruby/object:Gem::Version
-  version: 4.0.0.pre.rc.20
+  version: 4.0.0.pre.rc.21
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-25 00:00:00.000000000 Z
+date: 2025-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,14 +56,14 @@ dependencies:
   name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.9.119
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.9.119
 - !ruby/object:Gem::Dependency