kreuzberg 4.0.0.pre.rc.19 → 4.0.0.pre.rc.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f5df1c1138122d449d77193b97ee6c4f40de044077765f1d68ce4f0bc6aba2a
-  data.tar.gz: c48abedda657f892a912cd9cca7f40167fa3257d75f98527e0bc95da4580e630
+  metadata.gz: bc17da6af86a2e71001e5e5844c764fbabdc29e1b777b368d179fd505f8440f1
+  data.tar.gz: eae32510b4c628b8aa73dd943fc0adf60c316efc2e20d2910e84a0f60bf9da24
 SHA512:
-  metadata.gz: a2a0a7854003f48d69eb89cf79a3252aadba11f001edfe7ba4d03f16198b3d68394bd84589c5b379c7a4dcd4784391a2fd3b1c5ce636d8a490382a77d62fd671
-  data.tar.gz: f3d571515eb5598e34fdc8dd18296cd069a6fa25e7cf9017a9f3f1980a82fcebca977e9fc18e361d0f00386f72109ffe8f3e1afcf15dcbc35b5e6472b3f83853
+  metadata.gz: 869652660b57b61427d58ef01d832efc6854aa20c232db1c5fe0d1ce8601a70368c675d4b904be18d86f5b8d8b4730dbbfb050744457b03cf69063060c7521e8
+  data.tar.gz: 0c534272a1ddf5427221fde1917ab682b86adc7c1773d49865612240134b7576959f2bb2e4101fd00a5193016e6e141e0d01d1d29cfd82e4e1f25d057185be8a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kreuzberg (4.0.0.pre.rc.19)
+    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.lock

@@ -2540,7 +2540,7 @@ dependencies = [
 
 [[package]]
 name = "kreuzberg-rb"
-version = "4.0.0-rc.19"
+version = "4.0.0-rc.20"
 dependencies = [
  "async-trait",
  "html-to-markdown-rs",

data/ext/kreuzberg_rb/native/Cargo.toml

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

data/ext/kreuzberg_rb/native/src/lib.rs

@@ -670,6 +670,8 @@ fn parse_postprocessor_config(ruby: &Ruby, hash: RHash) -> Result<PostProcessorC
         enabled,
         enabled_processors,
         disabled_processors,
+        enabled_set: None,
+        disabled_set: None,
     };
 
     Ok(config)

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.19'
+  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.19"
+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.19"
+version = "4.0.0-rc.21"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -167,7 +167,10 @@ reqwest = { version = "0.12.25", default-features = false, features = [
     "rustls-tls",
 ], optional = true }
 # Format extractors (optional)
-pdfium-render = { version = "0.8.37", features = ["thread_safe", "image_latest"], optional = true }
+pdfium-render = { package = "kreuzberg-pdfium-render", version = "0.9.0", features = [
+    "thread_safe",
+    "image_latest",
+], optional = true }
 lopdf = { version = "0.38.0", optional = true }
 calamine = { version = "0.32.0", features = ["dates"], optional = true }
 polars = { version = "0.52.0", default-features = false, features = ["ipc"], optional = true }

data/vendor/kreuzberg/examples/bench_fixes.rs

@@ -0,0 +1,74 @@
+use kreuzberg::{ExtractionConfig, extract_file_sync};
+use std::path::PathBuf;
+use std::time::Instant;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let test_pdfs = [
+        (
+            "a_comprehensive_study_of_convergent_and_commutative_replicated_data_types.pdf",
+            "Academic Paper (18 fonts)",
+        ),
+        (
+            "5_level_paging_and_5_level_ept_intel_revision_1_1_may_2017.pdf",
+            "Intel PDF (5 fonts)",
+        ),
+        ("fake_memo.pdf", "Tiny Memo (3-5 fonts)"),
+    ];
+
+    let config = ExtractionConfig {
+        use_cache: false,
+        ..Default::default()
+    };
+
+    println!("=== PDFium Fork Fixes Benchmark ===\n");
+    println!("Testing warm execution fix and font overhead fix\n");
+
+    for (file, description) in &test_pdfs {
+        let path = PathBuf::from(format!("test_documents/pdfs/{}", file));
+        println!("=== {} ===", description);
+        println!("File: {}\n", file);
+
+        // Cold start
+        let start = Instant::now();
+        let result = extract_file_sync(&path, None, &config)?;
+        let cold = start.elapsed();
+        println!("Cold start:  {:>8.2} ms", cold.as_secs_f64() * 1000.0);
+        println!("Text length: {} chars\n", result.content.len());
+
+        // Warm iterations
+        let mut warm_times = Vec::new();
+        for i in 1..=5 {
+            let start = Instant::now();
+            let _ = extract_file_sync(&path, None, &config)?;
+            let warm = start.elapsed();
+            warm_times.push(warm);
+            let speedup = cold.as_micros() as f64 / warm.as_micros() as f64;
+            println!(
+                "Warm {:>2}:     {:>8.2} ms ({:>5.2}x faster than cold)",
+                i,
+                warm.as_secs_f64() * 1000.0,
+                speedup
+            );
+        }
+
+        // Statistics
+        let avg_warm = warm_times.iter().sum::<std::time::Duration>() / warm_times.len() as u32;
+        let avg_speedup = cold.as_micros() as f64 / avg_warm.as_micros() as f64;
+        println!(
+            "\nAverage warm: {:>8.2} ms ({:>5.2}x faster than cold)",
+            avg_warm.as_secs_f64() * 1000.0,
+            avg_speedup
+        );
+        println!("\n{}\n", "=".repeat(60));
+    }
+
+    println!("\n=== Success Criteria ===");
+    println!("✓ Warm Execution Fix:");
+    println!("  - Warm times should be 1-3x faster than cold (realistic)");
+    println!("  - NOT 100-700x faster (the bug we fixed)");
+    println!("\n✓ Font Overhead Fix:");
+    println!("  - Academic Paper cold: ~130-145ms (matches baseline)");
+    println!("  - NOT 180-195ms (the regression we fixed)");
+
+    Ok(())
+}

