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

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

@@ -4,62 +4,9 @@
 //! quality processing, chunking, and custom hooks in the correct order.
 
 use crate::core::config::ExtractionConfig;
-use crate::plugins::{PostProcessor, ProcessingStage};
+use crate::plugins::ProcessingStage;
 use crate::types::ExtractionResult;
 use crate::{KreuzbergError, Result};
-use once_cell::sync::Lazy;
-use std::sync::Arc;
-use std::sync::RwLock as StdRwLock;
-
-/// Cached post-processors for each stage to reduce lock contention.
-///
-/// This cache is populated once during the first pipeline run and reused
-/// for all subsequent extractions, eliminating 3 of 4 registry lock acquisitions
-/// per extraction.
-struct ProcessorCache {
-    early: Arc<Vec<Arc<dyn PostProcessor>>>,
-    middle: Arc<Vec<Arc<dyn PostProcessor>>>,
-    late: Arc<Vec<Arc<dyn PostProcessor>>>,
-}
-
-impl ProcessorCache {
-    /// Create a new processor cache by fetching from the registry.
-    fn new() -> Result<Self> {
-        let processor_registry = crate::plugins::registry::get_post_processor_registry();
-        let registry = processor_registry
-            .read()
-            .map_err(|e| crate::KreuzbergError::Other(format!("Post-processor registry lock poisoned: {}", e)))?;
-
-        Ok(Self {
-            early: Arc::new(registry.get_for_stage(ProcessingStage::Early)),
-            middle: Arc::new(registry.get_for_stage(ProcessingStage::Middle)),
-            late: Arc::new(registry.get_for_stage(ProcessingStage::Late)),
-        })
-    }
-
-    /// Get processors for a specific stage from cache.
-    #[allow(dead_code)]
-    fn get_for_stage(&self, stage: ProcessingStage) -> Arc<Vec<Arc<dyn PostProcessor>>> {
-        match stage {
-            ProcessingStage::Early => Arc::clone(&self.early),
-            ProcessingStage::Middle => Arc::clone(&self.middle),
-            ProcessingStage::Late => Arc::clone(&self.late),
-        }
-    }
-}
-
-/// Lazy processor cache - initialized on first use, then cached.
-static PROCESSOR_CACHE: Lazy<StdRwLock<Option<ProcessorCache>>> = Lazy::new(|| StdRwLock::new(None));
-
-/// Clear the processor cache (primarily for testing when registry changes).
-#[allow(dead_code)]
-pub fn clear_processor_cache() -> Result<()> {
-    let mut cache = PROCESSOR_CACHE
-        .write()
-        .map_err(|e| crate::KreuzbergError::Other(format!("Processor cache lock poisoned: {}", e)))?;
-    *cache = None;
-    Ok(())
-}
 
 /// Run the post-processing pipeline on an extraction result.
 ///
@@ -83,13 +30,6 @@ pub fn clear_processor_cache() -> Result<()> {
 /// - Validator errors bubble up immediately
 /// - Post-processor errors are caught and recorded in metadata
 /// - System errors (IO, RuntimeError equivalents) always bubble up
-#[cfg_attr(feature = "otel", tracing::instrument(
-    skip(result, config),
-    fields(
-        pipeline.stage = "post_processing",
-        content.length = result.content.len(),
-    )
-))]
 pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfig) -> Result<ExtractionResult> {
     let pp_config = config.postprocessor.as_ref();
     let postprocessing_enabled = pp_config.is_none_or(|c| c.enabled);
@@ -100,61 +40,21 @@ pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfi
             let _ = crate::keywords::ensure_initialized();
         }
 
-        #[cfg(feature = "language-detection")]
-        {
-            let _ = crate::language_detection::ensure_initialized();
-        }
-
-        #[cfg(feature = "chunking")]
-        {
-            let _ = crate::chunking::ensure_initialized();
-        }
-
-        #[cfg(feature = "quality")]
-        {
-            let registry = crate::plugins::registry::get_post_processor_registry();
-            if let Ok(mut reg) = registry.write() {
-                let _ = reg.register(std::sync::Arc::new(crate::text::QualityProcessor), 30);
-            }
-        }
-
-        {
-            let mut cache_lock = PROCESSOR_CACHE
-                .write()
-                .map_err(|e| crate::KreuzbergError::Other(format!("Processor cache lock poisoned: {}", e)))?;
-            if cache_lock.is_none() {
-                *cache_lock = Some(ProcessorCache::new()?);
-            }
-        }
+        let processor_registry = crate::plugins::registry::get_post_processor_registry();
 
