kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

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

@@ -19,74 +19,13 @@ use crate::plugins::DocumentExtractor;
 use crate::types::ExtractionResult;
 #[cfg(feature = "office")]
 use crate::types::LibreOfficeConversionResult;
-use crate::utils::{PoolSizeHint, estimate_pool_size, intern_mime_type};
 use crate::{KreuzbergError, Result};
-#[cfg(feature = "tokio-runtime")]
 use once_cell::sync::Lazy;
 #[cfg(feature = "office")]
 use serde_json::json;
 use std::path::Path;
 use std::sync::Arc;
 
-/// Record error information in the current OpenTelemetry span.
-///
-/// This function records error details in the current span when the `otel` feature is enabled.
-/// It marks the span with `otel.status_code=ERROR` and adds error type and message fields.
-///
-/// # Arguments
-///
-/// * `error` - The error to record in the span
-///
-/// # Example
-///
-/// ```rust,ignore
-/// let result = extract_file("doc.pdf", None, &config).await;
-/// #[cfg(feature = "otel")]
-/// if let Err(ref e) = result {
-///     record_error(e);
-/// }
-/// result
-/// ```
-#[cfg(feature = "otel")]
-fn record_error(error: &KreuzbergError) {
-    let span = tracing::Span::current();
-    span.record("otel.status_code", "ERROR");
-    span.record("error.type", format!("{:?}", error));
-    span.record("error.message", error.to_string());
-}
-
-/// Sanitize a file path to return only the filename.
-///
-/// This function extracts the filename from a path to avoid recording
-/// potentially sensitive full file paths in telemetry data.
-///
-/// # Arguments
-///
-/// * `path` - The path to sanitize
-///
-/// # Returns
-///
-/// The filename as a string, or "unknown" if extraction fails
-///
-/// # Security
-///
-/// This prevents PII (personally identifiable information) from appearing in
-/// traces by only recording filenames instead of full paths.
-///
-/// # Example
-///
-/// ```rust,ignore
-/// let path = Path::new("/home/user/documents/secret.pdf");
-/// assert_eq!(sanitize_path(path), "secret.pdf");
-/// ```
-#[cfg(feature = "otel")]
-fn sanitize_path(path: &Path) -> String {
-    path.file_name()
-        .and_then(|n| n.to_str())
-        .unwrap_or("unknown")
-        .to_string()
-}
-
 /// Global Tokio runtime for synchronous operations.
 ///
 /// This runtime is lazily initialized on first use and shared across all sync wrappers.
