kreuzberg 4.0.8 → 4.1.1

data/vendor/kreuzberg/src/extractors/{pdf.rs → pdf/mod.rs}

@@ -1,233 +1,31 @@
 //! PDF document extractor.
+//!
+//! Provides extraction of text, metadata, tables, and images from PDF documents
+//! using pypdfium2 and playa-pdf. Supports both native text extraction and OCR fallback.
+
+mod extraction;
+mod ocr;
+mod pages;
 
 use crate::Result;
 use crate::core::config::ExtractionConfig;
 use crate::plugins::{DocumentExtractor, Plugin};
-use crate::types::{ExtractionResult, Metadata, PageContent};
+use crate::types::{ExtractionResult, Metadata};
 use async_trait::async_trait;
 #[cfg(feature = "tokio-runtime")]
 use std::path::Path;
 
 #[cfg(feature = "pdf")]
 use crate::pdf::error::PdfError;
-#[cfg(feature = "ocr")]
-use crate::pdf::rendering::{PageRenderOptions, PdfRenderer};
-#[cfg(feature = "pdf")]
-use crate::types::Table;
-#[cfg(feature = "pdf")]
-use pdfium_render::prelude::*;
-
-#[cfg(feature = "pdf")]
-type PdfExtractionPhaseResult = (
-    crate::pdf::metadata::PdfExtractionMetadata,
-    String,
-    Vec<Table>,
-    Option<Vec<PageContent>>,
-);
 
+// Re-export for backward compatibility
 #[cfg(feature = "ocr")]
-const MIN_TOTAL_NON_WHITESPACE: usize = 64;
-#[cfg(feature = "ocr")]
-const MIN_NON_WHITESPACE_PER_PAGE: f64 = 32.0;
-#[cfg(feature = "ocr")]
-const MIN_MEANINGFUL_WORD_LEN: usize = 4;
-#[cfg(feature = "ocr")]
-const MIN_MEANINGFUL_WORDS: usize = 3;
-#[cfg(feature = "ocr")]
-const MIN_ALNUM_RATIO: f64 = 0.3;
-
-#[cfg(feature = "ocr")]
-struct NativeTextStats {
-    non_whitespace: usize,
-    alnum: usize,
-    meaningful_words: usize,
-    alnum_ratio: f64,
-}
-
-#[cfg(feature = "ocr")]
-struct OcrFallbackDecision {
-    stats: NativeTextStats,
-    avg_non_whitespace: f64,
-    avg_alnum: f64,
-    fallback: bool,
-}
-
-#[cfg(feature = "ocr")]
-impl NativeTextStats {
-    fn from(text: &str) -> Self {
-        let mut non_whitespace = 0usize;
-        let mut alnum = 0usize;
-
-        for ch in text.chars() {
-            if !ch.is_whitespace() {
-                non_whitespace += 1;
-                if ch.is_alphanumeric() {
-                    alnum += 1;
-                }
-            }
-        }
-
-        let meaningful_words = text
-            .split_whitespace()
-            .filter(|word| {
-                word.chars()
-                    .filter(|c| c.is_alphanumeric())
-                    .take(MIN_MEANINGFUL_WORD_LEN)
-                    .count()
-                    >= MIN_MEANINGFUL_WORD_LEN
-            })
-            .take(MIN_MEANINGFUL_WORDS)
-            .count();
-
-        let alnum_ratio = if non_whitespace == 0 {
-            0.0
-        } else {
-            alnum as f64 / non_whitespace as f64
-        };
-
-        Self {
-            non_whitespace,
-            alnum,
-            meaningful_words,
-            alnum_ratio,
-        }
-    }
-}
+pub use ocr::{NativeTextStats, OcrFallbackDecision, evaluate_native_text_for_ocr};
 
+use extraction::extract_all_from_document;
 #[cfg(feature = "ocr")]
