kreuzberg 4.0.0.pre.rc.8 → 4.0.0.pre.rc.11

data/vendor/kreuzberg/build.rs

@@ -1,3 +1,29 @@
+// Kreuzberg Build Script - PDFium Linking Configuration
+//
+// This build script handles PDFium library downloading and linking for the kreuzberg crate.
+// It supports multiple linking strategies via Cargo features:
+//
+// 1. Default (pdf, bundled-pdfium): Download dynamic library and embed in binary
+//    - Self-contained binary that extracts library at runtime
+//    - Larger binary size but no external .so dependency
+//    - No PDFIUM_*_PATH environment variables needed
+//
+// 2. static-pdfium: Static linking (no runtime dependency)
+//    - REQUIRES: PDFIUM_STATIC_LIB_PATH environment variable pointing to libpdfium.a directory
+//    - Reason: bblanchon/pdfium-binaries only provides dynamic libraries
+//    - Use case: Docker with musl, fully static binaries
+//    - Note: libpdfium.a must be obtained separately (e.g., paulocoutinhox/pdfium-lib)
+//
+// 3. system-pdfium: Use system-installed pdfium
+//    - Detected via pkg-config or KREUZBERG_PDFIUM_SYSTEM_PATH
+//
+// Environment Variables:
+// - PDFIUM_STATIC_LIB_PATH: Path to directory containing libpdfium.a (for static-pdfium)
+// - KREUZBERG_PDFIUM_PREBUILT: Path to prebuilt pdfium directory (skip download)
+// - KREUZBERG_PDFIUM_SYSTEM_PATH: System pdfium library path (for system-pdfium)
+// - PDFIUM_VERSION: Override version for bblanchon/pdfium-binaries
+// - KREUZBERG_PDFIUM_DOWNLOAD_RETRIES: Number of download retries (default: 5)
+
 use std::env;
 use std::fs;
 use std::io;
@@ -9,13 +35,11 @@ use std::time::Duration;
 /// PDFium linking strategy
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum PdfiumLinkStrategy {
-    /// Download and link dynamically (default behavior)
-    DownloadDynamic,
-    /// Download and link statically (pdf-static feature)
+    /// Download and link statically (static-pdfium feature)
     DownloadStatic,
-    /// Download, link dynamically, and embed in binary (pdf-bundled feature)
+    /// Download, link dynamically, and embed in binary (bundled-pdfium feature)
     Bundled,
-    /// Use system-installed pdfium via pkg-config (pdf-system feature)
+    /// Use system-installed pdfium via pkg-config (system-pdfium feature)
     System,
 }
 
@@ -35,17 +59,11 @@ fn main() {
         return;
     }
 