@@ -99,12 +38,6 @@ fn sanitize_path(path: &Path) -> String {
 /// 2. If runtime creation fails, the process is already in a critical state
 /// 3. This is a one-time initialization - if it fails, nothing will work
 /// 4. Better to fail fast than return errors from every sync operation
-///
-/// # Availability
-///
-/// This static is only available when the `tokio-runtime` feature is enabled.
-/// For WASM targets, use the truly synchronous extraction functions instead.
-#[cfg(feature = "tokio-runtime")]
 static GLOBAL_RUNTIME: Lazy<tokio::runtime::Runtime> = Lazy::new(|| {
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
@@ -129,34 +62,6 @@ fn get_extractor(mime_type: &str) -> Result<Arc<dyn DocumentExtractor>> {
     registry_read.get(mime_type)
 }
 
-/// Get optimal pool sizing hint for a document.
-///
-/// This function calculates recommended pool sizes based on the document's
-/// file size and MIME type. The hint can be used to create appropriately
-/// sized thread pools for extraction, reducing memory waste from over-allocation.
-///
-/// # Arguments
-///
-/// * `file_size` - The size of the file in bytes
-/// * `mime_type` - The MIME type of the document
-///
-/// # Returns
-///
-/// A `PoolSizeHint` with recommended pool configurations
-///
-/// # Example
-///
-/// ```rust,ignore
-/// use kreuzberg::core::extractor::get_pool_sizing_hint;
-///
-/// let hint = get_pool_sizing_hint(5_000_000, "application/pdf");
-/// println!("Recommended string buffers: {}", hint.string_buffer_count);
-/// ```
-#[inline]
-pub fn get_pool_sizing_hint(file_size: u64, mime_type: &str) -> PoolSizeHint {
-    estimate_pool_size(file_size, mime_type)
-}
-
 /// Extract content from a file.
 ///
 /// This is the main entry point for file-based extraction. It performs the following steps:
@@ -196,12 +101,6 @@ pub fn get_pool_sizing_hint(file_size: u64, mime_type: &str) -> PoolSizeHint {
 /// # Ok(())
 /// # }
 /// ```
-#[cfg_attr(feature = "otel", tracing::instrument(
-    skip(config, path),
-    fields(
-        extraction.filename = tracing::field::Empty,
-    )
-))]
 pub async fn extract_file(
     path: impl AsRef<Path>,
     mime_type: Option<&str>,
@@ -211,119 +110,86 @@ pub async fn extract_file(
 
     let path = path.as_ref();
 
-    #[cfg(feature = "otel")]
-    {
-        let span = tracing::Span::current();
-        span.record("extraction.filename", sanitize_path(path));
-    }
-
-    let result = async {
-        io::validate_file_exists(path)?;
+    io::validate_file_exists(path)?;
 
-        let detected_mime = mime::detect_or_validate(Some(path), mime_type)?;
+    let detected_mime = mime::detect_or_validate(Some(path), mime_type)?;
 
-        match detected_mime.as_str() {
-            #[cfg(feature = "office")]
-            LEGACY_WORD_MIME_TYPE => {
-                let original_bytes = tokio::fs::read(path).await?;
-                let conversion = convert_doc_to_docx(&original_bytes).await?;
-                let mut result =
-                    extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
-                apply_libreoffice_metadata(&mut result, LEGACY_WORD_MIME_TYPE, &conversion);
-                return Ok(result);
-            }
-            #[cfg(not(feature = "office"))]
-            LEGACY_WORD_MIME_TYPE => {
-                return Err(KreuzbergError::UnsupportedFormat(
-                    "Legacy Word conversion requires the `office` feature or LibreOffice support".to_string(),
-                ));
-            }
-            #[cfg(feature = "office")]
-            LEGACY_POWERPOINT_MIME_TYPE => {
-                let original_bytes = tokio::fs::read(path).await?;
-                let conversion = convert_ppt_to_pptx(&original_bytes).await?;
-                let mut result =
-                    extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
-                apply_libreoffice_metadata(&mut result, LEGACY_POWERPOINT_MIME_TYPE, &conversion);
-                return Ok(result);
-            }
-            #[cfg(not(feature = "office"))]
-            LEGACY_POWERPOINT_MIME_TYPE => {
-                return Err(KreuzbergError::UnsupportedFormat(
-                    "Legacy PowerPoint conversion requires the `office` feature or LibreOffice support".to_string(),
-                ));
-            }
-            _ => {}
+    match detected_mime.as_str() {
+        #[cfg(feature = "office")]
+        LEGACY_WORD_MIME_TYPE => {
+            let original_bytes = tokio::fs::read(path).await?;
+            let conversion = convert_doc_to_docx(&original_bytes).await?;
+            let mut result =
+                extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
+            apply_libreoffice_metadata(&mut result, LEGACY_WORD_MIME_TYPE, &conversion);
+            return Ok(result);
         }
-
-        extract_file_with_extractor(path, &detected_mime, config).await
-    }
-    .await;
-
-    #[cfg(feature = "otel")]
-    if let Err(ref e) = result {
-        record_error(e);
+        #[cfg(not(feature = "office"))]
+        LEGACY_WORD_MIME_TYPE => {
+            return Err(KreuzbergError::UnsupportedFormat(
+                "Legacy Word conversion requires the `office` feature or LibreOffice support".to_string(),
+            ));
+        }
+        #[cfg(feature = "office")]
+        LEGACY_POWERPOINT_MIME_TYPE => {
+            let original_bytes = tokio::fs::read(path).await?;
+            let conversion = convert_ppt_to_pptx(&original_bytes).await?;
+            let mut result =
+                extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
+            apply_libreoffice_metadata(&mut result, LEGACY_POWERPOINT_MIME_TYPE, &conversion);
+            return Ok(result);
+        }
+        #[cfg(not(feature = "office"))]
+        LEGACY_POWERPOINT_MIME_TYPE => {
+            return Err(KreuzbergError::UnsupportedFormat(
+                "Legacy PowerPoint conversion requires the `office` feature or LibreOffice support".to_string(),
+            ));
+        }
+        _ => {}
     }
 
-    result
+    extract_file_with_extractor(path, &detected_mime, config).await
 }
 
 /// Extract content from a byte array.
-#[cfg_attr(feature = "otel", tracing::instrument(
-    skip(config, content),
-    fields(
-        extraction.mime_type = mime_type,
-        extraction.size_bytes = content.len(),
-    )
-))]
 pub async fn extract_bytes(content: &[u8], mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
     use crate::core::mime;
 
-    let result = async {
-        let validated_mime = mime::validate_mime_type(mime_type)?;
-
-        match validated_mime.as_str() {
-            #[cfg(feature = "office")]
-            LEGACY_WORD_MIME_TYPE => {
-                let conversion = convert_doc_to_docx(content).await?;
-                let mut result =
-                    extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
-                apply_libreoffice_metadata(&mut result, LEGACY_WORD_MIME_TYPE, &conversion);
-                return Ok(result);
-            }
-            #[cfg(not(feature = "office"))]
-            LEGACY_WORD_MIME_TYPE => {
-                return Err(KreuzbergError::UnsupportedFormat(
-                    "Legacy Word conversion requires the `office` feature or LibreOffice support".to_string(),
-                ));
-            }
-            #[cfg(feature = "office")]
-            LEGACY_POWERPOINT_MIME_TYPE => {
-                let conversion = convert_ppt_to_pptx(content).await?;
-                let mut result =
-                    extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
-                apply_libreoffice_metadata(&mut result, LEGACY_POWERPOINT_MIME_TYPE, &conversion);
-                return Ok(result);
-            }
-            #[cfg(not(feature = "office"))]
-            LEGACY_POWERPOINT_MIME_TYPE => {
-                return Err(KreuzbergError::UnsupportedFormat(
-                    "Legacy PowerPoint conversion requires the `office` feature or LibreOffice support".to_string(),
-                ));
-            }
-            _ => {}
-        }
+    let validated_mime = mime::validate_mime_type(mime_type)?;
 
-        extract_bytes_with_extractor(content, &validated_mime, config).await
-    }
-    .await;
-
-    #[cfg(feature = "otel")]
-    if let Err(ref e) = result {
-        record_error(e);
+    match validated_mime.as_str() {
+        #[cfg(feature = "office")]
+        LEGACY_WORD_MIME_TYPE => {
+            let conversion = convert_doc_to_docx(content).await?;
+            let mut result =
+                extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
+            apply_libreoffice_metadata(&mut result, LEGACY_WORD_MIME_TYPE, &conversion);
+            return Ok(result);
+        }
+        #[cfg(not(feature = "office"))]
+        LEGACY_WORD_MIME_TYPE => {
+            return Err(KreuzbergError::UnsupportedFormat(
+                "Legacy Word conversion requires the `office` feature or LibreOffice support".to_string(),
+            ));
+        }
+        #[cfg(feature = "office")]
+        LEGACY_POWERPOINT_MIME_TYPE => {
+            let conversion = convert_ppt_to_pptx(content).await?;
+            let mut result =
+                extract_bytes_with_extractor(&conversion.converted_bytes, &conversion.target_mime, config).await?;
+            apply_libreoffice_metadata(&mut result, LEGACY_POWERPOINT_MIME_TYPE, &conversion);
+            return Ok(result);
+        }
+        #[cfg(not(feature = "office"))]
+        LEGACY_POWERPOINT_MIME_TYPE => {
+            return Err(KreuzbergError::UnsupportedFormat(
+                "Legacy PowerPoint conversion requires the `office` feature or LibreOffice support".to_string(),
+            ));
+        }
+        _ => {}
     }
 
-    result
+    extract_bytes_with_extractor(content, &validated_mime, config).await
 }
 
 /// Extract content from multiple files concurrently.
@@ -346,13 +212,6 @@ pub async fn extract_bytes(content: &[u8], mime_type: &str, config: &ExtractionC
 ///
 /// Individual file errors are captured in the result metadata. System errors
 /// (IO, RuntimeError equivalents) will bubble up and fail the entire batch.
-#[cfg(feature = "tokio-runtime")]
-#[cfg_attr(feature = "otel", tracing::instrument(
-    skip(config, paths),
-    fields(
-        extraction.batch_size = paths.len(),
-    )
-))]
 pub async fn batch_extract_file(
     paths: Vec<impl AsRef<Path>>,
     config: &ExtractionConfig,
@@ -367,9 +226,7 @@ pub async fn batch_extract_file(
 
     let config = Arc::new(config.clone());
 
-    let max_concurrent = config
-        .max_concurrent_extractions
-        .unwrap_or_else(|| (num_cpus::get() as f64 * 1.5).ceil() as usize);
+    let max_concurrent = config.max_concurrent_extractions.unwrap_or_else(|| num_cpus::get() * 2);
     let semaphore = Arc::new(Semaphore::new(max_concurrent));
 
     let mut tasks = JoinSet::new();
@@ -396,8 +253,11 @@ pub async fn batch_extract_file(
                 results[index] = Some(result);
             }
             Ok((index, Err(e))) => {
-                // All errors (including Io) should create error results
-                // instead of causing early return that abandons running tasks
+                // OSError/RuntimeError must bubble up - system errors need user reports ~keep
+                if matches!(e, KreuzbergError::Io(_)) {
+                    return Err(e);
+                }
+
                 use crate::types::{ErrorMetadata, Metadata};
                 let metadata = Metadata {
                     error: Some(ErrorMetadata {
@@ -415,7 +275,6 @@ pub async fn batch_extract_file(
                     detected_languages: None,
                     chunks: None,
                     images: None,
-                    pages: None,
                 });
             }
             Err(join_err) => {
@@ -443,15 +302,8 @@ pub async fn batch_extract_file(
 /// # Returns
 ///
 /// A vector of `ExtractionResult` in the same order as the input.
-#[cfg(feature = "tokio-runtime")]
-#[cfg_attr(feature = "otel", tracing::instrument(
-    skip(config, contents),
-    fields(
-        extraction.batch_size = contents.len(),
-    )
-))]
 pub async fn batch_extract_bytes(
-    contents: Vec<(Vec<u8>, String)>,
+    contents: Vec<(&[u8], &str)>,
     config: &ExtractionConfig,
 ) -> Result<Vec<ExtractionResult>> {
     use std::sync::Arc;
@@ -465,14 +317,17 @@ pub async fn batch_extract_bytes(
     let batch_config = config.clone();
     let config = Arc::new(batch_config);
 
-    let max_concurrent = config
-        .max_concurrent_extractions
-        .unwrap_or_else(|| (num_cpus::get() as f64 * 1.5).ceil() as usize);
+    let max_concurrent = config.max_concurrent_extractions.unwrap_or_else(|| num_cpus::get() * 2);
     let semaphore = Arc::new(Semaphore::new(max_concurrent));
 
+    let owned_contents: Vec<(Vec<u8>, String)> = contents
+        .into_iter()
+        .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
+        .collect();
+
     let mut tasks = JoinSet::new();
 
-    for (index, (bytes, mime_type)) in contents.into_iter().enumerate() {
+    for (index, (bytes, mime_type)) in owned_contents.into_iter().enumerate() {
         let config_clone = Arc::clone(&config);
         let semaphore_clone = Arc::clone(&semaphore);
 
@@ -494,8 +349,11 @@ pub async fn batch_extract_bytes(
                 results[index] = Some(result);
             }
             Ok((index, Err(e))) => {
-                // All errors (including Io) should create error results
-                // instead of causing early return that abandons running tasks
+                // OSError/RuntimeError must bubble up - system errors need user reports ~keep
+                if matches!(e, KreuzbergError::Io(_)) {
+                    return Err(e);
+                }
+
                 use crate::types::{ErrorMetadata, Metadata};
                 let metadata = Metadata {
                     error: Some(ErrorMetadata {
@@ -513,7 +371,6 @@ pub async fn batch_extract_bytes(
                     detected_languages: None,
                     chunks: None,
                     images: None,
-                    pages: None,
                 });
             }
             Err(join_err) => {
@@ -533,10 +390,6 @@ pub async fn batch_extract_bytes(
 ///
 /// Uses the global Tokio runtime for 100x+ performance improvement over creating
 /// a new runtime per call. Always uses the global runtime to avoid nested runtime issues.
-///
-/// This function is only available with the `tokio-runtime` feature. For WASM targets,
-/// use a truly synchronous extraction approach instead.
-#[cfg(feature = "tokio-runtime")]
 pub fn extract_file_sync(
     path: impl AsRef<Path>,
     mime_type: Option<&str>,
@@ -549,31 +402,14 @@ pub fn extract_file_sync(
 ///
 /// Uses the global Tokio runtime for 100x+ performance improvement over creating
 /// a new runtime per call.
-///
-/// With the `tokio-runtime` feature, this blocks the current thread using the global
-/// Tokio runtime. Without it (WASM), this calls a truly synchronous implementation.
-#[cfg(feature = "tokio-runtime")]
 pub fn extract_bytes_sync(content: &[u8], mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
     GLOBAL_RUNTIME.block_on(extract_bytes(content, mime_type, config))
 }
 
-/// Synchronous wrapper for `extract_bytes` (WASM-compatible version).
-///
-/// This is a truly synchronous implementation without tokio runtime dependency.
-/// It calls `extract_bytes_sync_impl()` to perform the extraction.
-#[cfg(not(feature = "tokio-runtime"))]
-pub fn extract_bytes_sync(content: &[u8], mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
-    extract_bytes_sync_impl(content.to_vec(), Some(mime_type.to_string()), Some(config.clone()))
-}
-
 /// Synchronous wrapper for `batch_extract_file`.
 ///
 /// Uses the global Tokio runtime for 100x+ performance improvement over creating
 /// a new runtime per call.
-///
-/// This function is only available with the `tokio-runtime` feature. For WASM targets,
-/// use a truly synchronous extraction approach instead.
-#[cfg(feature = "tokio-runtime")]
 pub fn batch_extract_file_sync(
     paths: Vec<impl AsRef<Path>>,
     config: &ExtractionConfig,
@@ -585,109 +421,13 @@ pub fn batch_extract_file_sync(
 ///
 /// Uses the global Tokio runtime for 100x+ performance improvement over creating
 /// a new runtime per call.
-///
-/// With the `tokio-runtime` feature, this blocks the current thread using the global
-/// Tokio runtime. Without it (WASM), this calls a truly synchronous implementation
-/// that iterates through items and calls `extract_bytes_sync()`.
-#[cfg(feature = "tokio-runtime")]
 pub fn batch_extract_bytes_sync(
-    contents: Vec<(Vec<u8>, String)>,
+    contents: Vec<(&[u8], &str)>,
     config: &ExtractionConfig,
 ) -> Result<Vec<ExtractionResult>> {
     GLOBAL_RUNTIME.block_on(batch_extract_bytes(contents, config))
 }
 
-/// Synchronous wrapper for `batch_extract_bytes` (WASM-compatible version).
-///
-/// This is a truly synchronous implementation that iterates through items
-/// and calls `extract_bytes_sync()` for each.
-#[cfg(not(feature = "tokio-runtime"))]
-pub fn batch_extract_bytes_sync(
-    contents: Vec<(Vec<u8>, String)>,
-    config: &ExtractionConfig,
-) -> Result<Vec<ExtractionResult>> {
-    let mut results = Vec::with_capacity(contents.len());
-    for (content, mime_type) in contents {
-        let result = extract_bytes_sync(&content, &mime_type, config);
-        results.push(result.unwrap_or_else(|e| {
-            use crate::types::{ErrorMetadata, Metadata};
-            ExtractionResult {
-                content: format!("Error: {}", e),
-                mime_type: pool_mime_type("text/plain"),
-                metadata: Metadata {
-                    error: Some(ErrorMetadata {
-                        error_type: format!("{:?}", e),
-                        message: e.to_string(),
-                    }),
-                    ..Default::default()
-                },
-                tables: vec![],
-                detected_languages: None,
-                chunks: None,
-                images: None,
-                pages: None,
-            }
-        }));
-    }
-    Ok(results)
-}
-
-/// Synchronous extraction implementation for WASM compatibility.
-///
-/// This function performs extraction without requiring a tokio runtime.
-/// It calls the sync extractor methods directly.
-///
-/// # Arguments
-///
-/// * `content` - The byte content to extract
-/// * `mime_type` - Optional MIME type to validate/use
-/// * `config` - Optional extraction configuration
-///
-/// # Returns
-///
-/// An `ExtractionResult` or a `KreuzbergError`
-///
-/// # Implementation Notes
-///
-/// This is called when the `tokio-runtime` feature is disabled.
-/// It replicates the logic of `extract_bytes` but uses synchronous extractor methods.
-#[cfg(not(feature = "tokio-runtime"))]
-fn extract_bytes_sync_impl(
-    content: Vec<u8>,
-    mime_type: Option<String>,
-    config: Option<ExtractionConfig>,
-) -> Result<ExtractionResult> {
-    use crate::core::mime;
-
-    let config = config.unwrap_or_default();
-
-    let validated_mime = if let Some(mime) = mime_type {
-        mime::validate_mime_type(&mime)?
-    } else {
-        return Err(KreuzbergError::Validation {
-            message: "MIME type is required for synchronous extraction".to_string(),
-            source: None,
-        });
-    };
-
-    crate::extractors::ensure_initialized()?;
-
-    let extractor = get_extractor(&validated_mime)?;
-
-    let sync_extractor = extractor.as_sync_extractor().ok_or_else(|| {
-        KreuzbergError::UnsupportedFormat(format!(
-            "Extractor for '{}' does not support synchronous extraction",
-            validated_mime
-        ))
-    })?;
-
-    let mut result = sync_extractor.extract_sync(&content, &validated_mime, &config)?;
-
-    result = crate::core::pipeline::run_pipeline_sync(result, &config)?;
-
-    Ok(result)
-}
-
 async fn extract_file_with_extractor(
     path: &Path,
     mime_type: &str,
@@ -714,29 +454,13 @@ async fn extract_bytes_with_extractor(
     Ok(result)
 }
 
-/// Convert a MIME type string to a pooled String for efficient deduplication.
-///
-/// This function uses the string interning pool to reduce memory allocations
-/// for repeatedly used MIME types (e.g., "application/pdf" appears thousands of times
-/// in batch processing). The interned string is converted to an owned String to satisfy
-/// the ExtractionResult::mime_type field type.
-///
-/// # Performance
-///
-/// 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.
-#[allow(dead_code)]
-fn pool_mime_type(mime_type: &str) -> String {
-    intern_mime_type(mime_type).to_string()
-}
-
 #[cfg(feature = "office")]
 fn apply_libreoffice_metadata(
     result: &mut ExtractionResult,
     legacy_mime: &str,
     conversion: &LibreOfficeConversionResult,
 ) {
-    result.mime_type = pool_mime_type(legacy_mime);
+    result.mime_type = legacy_mime.to_string();
     result.metadata.additional.insert(
         "libreoffice_conversion".to_string(),
         json!({
@@ -756,10 +480,6 @@ mod tests {
     use std::io::Write;
     use tempfile::tempdir;
 
-    fn assert_text_content(actual: &str, expected: &str) {
-        assert_eq!(actual.trim_end_matches('\n'), expected);
-    }
-
     #[tokio::test]
     async fn test_extract_file_basic() {
         let dir = tempdir().unwrap();
@@ -772,7 +492,7 @@ mod tests {
 
         assert!(result.is_ok());
         let result = result.unwrap();
-        assert_text_content(&result.content, "Hello, world!");
+        assert_eq!(result.content, "Hello, world!");
         assert_eq!(result.mime_type, "text/plain");
     }
 
@@ -805,7 +525,7 @@ mod tests {
 
         assert!(result.is_ok());
         let result = result.unwrap();
-        assert_text_content(&result.content, "test content");
+        assert_eq!(result.content, "test content");
         assert_eq!(result.mime_type, "text/plain");
     }
 
@@ -833,8 +553,8 @@ mod tests {
         assert!(results.is_ok());
         let results = results.unwrap();
         assert_eq!(results.len(), 2);
-        assert_text_content(&results[0].content, "content 1");
-        assert_text_content(&results[1].content, "content 2");
+        assert_eq!(results[0].content, "content 1");
+        assert_eq!(results[1].content, "content 2");
     }
 
     #[tokio::test]
@@ -854,17 +574,13 @@ mod tests {
             (b"content 1".as_slice(), "text/plain"),
             (b"content 2".as_slice(), "text/plain"),
         ];
-        let owned_contents: Vec<(Vec<u8>, String)> = contents
-            .into_iter()
-            .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
-            .collect();
-        let results = batch_extract_bytes(owned_contents, &config).await;
+        let results = batch_extract_bytes(contents, &config).await;
 
         assert!(results.is_ok());
         let results = results.unwrap();
         assert_eq!(results.len(), 2);
-        assert_text_content(&results[0].content, "content 1");
-        assert_text_content(&results[1].content, "content 2");
+        assert_eq!(results[0].content, "content 1");
+        assert_eq!(results[1].content, "content 2");
     }
 
     #[test]
@@ -877,8 +593,7 @@ mod tests {
 
         let result = extract_file_sync(&file_path, None, &config);
         assert!(result.is_ok());
-        let result = result.unwrap();
-        assert_text_content(&result.content, "sync test");
+        assert_eq!(result.unwrap().content, "sync test");
 
         let result = extract_bytes_sync(b"test", "text/plain", &config);
         assert!(result.is_ok());
@@ -890,14 +605,12 @@ mod tests {
 
         let result1 = extract_bytes(b"test 1", "text/plain", &config).await;
         assert!(result1.is_ok());
-        let result1 = result1.unwrap();
 
         let result2 = extract_bytes(b"test 2", "text/plain", &config).await;
         assert!(result2.is_ok());
-        let result2 = result2.unwrap();
 
-        assert_text_content(&result1.content, "test 1");
-        assert_text_content(&result2.content, "test 2");
+        assert_eq!(result1.unwrap().content, "test 1");
+        assert_eq!(result2.unwrap().content, "test 2");
 
         let result3 = extract_bytes(b"# test 3", "text/markdown", &config).await;
         assert!(result3.is_ok());
@@ -963,8 +676,7 @@ mod tests {
         let result = extract_file(&file_path, None, &config).await;
 
         assert!(result.is_ok());
-        let result = result.unwrap();
-        assert_text_content(&result.content, "content");
+        assert_eq!(result.unwrap().content, "content");
     }
 
     #[tokio::test]
@@ -1004,7 +716,7 @@ mod tests {
         assert!(results.is_ok());
         let results = results.unwrap();
         assert_eq!(results.len(), 2);
-        assert_text_content(&results[0].content, "valid content");
+        assert_eq!(results[0].content, "valid content");
         assert!(results[1].metadata.error.is_some());
     }
 
@@ -1016,18 +728,14 @@ mod tests {
             (b"invalid".as_slice(), "invalid/mime"),
             (b"valid 2".as_slice(), "text/plain"),
         ];
-        let owned_contents: Vec<(Vec<u8>, String)> = contents
-            .into_iter()
-            .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
-            .collect();
-        let results = batch_extract_bytes(owned_contents, &config).await;
+        let results = batch_extract_bytes(contents, &config).await;
 
         assert!(results.is_ok());
         let results = results.unwrap();
         assert_eq!(results.len(), 3);
-        assert_text_content(&results[0].content, "valid 1");
+        assert_eq!(results[0].content, "valid 1");
         assert!(results[1].metadata.error.is_some());
-        assert_text_content(&results[2].content, "valid 2");
+        assert_eq!(results[2].content, "valid 2");
     }
 
     #[tokio::test]
@@ -1037,11 +745,7 @@ mod tests {
             (b"test 1".as_slice(), "invalid/mime1"),
             (b"test 2".as_slice(), "invalid/mime2"),
         ];
-        let owned_contents: Vec<(Vec<u8>, String)> = contents
-            .into_iter()
-            .map(|(bytes, mime)| (bytes.to_vec(), mime.to_string()))
-            .collect();
-        let results = batch_extract_bytes(owned_contents, &config).await;
+        let results = batch_extract_bytes(contents, &config).await;
 
         assert!(results.is_ok());
         let results = results.unwrap();
@@ -1058,8 +762,7 @@ mod tests {
 
         assert!(result.is_ok());
         let result = result.unwrap();
-        let trimmed_len = result.content.trim_end_matches('\n').len();
-        assert_eq!(trimmed_len, 10_000_000);
+        assert_eq!(result.content.len(), 10_000_000);
     }
 
     #[tokio::test]
@@ -1084,7 +787,7 @@ mod tests {
         assert_eq!(results.len(), 100);
 
         for (i, result) in results.iter().enumerate() {
-            assert_text_content(&result.content, &format!("content {}", i));
+            assert_eq!(result.content, format!("content {}", i));
         }
     }
 
@@ -1137,7 +840,7 @@ mod tests {
     #[test]
     fn test_sync_wrapper_batch_bytes_empty() {
         let config = ExtractionConfig::default();
-        let contents: Vec<(Vec<u8>, String)> = vec![];
+        let contents: Vec<(&[u8], &str)> = vec![];
         let results = batch_extract_bytes_sync(contents, &config);
 
         assert!(results.is_ok());