data/vendor/kreuzberg/examples/test_pdfium_fork.rs

@@ -0,0 +1,65 @@
+use kreuzberg::{ExtractionConfig, extract_file};
+use std::time::Instant;
+
+#[tokio::main]
+async fn main() {
+    let config = ExtractionConfig {
+        use_cache: false,
+        ..Default::default()
+    };
+
+    println!("Testing PDF extraction with cleaned pdfium-render fork...\n");
+
+    // Test 1: Simple extraction
+    println!("Test 1: fake_memo.pdf");
+    let start = Instant::now();
+    match extract_file("test_documents/pdfs/fake_memo.pdf", None, &config).await {
+        Ok(result) => {
+            let duration = start.elapsed();
+            println!("  ✓ Success! Duration: {:?}", duration);
+            println!("  ✓ Text length: {} chars", result.content.len());
+        }
+        Err(e) => {
+            println!("  ✗ Failed: {}", e);
+            std::process::exit(1);
+        }
+    }
+
+    // Test 2: Warm iteration
+    println!("\nTest 2: Warm iteration");
+    let start = Instant::now();
+    match extract_file("test_documents/pdfs/fake_memo.pdf", None, &config).await {
+        Ok(result) => {
+            let duration = start.elapsed();
+            println!("  ✓ Success! Duration: {:?}", duration);
+            println!("  ✓ Text length: {} chars", result.content.len());
+        }
+        Err(e) => {
+            println!("  ✗ Failed: {}", e);
+            std::process::exit(1);
+        }
+    }
+
+    // Test 3: Academic Paper (font-heavy)
+    println!("\nTest 3: Academic Paper (18 fonts)");
+    let start = Instant::now();
+    match extract_file(
+        "test_documents/pdfs/a_comprehensive_study_of_convergent_and_commutative_replicated_data_types.pdf",
+        None,
+        &config,
+    )
+    .await
+    {
+        Ok(result) => {
+            let duration = start.elapsed();
+            println!("  ✓ Success! Duration: {:?}", duration);
+            println!("  ✓ Text length: {} chars", result.content.len());
+        }
+        Err(e) => {
+            println!("  ✗ Failed: {}", e);
+            std::process::exit(1);
+        }
+    }
+
+    println!("\n✅ All tests passed! Cleaned pdfium-render fork is working correctly.");
+}

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