-    validate_feature_exclusivity();
     let strategy = determine_link_strategy(&target);
 
     tracing::debug!("Using PDFium linking strategy: {:?}", strategy);
 
     match strategy {
-        PdfiumLinkStrategy::DownloadDynamic => {
-            let pdfium_dir = download_or_use_prebuilt(&target, &out_dir);
-            link_dynamically(&pdfium_dir, &target);
-            copy_lib_to_package(&pdfium_dir, &target);
-        }
         PdfiumLinkStrategy::DownloadStatic => {
             let pdfium_dir = download_or_use_prebuilt(&target, &out_dir);
             link_statically(&pdfium_dir, &target);
@@ -70,43 +88,49 @@ fn main() {
 // FEATURE & STRATEGY VALIDATION
 // ============================================================================
 
-/// Validate that only one linking strategy feature is enabled at a time
-fn validate_feature_exclusivity() {
-    let strategies = [
-        cfg!(feature = "pdf-static"),
-        cfg!(feature = "pdf-bundled"),
-        cfg!(feature = "pdf-system"),
-    ];
-    let count = strategies.iter().filter(|&&x| x).count();
-
-    if count > 1 {
-        panic!(
-            "Only one of pdf-static, pdf-bundled, pdf-system can be enabled at once.\n\
-             Please choose a single PDFium linking strategy."
-        );
-    }
-}
-
 /// Determine which linking strategy to use based on features and target
 fn determine_link_strategy(target: &str) -> PdfiumLinkStrategy {
-    // WASM always uses static linking
+    // WASM handling: check for PDFIUM_WASM_LIB environment variable
     if target.contains("wasm") {
-        return PdfiumLinkStrategy::DownloadStatic;
+        if let Ok(wasm_lib) = env::var("PDFIUM_WASM_LIB") {
+            println!("cargo:rustc-link-search=native={}", wasm_lib);
+            println!("cargo:rustc-link-lib=static=pdfium");
+            return PdfiumLinkStrategy::DownloadStatic;
+        }
+        // For WASM without explicit PDFIUM_WASM_LIB, use bundled strategy
+        // This downloads pdfium-lib which provides WASM-compatible builds
+        println!("cargo:warning=WASM build using bundled PDFium (set PDFIUM_WASM_LIB to link custom WASM PDFium)");
+        return PdfiumLinkStrategy::Bundled;
     }
 
-    // Feature-based strategy selection (priority order)
-    if cfg!(feature = "pdf-system") {
-        return PdfiumLinkStrategy::System;
+    let system_pdfium = cfg!(feature = "system-pdfium");
+    let bundled_pdfium = cfg!(feature = "bundled-pdfium");
+    let static_pdfium = cfg!(feature = "static-pdfium");
+
+    let enabled_count = usize::from(system_pdfium) + usize::from(bundled_pdfium) + usize::from(static_pdfium);
+    if enabled_count > 1 {
+        println!(
+            "cargo:warning=Multiple PDFium linking strategies enabled (static-pdfium={}, bundled-pdfium={}, system-pdfium={}); using bundled-pdfium for this build",
+            static_pdfium, bundled_pdfium, system_pdfium
+        );
     }
-    if cfg!(feature = "pdf-bundled") {
+
+    // Feature-based strategy selection.
+    // Prefer bundled-pdfium when multiple strategies are enabled (e.g. `--all-features`) because it
+    // does not require external PDFIUM_STATIC_LIB_PATH and does not depend on a system install.
+    if bundled_pdfium {
         return PdfiumLinkStrategy::Bundled;
     }
-    if cfg!(feature = "pdf-static") {
+    if system_pdfium {
+        return PdfiumLinkStrategy::System;
+    }
+    if static_pdfium {
         return PdfiumLinkStrategy::DownloadStatic;
     }
 
-    // Default: download and link dynamically
-    PdfiumLinkStrategy::DownloadDynamic
+    // Default: download and link dynamically (bundled-pdfium preferred if pdf not already selected)
+    // When only 'pdf' feature is enabled (no linking strategy), default to bundled-pdfium
+    PdfiumLinkStrategy::Bundled
 }
 
 // ============================================================================
@@ -136,6 +160,9 @@ fn download_or_use_prebuilt(target: &str, out_dir: &Path) -> PathBuf {
         if prebuilt_path.exists() {
             prepare_prebuilt_pdfium(&prebuilt_path, &pdfium_dir)
                 .unwrap_or_else(|err| panic!("Failed to copy Pdfium from {}: {}", prebuilt_path.display(), err));
+            if target.contains("windows") {
+                ensure_windows_import_library(&pdfium_dir);
+            }
             return pdfium_dir;
         } else {
             panic!(
@@ -166,19 +193,34 @@ fn download_or_use_prebuilt(target: &str, out_dir: &Path) -> PathBuf {
 
     // Windows-specific: ensure pdfium.lib exists
     if target.contains("windows") {
-        let lib_dir = pdfium_dir.join("lib");
-        let dll_lib = lib_dir.join("pdfium.dll.lib");
-        let expected_lib = lib_dir.join("pdfium.lib");
-
-        if dll_lib.exists() && !expected_lib.exists() {
-            tracing::debug!("Renaming cached {} to {}", dll_lib.display(), expected_lib.display());
-            fs::rename(&dll_lib, &expected_lib).expect("Failed to rename pdfium.dll.lib to pdfium.lib");
-        }
+        ensure_windows_import_library(&pdfium_dir);
     }
 
     pdfium_dir
 }
 
+fn ensure_windows_import_library(pdfium_dir: &Path) {
+    let lib_dir = pdfium_dir.join("lib");
+    let dll_lib = lib_dir.join("pdfium.dll.lib");
+    let expected_lib = lib_dir.join("pdfium.lib");
+
+    if dll_lib.exists() && !expected_lib.exists() {
+        tracing::debug!(
+            "Ensuring Windows import library at {} (source: {})",
+            expected_lib.display(),
+            dll_lib.display()
+        );
+        fs::copy(&dll_lib, &expected_lib).unwrap_or_else(|err| {
+            panic!(
+                "Failed to copy Windows import library from {} to {}: {}",
+                dll_lib.display(),
+                expected_lib.display(),
+                err
+            )
+        });
+    }
+}
+
 // ============================================================================
 // DOWNLOAD UTILITIES
 // ============================================================================
@@ -436,13 +478,14 @@ fn copy_dir_all(src: &Path, dst: &Path) -> io::Result<()> {
 /// Get platform-specific runtime library name and subdirectory
 ///
 /// Returns tuple of (library_name, subdirectory) for the target platform:
-/// - WASM: ("libpdfium.a", "lib")
+/// - WASM: ("libpdfium.a", "release/lib")
 /// - Windows: ("pdfium.dll", "bin")
 /// - macOS: ("libpdfium.dylib", "lib")
 /// - Linux: ("libpdfium.so", "lib")
 fn runtime_library_info(target: &str) -> (String, &'static str) {
     if target.contains("wasm") {
-        ("libpdfium.a".to_string(), "lib")
+        // pdfium-lib `wasm.tgz` extracts into `release/lib/libpdfium.a`
+        ("libpdfium.a".to_string(), "release/lib")
     } else if target.contains("windows") {
         ("pdfium.dll".to_string(), "bin")
     } else if target.contains("darwin") {
@@ -516,69 +559,6 @@ fn find_pdfium_library(pdfium_dir: &Path, lib_name: &str, expected_subdir: &str)
     Err(error_msg)
 }
 
-/// Fix macOS install name (rpath) for dynamic library
-///
-/// Uses install_name_tool to set the install name to @rpath/{lib_name}
-/// to enable relative path loading on macOS.
-fn fix_macos_install_name(lib_path: &Path, lib_name: &str) {
-    let new_install_name = format!("@rpath/{}", lib_name);
-
-    tracing::debug!("Fixing install_name for {} to {}", lib_path.display(), new_install_name);
-
-    let status = Command::new("install_name_tool")
-        .arg("-id")
-        .arg(&new_install_name)
-        .arg(lib_path)
-        .status();
-
-    match status {
-        Ok(s) if s.success() => {
-            tracing::debug!("Successfully updated install_name");
-        }
-        Ok(s) => {
-            tracing::debug!("install_name_tool failed with status: {}", s);
-        }
-        Err(e) => {
-            tracing::debug!("Failed to run install_name_tool: {}", e);
-        }
-    }
-}
-
-/// Code sign binary on macOS if needed
-///
-/// Uses codesign to sign the binary. Identity from KREUZBERG_CODESIGN_IDENTITY
-/// env var (default: "-" for adhoc signing). Only runs on apple-darwin targets.
-fn codesign_if_needed(target: &str, binary: &Path) {
-    if !target.contains("apple-darwin") || !binary.exists() {
-        return;
-    }
-
-    let identity = env::var("KREUZBERG_CODESIGN_IDENTITY").unwrap_or_else(|_| "-".to_string());
-    let status = Command::new("codesign")
-        .arg("--force")
-        .arg("--timestamp=none")
-        .arg("--sign")
-        .arg(identity)
-        .arg(binary)
-        .status();
-
-    match status {
-        Ok(result) if result.success() => {
-            tracing::debug!("Codesigned {}", binary.display());
-        }
-        Ok(result) => {
-            tracing::debug!(
-                "codesign exited with status {} while signing {}",
-                result,
-                binary.display()
-            );
-        }
-        Err(err) => {
-            tracing::debug!("Failed to run codesign for {}: {}", binary.display(), err);
-        }
-    }
-}
-
 // ============================================================================
 // LINKING STRATEGIES
 // ============================================================================
@@ -622,18 +602,100 @@ fn link_dynamically(pdfium_dir: &Path, target: &str) {
     }
 }
 
-/// Link PDFium statically (pdf-static feature)
+/// Link PDFium statically (static-pdfium feature)
 ///
 /// Embeds PDFium into the binary as a static library. Adds system
 /// dependencies required for static linking on Linux.
 /// Supports flexible archive structures by finding library in multiple locations.
+///
+/// Environment Variables:
+/// - `PDFIUM_STATIC_LIB_PATH`: Path to directory containing libpdfium.a (for Docker/musl builds)
+///
+/// Note: bblanchon/pdfium-binaries only provides dynamic libraries.
+/// On macOS, this will fallback to dynamic linking with a warning.
+/// On Linux, you must provide PDFIUM_STATIC_LIB_PATH pointing to a static build.
 fn link_statically(pdfium_dir: &Path, target: &str) {
-    let (runtime_lib_name, runtime_subdir) = runtime_library_info(target);
+    // For static linking, we need libpdfium.a (not .dylib or .so)
+    let static_lib_name = "libpdfium.a";
+    let lib_subdir = if target.contains("wasm") { "release/lib" } else { "lib" };
+
+    // First, check if user provided a static library path via environment variable
+    if let Ok(custom_path) = env::var("PDFIUM_STATIC_LIB_PATH") {
+        let custom_lib_dir = PathBuf::from(&custom_path);
+
+        if !custom_lib_dir.exists() {
+            panic!(
+                "PDFIUM_STATIC_LIB_PATH points to '{}' but the directory does not exist",
+                custom_path
+            );
+        }
+
+        let custom_lib = custom_lib_dir.join(static_lib_name);
+        if !custom_lib.exists() {
+            panic!(
+                "PDFIUM_STATIC_LIB_PATH points to '{}' but {} not found.\n\
+                 Expected to find: {}",
+                custom_path,
+                static_lib_name,
+                custom_lib.display()
+            );
+        }
+
+        tracing::debug!("Using custom static PDFium from: {}", custom_lib.display());
+        println!("cargo:rustc-link-search=native={}", custom_lib_dir.display());
+        println!("cargo:rustc-link-lib=static=pdfium");
+
+        // Static linking requires additional system dependencies
+        if target.contains("linux") {
+            println!("cargo:rustc-link-lib=dylib=pthread");
+            println!("cargo:rustc-link-lib=dylib=dl");
+        } else if target.contains("windows") {
+            println!("cargo:rustc-link-lib=dylib=ws2_32");
+            println!("cargo:rustc-link-lib=dylib=userenv");
+        }
+
+        return;
+    }
 
     // Find the actual library location (handles multiple possible archive structures)
-    let lib_path = match find_pdfium_library(pdfium_dir, &runtime_lib_name, runtime_subdir) {
+    let lib_path = match find_pdfium_library(pdfium_dir, static_lib_name, lib_subdir) {
         Ok(path) => path.parent().unwrap_or(pdfium_dir).to_path_buf(),
-        Err(err) => panic!("{}", err),
+        Err(_err) => {
+            // Static library not found - check if we're on macOS and can fallback
+            if target.contains("darwin") {
+                eprintln!("cargo:warning=Static PDFium library (libpdfium.a) not found for macOS.");
+                eprintln!("cargo:warning=bblanchon/pdfium-binaries only provides dynamic libraries.");
+                eprintln!("cargo:warning=Falling back to dynamic linking for local development.");
+                eprintln!("cargo:warning=Production Linux builds require PDFIUM_STATIC_LIB_PATH.");
+
+                // Fallback to dynamic linking on macOS
+                link_dynamically(pdfium_dir, target);
+                return;
+            } else {
+                // On Linux/Windows, provide helpful error with actionable steps
+                panic!(
+                    "Static PDFium library (libpdfium.a) not found.\n\n\
+                     bblanchon/pdfium-binaries only provides dynamic libraries.\n\n\
+                     For static linking (required for Docker with musl), you must:\n\n\
+                     1. Build static PDFium or obtain from a source that provides it\n\
+                        - See: https://github.com/ajrcarey/pdfium-render/issues/53\n\
+                        - Or use: https://github.com/paulocoutinhox/pdfium-lib (provides static builds)\n\n\
+                     2. Set environment variable pointing to the directory containing libpdfium.a:\n\
+                        export PDFIUM_STATIC_LIB_PATH=/path/to/pdfium/lib\n\n\
+                     3. Or use alternative features:\n\
+                        - 'pdf' (dynamic linking, requires .so at runtime)\n\
+                        - 'bundled-pdfium' (embeds dynamic library in binary)\n\
+                        - 'system-pdfium' (use system-installed pdfium)\n\n\
+                     Example Dockerfile pattern:\n\
+                        FROM alpine:latest as pdfium-builder\n\
+                        # Download/build static libpdfium.a\n\
+                        \n\
+                        FROM rust:alpine as builder\n\
+                        ENV PDFIUM_STATIC_LIB_PATH=/pdfium/lib\n\
+                        COPY --from=pdfium-builder /path/to/libpdfium.a /pdfium/lib/"
+                );
+            }
+        }
     };
 
     println!("cargo:rustc-link-search=native={}", lib_path.display());
@@ -653,21 +715,22 @@ fn link_statically(pdfium_dir: &Path, target: &str) {
 
     // Static linking requires additional system dependencies
     if target.contains("linux") {
-        // Linux requires additional libraries for static linking
         println!("cargo:rustc-link-lib=dylib=pthread");
         println!("cargo:rustc-link-lib=dylib=dl");
+    } else if target.contains("windows") {
+        println!("cargo:rustc-link-lib=dylib=ws2_32");
+        println!("cargo:rustc-link-lib=dylib=userenv");
     }
 }
 
-/// Link PDFium bundled (pdf-bundled feature)
+/// Link PDFium bundled (bundled-pdfium feature)
 ///
 /// Links dynamically but copies library to OUT_DIR for embedding in binary.
 /// Each binary extracts and uses its own copy of the PDFium library.
 /// Supports flexible archive structures by finding library in multiple locations.
+///
+/// For WASM targets, links statically using the bundled static library.
 fn link_bundled(pdfium_dir: &Path, target: &str, out_dir: &Path) {
-    // Link dynamically for build
-    link_dynamically(pdfium_dir, target);
-
     // Copy library to OUT_DIR for bundling using flexible detection
     let (runtime_lib_name, runtime_subdir) = runtime_library_info(target);
     let src_lib = match find_pdfium_library(pdfium_dir, &runtime_lib_name, runtime_subdir) {
@@ -685,10 +748,20 @@ fn link_bundled(pdfium_dir: &Path, target: &str, out_dir: &Path) {
         .unwrap_or_else(|| panic!("Non-UTF8 path for bundled library: {}", bundled_lib.display()));
     println!("cargo:rustc-env=KREUZBERG_PDFIUM_BUNDLED_PATH={}", bundled_path);
 
-    tracing::debug!("Bundled PDFium library at: {}", bundled_path);
+    // For WASM, link statically using the bundled library
+    if target.contains("wasm") {
+        let lib_dir = bundled_lib
+            .parent()
+            .unwrap_or_else(|| panic!("Invalid bundled library path: {}", bundled_lib.display()));
+        println!("cargo:rustc-link-search=native={}", lib_dir.display());
+        println!("cargo:rustc-link-lib=static=pdfium");
+        tracing::debug!("Bundled PDFium static library linked for WASM at: {}", bundled_path);
+    } else {
+        tracing::debug!("Bundled PDFium library at: {}", bundled_path);
+    }
 }
 
-/// Link system-installed PDFium (pdf-system feature)
+/// Link system-installed PDFium (system-pdfium feature)
 ///
 /// Attempts to find PDFium via pkg-config first, then falls back to
 /// environment variables (KREUZBERG_PDFIUM_SYSTEM_PATH, KREUZBERG_PDFIUM_SYSTEM_INCLUDE).
@@ -733,7 +806,7 @@ fn link_system(_target: &str) {
 
     // No system pdfium found
     panic!(
-        "pdf-system feature enabled but pdfium not found.\n\
+        "system-pdfium feature enabled but pdfium not found.\n\
          \n\
          Please install pdfium system-wide or provide:\n\
          - KREUZBERG_PDFIUM_SYSTEM_PATH: path to directory containing libpdfium\n\
@@ -741,8 +814,8 @@ fn link_system(_target: &str) {
          \n\
          Alternatively, use a different linking strategy:\n\
          - Default (dynamic): cargo build --features pdf\n\
-         - Static linking: cargo build --features pdf,pdf-static\n\
-         - Bundled: cargo build --features pdf,pdf-bundled"
+         - Static linking: cargo build --features pdf,static-pdfium\n\
+         - Bundled: cargo build --features pdf,bundled-pdfium"
     );
 }
 
@@ -768,124 +841,3 @@ fn link_system_frameworks(target: &str) {
         println!("cargo:rustc-link-lib=dylib=advapi32");
     }
 }
-
-// ============================================================================
-// LIBRARY DISTRIBUTION
-// ============================================================================
-
-/// Copy PDFium library to various package directories
-///
-/// Distributes the compiled/downloaded PDFium library to:
-/// - CLI target directories (debug/release)
-/// - Python package directory
-/// - Node.js package directory
-/// - Ruby gem directory
-///
-/// On macOS, also fixes install_name and applies code signing.
-/// Supports flexible archive structures by finding library in multiple locations.
-fn copy_lib_to_package(pdfium_dir: &Path, target: &str) {
-    let (runtime_lib_name, runtime_subdir) = runtime_library_info(target);
-    let src_lib = match find_pdfium_library(pdfium_dir, &runtime_lib_name, runtime_subdir) {
-        Ok(path) => path,
-        Err(err) => {
-            tracing::debug!("Failed to locate PDFium library: {}", err);
-            return;
-        }
-    };
-
-    if target.contains("darwin") {
-        fix_macos_install_name(&src_lib, &runtime_lib_name);
-        codesign_if_needed(target, &src_lib);
-    }
-
-    let crate_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
-    let workspace_root = crate_dir.parent().unwrap().parent().unwrap();
-
-    if let Ok(profile) = env::var("PROFILE") {
-        let target_dir = if let Ok(cargo_target) = env::var("TARGET") {
-            workspace_root.join("target").join(cargo_target).join(&profile)
-        } else {
-            workspace_root.join("target").join(&profile)
-        };
-
-        if target_dir.exists() {
-            copy_lib_if_needed(
-                &src_lib,
-                &target_dir.join(&runtime_lib_name),
-                "CLI target directory",
-                target,
-            );
-        }
-
-        let simple_target_dir = workspace_root.join("target").join(&profile);
-        if simple_target_dir != target_dir {
-            fs::create_dir_all(&simple_target_dir).ok();
-            copy_lib_if_needed(
-                &src_lib,
-                &simple_target_dir.join(&runtime_lib_name),
-                "Java FFI target directory",
-                target,
-            );
-        }
-    }
-
-    let python_dest_dir = workspace_root.join("packages").join("python").join("kreuzberg");
-    if python_dest_dir.exists() {
-        copy_lib_if_needed(
-            &src_lib,
-            &python_dest_dir.join(&runtime_lib_name),
-            "Python package",
-            target,
-        );
-    } else {
-        tracing::debug!("Python package directory not found, skipping Python library copy");
-    }
-
-    let node_dest_dir = workspace_root.join("crates").join("kreuzberg-node");
-    if node_dest_dir.exists() {
-        copy_lib_if_needed(
-            &src_lib,
-            &node_dest_dir.join(&runtime_lib_name),
-            "Node.js package",
-            target,
-        );
-    } else {
-        tracing::debug!("Node.js package directory not found, skipping Node library copy");
-    }
-
-    let ruby_dest_dir = workspace_root.join("packages").join("ruby").join("lib");
-    if ruby_dest_dir.exists() {
-        copy_lib_if_needed(&src_lib, &ruby_dest_dir.join(&runtime_lib_name), "Ruby package", target);
-    } else {
-        tracing::debug!("Ruby package directory not found, skipping Ruby library copy");
-    }
-}
-
-/// Copy library to destination if needed (based on modification time)
-///
-/// Only copies if destination doesn't exist or source is newer than destination.
-/// Applies platform-specific post-processing (code signing on macOS).
-fn copy_lib_if_needed(src: &Path, dest: &Path, package_name: &str, target: &str) {
-    use std::fs;
-
-    let should_copy = if dest.exists() {
-        let src_metadata = fs::metadata(src).ok();
-        let dest_metadata = fs::metadata(dest).ok();
-        match (src_metadata, dest_metadata) {
-            (Some(src), Some(dest)) => src.modified().ok() > dest.modified().ok(),
-            _ => true,
-        }
-    } else {
-        true
-    };
-
-    if should_copy {
-        match fs::copy(src, dest) {
-            Ok(_) => {
-                tracing::debug!("Copied {} to {} ({})", src.display(), dest.display(), package_name);
-                codesign_if_needed(target, dest);
-            }
-            Err(e) => tracing::debug!("Failed to copy library to {}: {}", package_name, e),
-        }
-    }
-}

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

@@ -653,6 +653,18 @@ 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 {
@@ -703,6 +715,7 @@ 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(),