-fn evaluate_native_text_for_ocr(native_text: &str, page_count: Option<usize>) -> OcrFallbackDecision {
-    let trimmed = native_text.trim();
-
-    if trimmed.is_empty() {
-        let empty_stats = NativeTextStats {
-            non_whitespace: 0,
-            alnum: 0,
-            meaningful_words: 0,
-            alnum_ratio: 0.0,
-        };
-        return OcrFallbackDecision {
-            stats: empty_stats,
-            avg_non_whitespace: 0.0,
-            avg_alnum: 0.0,
-            fallback: true,
-        };
-    }
-
-    let stats = NativeTextStats::from(trimmed);
-    let pages = page_count.unwrap_or(1).max(1) as f64;
-    let avg_non_whitespace = stats.non_whitespace as f64 / pages;
-    let avg_alnum = stats.alnum as f64 / pages;
-
-    let has_substantial_text = stats.non_whitespace >= MIN_TOTAL_NON_WHITESPACE
-        && avg_non_whitespace >= MIN_NON_WHITESPACE_PER_PAGE
-        && stats.meaningful_words >= MIN_MEANINGFUL_WORDS;
-
-    let fallback = if stats.non_whitespace == 0 || stats.alnum == 0 {
-        true
-    } else if has_substantial_text {
-        false
-    } else if (stats.alnum_ratio < MIN_ALNUM_RATIO && avg_alnum < MIN_NON_WHITESPACE_PER_PAGE)
-        || (stats.non_whitespace < MIN_TOTAL_NON_WHITESPACE && avg_non_whitespace < MIN_NON_WHITESPACE_PER_PAGE)
-    {
-        true
-    } else {
-        stats.meaningful_words == 0 && avg_non_whitespace < MIN_NON_WHITESPACE_PER_PAGE
-    };
-
-    OcrFallbackDecision {
-        stats,
-        avg_non_whitespace,
-        avg_alnum,
-        fallback,
-    }
-}
-
-/// Extract tables from PDF document using native text positions.
-///
-/// This function converts PDF character positions to HocrWord format,
-/// then uses the existing table reconstruction logic to detect tables.
-///
-/// Uses the shared PdfDocument reference (wrapped in Arc<RwLock<>> for thread-safety).
-#[cfg(all(feature = "pdf", feature = "ocr"))]
-fn extract_tables_from_document(
-    document: &PdfDocument,
-    _metadata: &crate::pdf::metadata::PdfExtractionMetadata,
-) -> Result<Vec<Table>> {
-    use crate::ocr::table::{reconstruct_table, table_to_markdown};
-    use crate::pdf::table::extract_words_from_page;
-
-    let mut all_tables = Vec::new();
-
-    for (page_index, page) in document.pages().iter().enumerate() {
-        let words = extract_words_from_page(&page, 0.0)?;
-
-        if words.is_empty() {
-            continue;
-        }
-
-        let column_threshold = 50;
-        let row_threshold_ratio = 0.5;
-
-        let table_cells = reconstruct_table(&words, column_threshold, row_threshold_ratio);
-
-        if !table_cells.is_empty() {
-            let markdown = table_to_markdown(&table_cells);
-
-            all_tables.push(Table {
-                cells: table_cells,
-                markdown,
-                page_number: page_index + 1,
-            });
-        }
-    }
-
-    Ok(all_tables)
-}
-
-/// Fallback for when OCR feature is not enabled - returns empty tables.
-#[cfg(all(feature = "pdf", not(feature = "ocr")))]
-fn extract_tables_from_document(
-    _document: &PdfDocument,
-    _metadata: &crate::pdf::metadata::PdfExtractionMetadata,
-) -> Result<Vec<crate::types::Table>> {
-    Ok(vec![])
-}
-
-/// Helper function to assign tables and images to pages.
-///
-/// If page_contents is None, returns None (no per-page tracking enabled).
-/// Otherwise, iterates through tables and images, assigning them to pages based on page_number.
-///
-/// # Performance
-///
-/// Uses Arc::new to wrap tables and images, avoiding expensive copies.
-/// This reduces memory overhead by enabling zero-copy sharing of table/image data
-/// across multiple references (e.g., when the same table appears on multiple pages).
-fn assign_tables_and_images_to_pages(
-    mut page_contents: Option<Vec<PageContent>>,
-    tables: &[crate::types::Table],
-    images: &[crate::types::ExtractedImage],
-) -> Option<Vec<PageContent>> {
-    let pages = page_contents.take()?;
-
-    let mut updated_pages = pages;
-
-    for table in tables {
-        if let Some(page) = updated_pages.iter_mut().find(|p| p.page_number == table.page_number) {
-            page.tables.push(std::sync::Arc::new(table.clone()));
-        }
-    }
-
-    for image in images {
-        if let Some(page_num) = image.page_number
-            && let Some(page) = updated_pages.iter_mut().find(|p| p.page_number == page_num)
-        {
-            page.images.push(std::sync::Arc::new(image.clone()));
-        }
-    }
-
-    Some(updated_pages)
-}
+use ocr::extract_with_ocr;
+use pages::assign_tables_and_images_to_pages;
 
 /// PDF document extractor using pypdfium2 and playa-pdf.
 pub struct PdfExtractor;