@@ -392,26 +392,26 @@ impl DocumentExtractor for PdfExtractor {
             {
                 // For WASM targets, PDFium must be properly initialized in the environment.
                 // 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()
+                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,
                             }
-                        })?;
-                let pdfium = Pdfium::new(bindings);
+                        } else {
+                            pdf_err.into()
+                        }
+                    },
+                )?;
+                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 {
@@ -431,13 +431,12 @@ impl DocumentExtractor for PdfExtractor {
                     tokio::task::spawn_blocking(move || {
                         let _guard = span.entered();
 
-                        let bindings =
-                            crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
+                        crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                        let pdfium = Pdfium::new(bindings);
+                        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 {
@@ -464,13 +463,12 @@ impl DocumentExtractor for PdfExtractor {
                     .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")?;
+                    crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                    let pdfium = Pdfium::new(bindings);
+                    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,13 +482,12 @@ impl DocumentExtractor for PdfExtractor {
             }
             #[cfg(all(not(target_arch = "wasm32"), not(feature = "tokio-runtime")))]
             {
-                let bindings =
-                    crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
+                crate::pdf::bindings::bind_pdfium(PdfError::MetadataExtractionFailed, "initialize Pdfium")?;
 
-                let pdfium = Pdfium::new(bindings);
+                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,10 +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<Box<dyn PdfiumLibraryBindings>, 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)
@@ -97,55 +94,26 @@ pub(crate) fn bind_pdfium(
     // Initialize on first call
     match &*state {
         InitializationState::Uninitialized => match bind_pdfium_impl() {
-            Ok((lib_dir, _bindings)) => {
+            Ok((lib_dir, 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, proceed to create bindings below
-        }
-    }
-
-    // Create fresh bindings from cached state
-    #[cfg(all(feature = "pdf", feature = "bundled-pdfium", not(target_arch = "wasm32")))]
-    {
-        match &*state {
-            InitializationState::Initialized { lib_dir: Some(lib_dir) } => {
-                Pdfium::bind_to_library(Pdfium::pdfium_platform_library_name_at_path(lib_dir))
-                    .map_err(|e| map_err(format!("Failed to create Pdfium bindings ({}): {}", context, e)))
-            }
-            _ => {
-                // This should not happen as state is guaranteed to be Initialized here
-                Err(map_err(format!(
-                    "Internal error: Pdfium state not properly initialized ({})",
-                    context
-                )))
-            }
+            // Already initialized, return a new accessor to the singleton
+            Ok(Pdfium)
         }
     }
-
-    // For system pdfium or WASM, create fresh bindings
-    #[cfg(all(feature = "pdf", feature = "bundled-pdfium", target_arch = "wasm32"))]
-    {
-        Pdfium::bind_to_system_library()
-            .map_err(|e| map_err(format!("Failed to create Pdfium bindings ({}): {}", context, e)))
-    }
-
-    #[cfg(all(feature = "pdf", not(feature = "bundled-pdfium")))]
-    {
-        Pdfium::bind_to_system_library()
-            .map_err(|e| map_err(format!("Failed to create Pdfium bindings ({}): {}", context, e)))
-    }
 }
 
 #[cfg(test)]
@@ -158,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

@@ -11,6 +11,7 @@ pub enum PdfError {
     RenderingFailed(String),
     MetadataExtractionFailed(String),
     ExtractionFailed(String),
+    FontLoadingFailed(String),
     IOError(String),
 }
 
@@ -30,6 +31,7 @@ impl fmt::Display for PdfError {
                 write!(f, "Metadata extraction failed: {}", msg)
             }
             PdfError::ExtractionFailed(msg) => write!(f, "Extraction failed: {}", msg),
+            PdfError::FontLoadingFailed(msg) => write!(f, "Font loading failed: {}", msg),
             PdfError::IOError(msg) => write!(f, "I/O error: {}", msg),
         }
     }
@@ -50,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::*;
@@ -127,4 +157,71 @@ mod tests {
         let err = PdfError::ExtractionFailed("page data mismatch".to_string());
         assert_eq!(err.to_string(), "Extraction failed: page data mismatch");
     }
+
+    #[test]
+    fn test_font_loading_failed_error() {
+        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"));
+    }
 }