-        let (early_processors, middle_processors, late_processors) = {
-            let cache_lock = PROCESSOR_CACHE
-                .read()
-                .map_err(|e| crate::KreuzbergError::Other(format!("Processor cache lock poisoned: {}", e)))?;
-            let cache = cache_lock
-                .as_ref()
-                .ok_or_else(|| crate::KreuzbergError::Other("Processor cache not initialized".to_string()))?;
-            (
-                Arc::clone(&cache.early),
-                Arc::clone(&cache.middle),
-                Arc::clone(&cache.late),
-            )
-        };
+        for stage in [ProcessingStage::Early, ProcessingStage::Middle, ProcessingStage::Late] {
+            let processors = {
+                let registry = processor_registry.read().map_err(|e| {
+                    crate::KreuzbergError::Other(format!("Post-processor registry lock poisoned: {}", e))
+                })?;
+                registry.get_for_stage(stage)
+            };
 
-        for (_stage, processors_arc) in [
-            (ProcessingStage::Early, early_processors),
-            (ProcessingStage::Middle, middle_processors),
-            (ProcessingStage::Late, late_processors),
-        ] {
-            for processor in processors_arc.iter() {
+            for processor in processors {
                 let processor_name = processor.name();
 
                 let should_run = if let Some(config) = pp_config {
-                    if let Some(ref enabled_set) = config.enabled_set {
-                        enabled_set.contains(processor_name)
-                    } else if let Some(ref disabled_set) = config.disabled_set {
-                        !disabled_set.contains(processor_name)
-                    } else if let Some(ref enabled) = config.enabled_processors {
+                    if let Some(ref enabled) = config.enabled_processors {
                         enabled.iter().any(|name| name == processor_name)
                     } else if let Some(ref disabled) = config.disabled_processors {
                         !disabled.iter().any(|name| name == processor_name)
@@ -185,6 +85,35 @@ pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfi
         }
     }
 
+    #[cfg(feature = "quality")]
+    if config.enable_quality_processing {
+        let quality_score = crate::text::quality::calculate_quality_score(
+            &result.content,
+            Some(
+                &result
+                    .metadata
+                    .additional
+                    .iter()
+                    .map(|(k, v)| (k.clone(), v.to_string()))
+                    .collect(),
+            ),
+        );
+        result.metadata.additional.insert(
+            "quality_score".to_string(),
+            serde_json::Value::Number(
+                serde_json::Number::from_f64(quality_score).unwrap_or(serde_json::Number::from(0)),
+            ),
+        );
+    }
+
+    #[cfg(not(feature = "quality"))]
+    if config.enable_quality_processing {
+        result.metadata.additional.insert(
+            "quality_processing_error".to_string(),
+            serde_json::Value::String("Quality processing feature not enabled".to_string()),
+        );
+    }
+
     #[cfg(feature = "chunking")]
     if let Some(ref chunking_config) = config.chunking {
         let chunk_config = crate::chunking::ChunkingConfig {
@@ -194,9 +123,7 @@ pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfi
             chunker_type: crate::chunking::ChunkerType::Text,
         };
 
-        let page_boundaries = result.metadata.pages.as_ref().and_then(|ps| ps.boundaries.as_deref());
-
-        match crate::chunking::chunk_text(&result.content, &chunk_config, page_boundaries) {
+        match crate::chunking::chunk_text(&result.content, &chunk_config) {
             Ok(chunking_result) => {
                 result.chunks = Some(chunking_result.chunks);
 
@@ -284,11 +211,9 @@ pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfi
             registry.get_all()
         };
 
-        if !validators.is_empty() {
-            for validator in validators {
-                if validator.should_validate(&result, config) {
-                    validator.validate(&result, config).await?;
-                }
+        for validator in validators {
+            if validator.should_validate(&result, config) {
+                validator.validate(&result, config).await?;
             }
         }
     }
@@ -296,144 +221,19 @@ pub async fn run_pipeline(mut result: ExtractionResult, config: &ExtractionConfi
     Ok(result)
 }
 
-/// Run the post-processing pipeline synchronously (WASM-compatible version).
-///
-/// This is a synchronous implementation for WASM and non-async contexts.
-/// It performs a subset of the full async pipeline, excluding async post-processors
-/// and validators.
-///
-/// # Arguments
-///
-/// * `result` - The extraction result to process
-/// * `config` - Extraction configuration
-///
-/// # Returns
-///
-/// The processed extraction result.
-///
-/// # Notes
-///
-/// This function is only available when the `tokio-runtime` feature is disabled.
-/// It handles:
-/// - Quality processing (if enabled)
-/// - Chunking (if enabled)
-/// - Language detection (if enabled)
-///
-/// It does NOT handle:
-/// - Async post-processors
-/// - Async validators
-#[cfg(not(feature = "tokio-runtime"))]
-pub fn run_pipeline_sync(mut result: ExtractionResult, config: &ExtractionConfig) -> Result<ExtractionResult> {
-    #[cfg(feature = "chunking")]
-    if let Some(ref chunking_config) = config.chunking {
-        let chunk_config = crate::chunking::ChunkingConfig {
-            max_characters: chunking_config.max_chars,
-            overlap: chunking_config.max_overlap,
-            trim: true,
-            chunker_type: crate::chunking::ChunkerType::Text,
-        };
-
-        match crate::chunking::chunk_text(&result.content, &chunk_config, None) {
-            Ok(chunking_result) => {
-                result.chunks = Some(chunking_result.chunks);
-
-                if let Some(ref chunks) = result.chunks {
-                    result.metadata.additional.insert(
-                        "chunk_count".to_string(),
-                        serde_json::Value::Number(serde_json::Number::from(chunks.len())),
-                    );
-                }
-
-                #[cfg(feature = "embeddings")]
-                if let Some(ref embedding_config) = chunking_config.embedding
-                    && let Some(ref mut chunks) = result.chunks
-                {
-                    match crate::embeddings::generate_embeddings_for_chunks(chunks, embedding_config) {
-                        Ok(()) => {
-                            result
-                                .metadata
-                                .additional
-                                .insert("embeddings_generated".to_string(), serde_json::Value::Bool(true));
-                        }
-                        Err(e) => {
-                            result
-                                .metadata
-                                .additional
-                                .insert("embedding_error".to_string(), serde_json::Value::String(e.to_string()));
-                        }
-                    }
-                }
-
-                #[cfg(not(feature = "embeddings"))]
-                if chunking_config.embedding.is_some() {
-                    result.metadata.additional.insert(
-                        "embedding_error".to_string(),
-                        serde_json::Value::String("Embeddings feature not enabled".to_string()),
-                    );
-                }
-            }
-            Err(e) => {
-                result
-                    .metadata
-                    .additional
-                    .insert("chunking_error".to_string(), serde_json::Value::String(e.to_string()));
-            }
-        }
-    }
-
-    #[cfg(not(feature = "chunking"))]
-    if config.chunking.is_some() {
-        result.metadata.additional.insert(
-            "chunking_error".to_string(),
-            serde_json::Value::String("Chunking feature not enabled".to_string()),
-        );
-    }
-
-    #[cfg(feature = "language-detection")]
-    if let Some(ref lang_config) = config.language_detection {
-        match crate::language_detection::detect_languages(&result.content, lang_config) {
-            Ok(detected) => {
-                result.detected_languages = detected;
-            }
-            Err(e) => {
-                result.metadata.additional.insert(
-                    "language_detection_error".to_string(),
-                    serde_json::Value::String(e.to_string()),
-                );
-            }
-        }
-    }
-
-    #[cfg(not(feature = "language-detection"))]
-    if config.language_detection.is_some() {
-        result.metadata.additional.insert(
-            "language_detection_error".to_string(),
-            serde_json::Value::String("Language detection feature not enabled".to_string()),
-        );
-    }
-
-    Ok(result)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::types::Metadata;
     use lazy_static::lazy_static;
 
-    const VALIDATION_MARKER_KEY: &str = "registry_validation_marker";
-    #[cfg(feature = "quality")]
-    const QUALITY_VALIDATION_MARKER: &str = "quality_validation_test";
-    const POSTPROCESSOR_VALIDATION_MARKER: &str = "postprocessor_validation_test";
-    const ORDER_VALIDATION_MARKER: &str = "order_validation_test";
-
     lazy_static! {
         static ref REGISTRY_TEST_GUARD: std::sync::Mutex<()> = std::sync::Mutex::new(());
     }
 
     #[tokio::test]
     async fn test_run_pipeline_basic() {
-        let mut result = ExtractionResult {
+        let result = ExtractionResult {
             content: "test".to_string(),
             mime_type: "text/plain".to_string(),
             metadata: Metadata::default(),
@@ -441,12 +241,7 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
-        result.metadata.additional.insert(
-            VALIDATION_MARKER_KEY.to_string(),
-            serde_json::json!(ORDER_VALIDATION_MARKER),
-        );
         let config = ExtractionConfig::default();
 
         let processed = run_pipeline(result, &config).await.unwrap();
@@ -464,7 +259,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig {
             enable_quality_processing: true,
@@ -485,7 +279,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig {
             enable_quality_processing: false,
@@ -507,7 +300,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig {
             chunking: Some(crate::ChunkingConfig {
@@ -535,7 +327,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig {
             chunking: None,
@@ -560,7 +351,6 @@ mod tests {
                 additional,
                 ..Default::default()
             },
-            pages: None,
             tables: vec![],
             detected_languages: None,
             chunks: None,
@@ -597,7 +387,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig::default();
 
@@ -608,17 +397,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_pipeline_empty_content() {
-        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-
         {
-            let registry = crate::plugins::registry::get_post_processor_registry();
-            registry.write().unwrap().shutdown_all().unwrap();
-        }
-        {
-            let registry = crate::plugins::registry::get_validator_registry();
-            registry.write().unwrap().shutdown_all().unwrap();
-        }
-
+            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        } // Drop guard before async operations
         let result = ExtractionResult {
             content: String::new(),
             mime_type: "text/plain".to_string(),
@@ -627,12 +408,9 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig::default();
 
-        drop(_guard);
-
         let processed = run_pipeline(result, &config).await.unwrap();
         assert_eq!(processed.content, "");
     }
@@ -648,7 +426,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
         let config = ExtractionConfig {
             enable_quality_processing: true,
@@ -669,22 +446,6 @@ mod tests {
     #[tokio::test]
     #[cfg(any(feature = "keywords-yake", feature = "keywords-rake"))]
     async fn test_pipeline_with_keyword_extraction() {
-        {
-            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-            crate::plugins::registry::get_validator_registry()
-                .write()
-                .unwrap()
-                .shutdown_all()
-                .unwrap();
-            crate::plugins::registry::get_post_processor_registry()
-                .write()
-                .unwrap()
-                .shutdown_all()
-                .unwrap();
-
-            let _ = crate::keywords::register_keyword_processor();
-        }
-
         let result = ExtractionResult {
             content: r#"
 Machine learning is a branch of artificial intelligence that focuses on
@@ -699,7 +460,6 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         #[cfg(feature = "keywords-yake")]
@@ -733,9 +493,6 @@ Natural language processing enables computers to understand human language.
     #[tokio::test]
     #[cfg(any(feature = "keywords-yake", feature = "keywords-rake"))]
     async fn test_pipeline_without_keyword_config() {
-        {
-            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-        }
         let result = ExtractionResult {
             content: "Machine learning and artificial intelligence.".to_string(),
             mime_type: "text/plain".to_string(),
@@ -744,7 +501,6 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let config = ExtractionConfig {
@@ -760,18 +516,6 @@ Natural language processing enables computers to understand human language.
     #[tokio::test]
     #[cfg(any(feature = "keywords-yake", feature = "keywords-rake"))]
     async fn test_pipeline_keyword_extraction_short_content() {
-        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-        crate::plugins::registry::get_validator_registry()
-            .write()
-            .unwrap()
-            .shutdown_all()
-            .unwrap();
-        crate::plugins::registry::get_post_processor_registry()
-            .write()
-            .unwrap()
-            .shutdown_all()
-            .unwrap();
-
         let result = ExtractionResult {
             content: "Short text".to_string(),
             mime_type: "text/plain".to_string(),
@@ -780,7 +524,6 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         #[cfg(feature = "keywords-yake")]
@@ -794,8 +537,6 @@ Natural language processing enables computers to understand human language.
             ..Default::default()
         };
 
-        drop(_guard);
-
         let processed = run_pipeline(result, &config).await.unwrap();
 
         assert!(!processed.metadata.additional.contains_key("keywords"));
@@ -803,6 +544,9 @@ Natural language processing enables computers to understand human language.
 
     #[tokio::test]
     async fn test_postprocessor_runs_before_validator() {
+        {
+            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        } // Drop guard before async operations
         use crate::plugins::{Plugin, PostProcessor, ProcessingStage, Validator};
         use async_trait::async_trait;
         use std::sync::Arc;
@@ -857,17 +601,6 @@ Natural language processing enables computers to understand human language.
         #[async_trait]
         impl Validator for TestValidator {
             async fn validate(&self, result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
-                let should_validate = result
-                    .metadata
-                    .additional
-                    .get(VALIDATION_MARKER_KEY)
-                    .and_then(|v| v.as_str())
-                    == Some(POSTPROCESSOR_VALIDATION_MARKER);
-
-                if !should_validate {
-                    return Ok(());
-                }
-
                 let processed = result
                     .metadata
                     .additional
@@ -886,28 +619,18 @@ Natural language processing enables computers to understand human language.
         }
 
         let pp_registry = crate::plugins::registry::get_post_processor_registry();
-        let val_registry = crate::plugins::registry::get_validator_registry();
-
-        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-        clear_processor_cache().unwrap();
-        pp_registry.write().unwrap().shutdown_all().unwrap();
-        val_registry.write().unwrap().shutdown_all().unwrap();
-        clear_processor_cache().unwrap();
-
         {
             let mut registry = pp_registry.write().unwrap();
             registry.register(Arc::new(TestPostProcessor), 0).unwrap();
         }
 
+        let val_registry = crate::plugins::registry::get_validator_registry();
         {
             let mut registry = val_registry.write().unwrap();
             registry.register(Arc::new(TestValidator)).unwrap();
         }
 
-        // Clear the cache after registering new processors so it rebuilds with the test processors
-        clear_processor_cache().unwrap();
-
-        let mut result = ExtractionResult {
+        let result = ExtractionResult {
             content: "test".to_string(),
             mime_type: "text/plain".to_string(),
             metadata: Metadata::default(),
@@ -915,29 +638,19 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
-        };
-        result.metadata.additional.insert(
-            VALIDATION_MARKER_KEY.to_string(),
-            serde_json::json!(POSTPROCESSOR_VALIDATION_MARKER),
-        );
-
-        let config = ExtractionConfig {
-            postprocessor: Some(crate::core::config::PostProcessorConfig {
-                enabled: true,
-                enabled_set: None,
-                disabled_set: None,
-                enabled_processors: None,
-                disabled_processors: None,
-            }),
-            ..Default::default()
         };
-        drop(_guard);
 
+        let config = ExtractionConfig::default();
         let processed = run_pipeline(result, &config).await;
 
-        pp_registry.write().unwrap().shutdown_all().unwrap();
-        val_registry.write().unwrap().shutdown_all().unwrap();
+        {
+            let mut registry = pp_registry.write().unwrap();
+            registry.remove("test-processor").unwrap();
+        }
+        {
+            let mut registry = val_registry.write().unwrap();
+            registry.remove("test-validator").unwrap();
+        }
 
         assert!(processed.is_ok(), "Validator should have seen post-processor metadata");
         let processed = processed.unwrap();
@@ -951,7 +664,9 @@ Natural language processing enables computers to understand human language.
     #[tokio::test]
     #[cfg(feature = "quality")]
     async fn test_quality_processing_runs_before_validator() {
-        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        {
+            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        } // Drop guard before async operations
         use crate::plugins::{Plugin, Validator};
         use async_trait::async_trait;
         use std::sync::Arc;
@@ -975,17 +690,6 @@ Natural language processing enables computers to understand human language.
         #[async_trait]
         impl Validator for QualityValidator {
             async fn validate(&self, result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
-                let should_validate = result
-                    .metadata
-                    .additional
-                    .get(VALIDATION_MARKER_KEY)
-                    .and_then(|v| v.as_str())
-                    == Some(QUALITY_VALIDATION_MARKER);
-
-                if !should_validate {
-                    return Ok(());
-                }
-
                 if !result.metadata.additional.contains_key("quality_score") {
                     return Err(crate::KreuzbergError::Validation {
                         message: "Quality processing did not run before validator".to_string(),
@@ -1002,7 +706,7 @@ Natural language processing enables computers to understand human language.
             registry.register(Arc::new(QualityValidator)).unwrap();
         }
 
-        let mut result = ExtractionResult {
+        let result = ExtractionResult {
             content: "This is meaningful test content for quality scoring.".to_string(),
             mime_type: "text/plain".to_string(),
             metadata: Metadata::default(),
@@ -1010,20 +714,13 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
-        result.metadata.additional.insert(
-            VALIDATION_MARKER_KEY.to_string(),
-            serde_json::json!(QUALITY_VALIDATION_MARKER),
-        );
 
         let config = ExtractionConfig {
             enable_quality_processing: true,
             ..Default::default()
         };
 
-        drop(_guard);
-
         let processed = run_pipeline(result, &config).await;
 
         {
@@ -1036,6 +733,9 @@ Natural language processing enables computers to understand human language.
 
     #[tokio::test]
     async fn test_multiple_postprocessors_run_before_validator() {
+        {
+            let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
+        } // Drop guard before async operations
         use crate::plugins::{Plugin, PostProcessor, ProcessingStage, Validator};
         use async_trait::async_trait;
         use std::sync::Arc;
@@ -1137,17 +837,6 @@ Natural language processing enables computers to understand human language.
         #[async_trait]
         impl Validator for OrderValidator {
             async fn validate(&self, result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
-                let should_validate = result
-                    .metadata
-                    .additional
-                    .get(VALIDATION_MARKER_KEY)
-                    .and_then(|v| v.as_str())
-                    == Some(ORDER_VALIDATION_MARKER);
-
-                if !should_validate {
-                    return Ok(());
-                }
-
                 let order = result
                     .metadata
                     .additional
@@ -1177,27 +866,18 @@ Natural language processing enables computers to understand human language.
         }
 
         let pp_registry = crate::plugins::registry::get_post_processor_registry();
-        let val_registry = crate::plugins::registry::get_validator_registry();
-        let _guard = REGISTRY_TEST_GUARD.lock().unwrap();
-
-        pp_registry.write().unwrap().shutdown_all().unwrap();
-        val_registry.write().unwrap().shutdown_all().unwrap();
-        clear_processor_cache().unwrap();
-
         {
             let mut registry = pp_registry.write().unwrap();
             registry.register(Arc::new(EarlyProcessor), 0).unwrap();
             registry.register(Arc::new(LateProcessor), 0).unwrap();
         }
 
+        let val_registry = crate::plugins::registry::get_validator_registry();
         {
             let mut registry = val_registry.write().unwrap();
             registry.register(Arc::new(OrderValidator)).unwrap();
         }
 
-        // Clear the cache after registering new processors so it rebuilds with the test processors
-        clear_processor_cache().unwrap();
-
         let result = ExtractionResult {
             content: "test".to_string(),
             mime_type: "text/plain".to_string(),
@@ -1206,17 +886,20 @@ Natural language processing enables computers to understand human language.
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let config = ExtractionConfig::default();
-        drop(_guard);
-
         let processed = run_pipeline(result, &config).await;
 
-        pp_registry.write().unwrap().shutdown_all().unwrap();
-        val_registry.write().unwrap().shutdown_all().unwrap();
-        clear_processor_cache().unwrap();
+        {
+            let mut registry = pp_registry.write().unwrap();
+            registry.remove("early-proc").unwrap();
+            registry.remove("late-proc").unwrap();
+        }
+        {
+            let mut registry = val_registry.write().unwrap();
+            registry.remove("order-validator").unwrap();
+        }
 
         assert!(processed.is_ok(), "All processors should run before validator");
     }