@@ -242,105 +40,6 @@ impl PdfExtractor {
     pub fn new() -> Self {
         Self
     }
-
-    /// Extract text, metadata, and tables from a PDF document using a single shared instance.
-    ///
-    /// This method consolidates all PDF extraction phases (text, metadata, tables) into a single
-    /// operation using a single PdfDocument instance. This avoids redundant document parsing
-    /// and pdfium initialization overhead.
-    ///
-    /// # Performance
-    ///
-    /// By reusing a single document instance across all extraction phases, we eliminate:
-    /// - Duplicate document parsing overhead (25-40ms saved)
-    /// - Redundant pdfium bindings initialization
-    /// - Multiple page tree traversals
-    ///
-    /// Expected improvement: 20-30% faster PDF processing.
-    ///
-    /// # Returns
-    ///
-    /// A tuple containing:
-    /// - PDF metadata (title, authors, dates, page structure, etc.)
-    /// - Native extracted text (or empty if using OCR)
-    /// - Extracted tables (if OCR feature enabled)
-    /// - Per-page content (if page extraction configured)
-    #[cfg(feature = "pdf")]
-    fn extract_all_from_document(
-        document: &PdfDocument,
-        config: &ExtractionConfig,
-    ) -> Result<PdfExtractionPhaseResult> {
-        let (native_text, _boundaries, page_contents, pdf_metadata) =
-            crate::pdf::text::extract_text_and_metadata_from_pdf_document(document, Some(config))?;
-
-        let tables = extract_tables_from_document(document, &pdf_metadata)?;
-
-        Ok((pdf_metadata, native_text, tables, page_contents))
-    }
-
-    /// Extract text from PDF using OCR.
-    ///
-    /// Renders all pages to images and processes them with OCR.
-    #[cfg(feature = "ocr")]
-    async fn extract_with_ocr(&self, content: &[u8], config: &ExtractionConfig) -> Result<String> {
-        use crate::plugins::registry::get_ocr_backend_registry;
-        use image::ImageEncoder;
-        use image::codecs::png::PngEncoder;
-        use std::io::Cursor;
-
-        let ocr_config = config.ocr.as_ref().ok_or_else(|| crate::KreuzbergError::Parsing {
-            message: "OCR config required for force_ocr".to_string(),
-            source: None,
-        })?;
-
-        let backend = {
-            let registry = get_ocr_backend_registry();
-            let registry = registry.read().map_err(|e| crate::KreuzbergError::Plugin {
-                message: format!("Failed to acquire read lock on OCR backend registry: {}", e),
-                plugin_name: "ocr-registry".to_string(),
-            })?;
-            registry.get(&ocr_config.backend)?
-        };
-
-        let images = {
-            let render_options = PageRenderOptions::default();
-            let renderer = PdfRenderer::new().map_err(|e| crate::KreuzbergError::Parsing {
-                message: format!("Failed to initialize PDF renderer: {}", e),
-                source: None,
-            })?;
-
-            renderer
-                .render_all_pages(content, &render_options)
-                .map_err(|e| crate::KreuzbergError::Parsing {
-                    message: format!("Failed to render PDF pages: {}", e),
-                    source: None,
-                })?
-        };
-
-        let mut page_texts = Vec::with_capacity(images.len());
-
-        for image in images {
-            let rgb_image = image.to_rgb8();
-            let (width, height) = rgb_image.dimensions();
-
-            let mut image_bytes = Cursor::new(Vec::new());
-            let encoder = PngEncoder::new(&mut image_bytes);
-            encoder
-                .write_image(&rgb_image, width, height, image::ColorType::Rgb8.into())
-                .map_err(|e| crate::KreuzbergError::Parsing {
-                    message: format!("Failed to encode image: {}", e),
-                    source: None,
-                })?;
-
-            let image_data = image_bytes.into_inner();
-
-            let ocr_result = backend.process_image(&image_data, ocr_config).await?;
-
-            page_texts.push(ocr_result.content);
-        }
-
-        Ok(page_texts.join("\n\n"))
-    }
 }
 
 impl Plugin for PdfExtractor {
@@ -404,7 +103,7 @@ impl DocumentExtractor for PdfExtractor {
                     }
                 })?;
 
-                Self::extract_all_from_document(&document, config)?
+                extract_all_from_document(&document, config)?
             }
             #[cfg(all(not(target_arch = "wasm32"), feature = "tokio-runtime"))]
             {
@@ -428,7 +127,7 @@ impl DocumentExtractor for PdfExtractor {
                         })?;
 
                         let (pdf_metadata, native_text, tables, page_contents) =
-                            Self::extract_all_from_document(&document, &config_owned)?;
+                            extract_all_from_document(&document, &config_owned)?;
 
                         if let Some(page_cfg) = config_owned.pages.as_ref()
                             && page_cfg.extract_pages
@@ -458,7 +157,7 @@ impl DocumentExtractor for PdfExtractor {
                         }
                     })?;
 
-                    Self::extract_all_from_document(&document, config)?
+                    extract_all_from_document(&document, config)?
                 }
             }
             #[cfg(all(not(target_arch = "wasm32"), not(feature = "tokio-runtime")))]
@@ -475,19 +174,19 @@ impl DocumentExtractor for PdfExtractor {
                     }
                 })?;
 
-                Self::extract_all_from_document(&document, config)?
+                extract_all_from_document(&document, config)?
             }
         };
 
         #[cfg(feature = "ocr")]
         let text = if config.force_ocr {
             if config.ocr.is_some() {
-                self.extract_with_ocr(content, config).await?
+                extract_with_ocr(content, config).await?
             } else {
                 native_text
             }
         } else if config.ocr.is_some() {
-            let decision = evaluate_native_text_for_ocr(&native_text, None);
+            let decision = ocr::evaluate_native_text_for_ocr(&native_text, None);
 
             if std::env::var("KREUZBERG_DEBUG_OCR").is_ok() {
                 eprintln!(
@@ -504,7 +203,7 @@ impl DocumentExtractor for PdfExtractor {
             }
 
             if decision.fallback {
-                self.extract_with_ocr(content, config).await?
+                extract_with_ocr(content, config).await?
             } else {
                 native_text
             }
@@ -593,6 +292,8 @@ impl DocumentExtractor for PdfExtractor {
             detected_languages: None,
             chunks: None,
             images,
+            djot_content: None,
+            elements: None,
         })
     }
 
@@ -640,21 +341,21 @@ mod tests {
     #[cfg(feature = "ocr")]
     #[test]
     fn test_should_fallback_to_ocr_for_empty_text() {
-        assert!(evaluate_native_text_for_ocr("", Some(1)).fallback);
+        assert!(ocr::evaluate_native_text_for_ocr("", Some(1)).fallback);
     }
 
     #[cfg(feature = "ocr")]
     #[test]
     fn test_should_not_fallback_for_meaningful_text() {
         let sample = "This page has searchable vector text and should avoid OCR.";
-        assert!(!evaluate_native_text_for_ocr(sample, Some(1)).fallback);
+        assert!(!ocr::evaluate_native_text_for_ocr(sample, Some(1)).fallback);
     }
 
     #[cfg(feature = "ocr")]
     #[test]
     fn test_should_fallback_for_punctuation_only_text() {
         let sample = " . , ; : -- -- ";
-        assert!(evaluate_native_text_for_ocr(sample, Some(2)).fallback);
+        assert!(ocr::evaluate_native_text_for_ocr(sample, Some(2)).fallback);
     }
 
     #[tokio::test]

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

@@ -0,0 +1,214 @@
+//! OCR functionality for PDF extraction.
+//!
+//! Handles text quality evaluation, OCR fallback decision logic, and OCR processing.
+
+#[cfg(feature = "ocr")]
+use crate::core::config::ExtractionConfig;
+
+#[cfg(feature = "ocr")]
+pub(crate) const MIN_TOTAL_NON_WHITESPACE: usize = 64;
+#[cfg(feature = "ocr")]
+pub(crate) const MIN_NON_WHITESPACE_PER_PAGE: f64 = 32.0;
+#[cfg(feature = "ocr")]
+pub(crate) const MIN_MEANINGFUL_WORD_LEN: usize = 4;
+#[cfg(feature = "ocr")]
+pub(crate) const MIN_MEANINGFUL_WORDS: usize = 3;
+#[cfg(feature = "ocr")]
+pub(crate) const MIN_ALNUM_RATIO: f64 = 0.3;
+
+#[cfg(feature = "ocr")]
+pub struct NativeTextStats {
+    pub non_whitespace: usize,
+    pub alnum: usize,
+    pub meaningful_words: usize,
+    pub alnum_ratio: f64,
+}
+
+#[cfg(feature = "ocr")]
+pub struct OcrFallbackDecision {
+    pub stats: NativeTextStats,
+    pub avg_non_whitespace: f64,
+    pub avg_alnum: f64,
+    pub fallback: bool,
+}
+
+#[cfg(feature = "ocr")]
+impl NativeTextStats {
+    pub fn from(text: &str) -> Self {
+        let mut non_whitespace = 0usize;
+        let mut alnum = 0usize;
+
+        for ch in text.chars() {
+            if !ch.is_whitespace() {
+                non_whitespace += 1;
+                if ch.is_alphanumeric() {
+                    alnum += 1;
+                }
+            }
+        }
+
+        let meaningful_words = text
+            .split_whitespace()
+            .filter(|word| {
+                word.chars()
+                    .filter(|c| c.is_alphanumeric())
+                    .take(MIN_MEANINGFUL_WORD_LEN)
+                    .count()
+                    >= MIN_MEANINGFUL_WORD_LEN
+            })
+            .take(MIN_MEANINGFUL_WORDS)
+            .count();
+
+        let alnum_ratio = if non_whitespace == 0 {
+            0.0
+        } else {
+            alnum as f64 / non_whitespace as f64
+        };
+
+        Self {
+            non_whitespace,
+            alnum,
+            meaningful_words,
+            alnum_ratio,
+        }
+    }
+}
+
+/// Evaluates native PDF text quality to determine if OCR fallback is needed.
+///
+/// Analyzes text characteristics (whitespace, alphanumeric ratio, meaningful words)
+/// to detect cases where native text extraction produced poor results (e.g., scanned
+/// PDFs with garbled text).
+///
+/// # Arguments
+///
+/// * `native_text` - The text extracted from the PDF using native methods
+/// * `page_count` - Optional page count for per-page average calculations
+///
+/// # Returns
+///
+/// An `OcrFallbackDecision` containing:
+/// - Statistics about the text quality
+/// - Per-page averages
+/// - Boolean decision on whether to use OCR
+#[cfg(feature = "ocr")]
+pub fn evaluate_native_text_for_ocr(native_text: &str, page_count: Option<usize>) -> OcrFallbackDecision {
+    let trimmed = native_text.trim();
+
+    if trimmed.is_empty() {
+        let empty_stats = NativeTextStats {
+            non_whitespace: 0,
+            alnum: 0,
+            meaningful_words: 0,
+            alnum_ratio: 0.0,
+        };
+        return OcrFallbackDecision {
+            stats: empty_stats,
+            avg_non_whitespace: 0.0,
+            avg_alnum: 0.0,
+            fallback: true,
+        };
+    }
+
+    let stats = NativeTextStats::from(trimmed);
+    let pages = page_count.unwrap_or(1).max(1) as f64;
+    let avg_non_whitespace = stats.non_whitespace as f64 / pages;
+    let avg_alnum = stats.alnum as f64 / pages;
+
+    let has_substantial_text = stats.non_whitespace >= MIN_TOTAL_NON_WHITESPACE
+        && avg_non_whitespace >= MIN_NON_WHITESPACE_PER_PAGE
+        && stats.meaningful_words >= MIN_MEANINGFUL_WORDS;
+
+    let fallback = if stats.non_whitespace == 0 || stats.alnum == 0 {
+        true
+    } else if has_substantial_text {
+        false
+    } else if (stats.alnum_ratio < MIN_ALNUM_RATIO && avg_alnum < MIN_NON_WHITESPACE_PER_PAGE)
+        || (stats.non_whitespace < MIN_TOTAL_NON_WHITESPACE && avg_non_whitespace < MIN_NON_WHITESPACE_PER_PAGE)
+    {
+        true
+    } else {
+        stats.meaningful_words == 0 && avg_non_whitespace < MIN_NON_WHITESPACE_PER_PAGE
+    };
+
+    OcrFallbackDecision {
+        stats,
+        avg_non_whitespace,
+        avg_alnum,
+        fallback,
+    }
+}
+
+/// Extract text from PDF using OCR.
+///
+/// Renders all pages to images and processes them with OCR backend.
+///
+/// # Arguments
+///
+/// * `content` - Raw PDF bytes
+/// * `config` - Extraction configuration including OCR settings
+///
+/// # Returns
+///
+/// Concatenated text from all pages, separated by double newlines
+#[cfg(feature = "ocr")]
+pub(crate) async fn extract_with_ocr(content: &[u8], config: &ExtractionConfig) -> crate::Result<String> {
+    use crate::pdf::rendering::{PageRenderOptions, PdfRenderer};
+    use crate::plugins::registry::get_ocr_backend_registry;
+    use image::ImageEncoder;
+    use image::codecs::png::PngEncoder;
+    use std::io::Cursor;
+
+    let ocr_config = config.ocr.as_ref().ok_or_else(|| crate::KreuzbergError::Parsing {
+        message: "OCR config required for force_ocr".to_string(),
+        source: None,
+    })?;
+
+    let backend = {
+        let registry = get_ocr_backend_registry();
+        let registry = registry.read().map_err(|e| crate::KreuzbergError::Plugin {
+            message: format!("Failed to acquire read lock on OCR backend registry: {}", e),
+            plugin_name: "ocr-registry".to_string(),
+        })?;
+        registry.get(&ocr_config.backend)?
+    };
+
+    let images = {
+        let render_options = PageRenderOptions::default();
+        let renderer = PdfRenderer::new().map_err(|e| crate::KreuzbergError::Parsing {
+            message: format!("Failed to initialize PDF renderer: {}", e),
+            source: None,
+        })?;
+
+        renderer
+            .render_all_pages(content, &render_options)
+            .map_err(|e| crate::KreuzbergError::Parsing {
+                message: format!("Failed to render PDF pages: {}", e),
+                source: None,
+            })?
+    };
+
+    let mut page_texts = Vec::with_capacity(images.len());
+
+    for image in images {
+        let rgb_image = image.to_rgb8();
+        let (width, height) = rgb_image.dimensions();
+
+        let mut image_bytes = Cursor::new(Vec::new());
+        let encoder = PngEncoder::new(&mut image_bytes);
+        encoder
+            .write_image(&rgb_image, width, height, image::ColorType::Rgb8.into())
+            .map_err(|e| crate::KreuzbergError::Parsing {
+                message: format!("Failed to encode image: {}", e),
+                source: None,
+            })?;
+
+        let image_data = image_bytes.into_inner();
+
+        let ocr_result = backend.process_image(&image_data, ocr_config).await?;
+
+        page_texts.push(ocr_result.content);
+    }
+
+    Ok(page_texts.join("\n\n"))
+}

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

@@ -0,0 +1,51 @@
+//! Page content management for PDF extraction.
+//!
+//! Handles assignment of tables and images to specific pages.
+
+use crate::types::PageContent;
+
+/// Helper function to assign tables and images to pages.
+///
+/// If page_contents is None, returns None (no per-page tracking enabled).
+/// Otherwise, iterates through tables and images, assigning them to pages based on page_number.
+///
+/// # Performance
+///
+/// Uses Arc::new to wrap tables and images, avoiding expensive copies.
+/// This reduces memory overhead by enabling zero-copy sharing of table/image data
+/// across multiple references (e.g., when the same table appears on multiple pages).
+///
+/// # Arguments
+///
+/// * `page_contents` - Optional vector of page contents to populate
+/// * `tables` - Slice of tables to assign to pages
+/// * `images` - Slice of images to assign to pages
+///
+/// # Returns
+///
+/// Updated page contents with tables and images assigned, or None if page tracking disabled
+pub(crate) fn assign_tables_and_images_to_pages(
+    mut page_contents: Option<Vec<PageContent>>,
+    tables: &[crate::types::Table],
+    images: &[crate::types::ExtractedImage],
+) -> Option<Vec<PageContent>> {
+    let pages = page_contents.take()?;
+
+    let mut updated_pages = pages;
+
+    for table in tables {
+        if let Some(page) = updated_pages.iter_mut().find(|p| p.page_number == table.page_number) {
+            page.tables.push(std::sync::Arc::new(table.clone()));
+        }
+    }
+
+    for image in images {
+        if let Some(page_num) = image.page_number
+            && let Some(page) = updated_pages.iter_mut().find(|p| p.page_number == page_num)
+        {
+            page.images.push(std::sync::Arc::new(image.clone()));
+        }
+    }
+
+    Some(updated_pages)
+}