kreuzberg 4.9.2 → 4.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 431f2a7c19d9a4404369b7c9fe80fd10233b34b3462cf3c0076aac9b7f3065cb
-  data.tar.gz: bf36fd9dd46ffb84374e8f64ffb1f61ac6774cc8dd56d43d404e0b8995813ffc
+  metadata.gz: 9f3132b44aad1652c76e8b1445b775eb3586e48661908eda794c95339f06387d
+  data.tar.gz: 2f957af07040ec2f3bcd79c299dd429a752423d714eea73bfb608a28718a6c11
 SHA512:
-  metadata.gz: 2cf3ad1e3edd0778537e542bcafc121b6cd14235e271d2b9b27747f7beab7a2899362426f450a06f9ff0d0d4365982acb68300e46568887a871ad1bda6767d00
-  data.tar.gz: e7bcbe73f50701fbd4a0cb7e75e588096c02202198b234ba6f830b846f4fabd95e051ed0c25ed4a1c1d72a933cf5ccf9d755129eb1dc54ea446a60d9d9946997
+  metadata.gz: 878748ecb791e049c2de05cdc4ec7b9f6749bb265981c98ea49126108ca7c2782b92a6b5ed31d1fbfbeee83e3c45c80aaf74aacecd20f9bc428d796709afa0aa
+  data.tar.gz: ff137eb78f8fcfcc2ac357b0d9adf6d3d6fee11a448679a976678e0745905a0abcd8abfeb331028d780810d96dc47a04ec01dda94c900ec63ad4b35c124c187f

data/README.md

@@ -22,7 +22,7 @@
     <img src="https://img.shields.io/maven-central/v/dev.kreuzberg/kreuzberg?label=Java&color=007ec6" alt="Java">
   </a>
   <a href="https://github.com/kreuzberg-dev/kreuzberg/releases">
-    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.9.2" alt="Go">
+    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.9.6" alt="Go">
   </a>
   <a href="https://www.nuget.org/packages/Kreuzberg/">
     <img src="https://img.shields.io/nuget/v/Kreuzberg?label=C%23&color=007ec6" alt="C#">

data/ext/kreuzberg_rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg-rb"
-version = "4.9.2"
+version = "4.9.6"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
@@ -65,7 +65,7 @@ tokio = { version = "1.52.1", features = [
     "time",
     "io-util",
 ] }
-html-to-markdown-rs = { version = "3.2.5", default-features = false }
+html-to-markdown-rs = { version = "3.3.1", default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

data/ext/kreuzberg_rb/native/src/config/types.rs

@@ -54,6 +54,7 @@ pub fn parse_ocr_config(ruby: &Ruby, hash: RHash) -> Result<OcrConfig, Error> {
         quality_thresholds: None,
         vlm_config: None,
         vlm_prompt: None,
+        acceleration: None,
     };
 
     if let Some(val) = get_kw(ruby, hash, "tesseract_config")
@@ -404,6 +405,12 @@ pub fn parse_image_extraction_config(ruby: &Ruby, hash: RHash) -> Result<ImageEx
         true
     };
 
+    let max_images_per_page = if let Some(val) = get_kw(ruby, hash, "max_images_per_page") {
+        Some(u32::try_convert(val)?)
+    } else {
+        None
+    };
+
     let config = ImageExtractionConfig {
         extract_images,
         target_dpi,
@@ -412,6 +419,7 @@ pub fn parse_image_extraction_config(ruby: &Ruby, hash: RHash) -> Result<ImageEx
         auto_adjust_dpi,
         min_dpi,
         max_dpi,
+        max_images_per_page,
     };
 
     Ok(config)

data/lib/kreuzberg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kreuzberg
-  VERSION = '4.9.2'
+  VERSION = '4.9.6'
 end

data/vendor/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["kreuzberg", "kreuzberg-ffi", "kreuzberg-tesseract", "kreuzberg-paddle-ocr", "kreuzberg-pdfium-render"]
 
 [workspace.package]
-version = "4.9.2"
+version = "4.9.6"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
@@ -28,12 +28,12 @@ dbase = "0.7"
 futures = "0.3"
 getrandom = { version = "0.4.2", features = ["wasm_js"] }
 hex = "0.4.3"
-html-to-markdown-rs = { version = "3.2.5", default-features = false }
+html-to-markdown-rs = { version = "3.3.1", default-features = false }
 image = { version = "0.25.10", default-features = false }
 itertools = "0.14"
 js-sys = "0.3"
-kreuzberg = { path = "./crates/kreuzberg", version = "4.9.2", default-features = false }
-kreuzberg-ffi = { path = "./crates/kreuzberg-ffi", version = "4.9.2" }
+kreuzberg = { path = "./crates/kreuzberg", version = "4.9.6", default-features = false }
+kreuzberg-ffi = { path = "./crates/kreuzberg-ffi", version = "4.9.6" }
 lazy_static = "1.5.0"
 libc = "0.2.185"
 liter-llm = { version = "1.2", features = ["native-http", "tracing"], default-features = false }
@@ -45,7 +45,7 @@ num_cpus = "1.17.0"
 once_cell = "1.21.4"
 ort = { version = "2.0.0-rc.12", features = ["std", "api-18"], default-features = false }
 parking_lot = "0.12.5"
-pdf_oxide = { version = "0.3.34", default-features = false }
+pdf_oxide = { version = "0.3.37", default-features = false }
 pdfium-render = { package = "kreuzberg-pdfium-render", path = "crates/kreuzberg-pdfium-render", version = "4.3" }
 rayon = "1.12.0"
 reqwest = { version = "0.13.2", default-features = false }
@@ -57,7 +57,7 @@ thiserror = "2.0.18"
 tokio = { version = "1.52.1", features = ["rt", "rt-multi-thread", "macros", "sync", "process", "fs", "time", "io-util"] }
 toml = "1.1.2"
 tracing = "0.1"
-tree-sitter-language-pack = { version = "1.6.2", features = ["serde"], default-features = false }
+tree-sitter-language-pack = { version = "1.7.0", features = ["serde"], default-features = false }
 wasm-bindgen = { version = "0.2", features = ["enable-interning"] }
 wasm-bindgen-futures = "0.4"
 web-sys = { version = "0.3", features = ["Blob", "File", "FileReader", "console", "TextDecoder", "ImageData", "Window", "Response"] }

data/vendor/kreuzberg/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg"
-version = "4.9.2"
+version = "4.9.6"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
@@ -271,7 +271,7 @@ hayro-jpeg2000 = { version = "0.3", default-features = false, features = [
     "simd",
 ], optional = true }
 hex = "0.4.3"
-html-to-markdown-rs = { version = "3.2.5", default-features = false, features = [
+html-to-markdown-rs = { version = "3.3.1", default-features = false, features = [
     "inline-images",
     "metadata",
 ], optional = true }
@@ -287,7 +287,7 @@ image = { version = "0.25.10", default-features = false, features = [
 ], optional = true }
 indexmap = "2.14.0"
 infer = "0.19.0"
-jotdown = "0.9"
+jotdown = "0.10"
 kamadak-exif = { version = "0.6.1", optional = true }
 
 kreuzberg-tesseract = { path = "../kreuzberg-tesseract", optional = true }
@@ -314,7 +314,7 @@ ort = { version = "2.0.0-rc.12", default-features = false, features = [
 outlook-pst = { version = "1.2.0", optional = true }
 parking_lot = "0.12.5"
 pastey = "0.2"
-pdf_oxide = { version = "0.3.34", default-features = false, optional = true }
+pdf_oxide = { version = "0.3.37", default-features = false, optional = true }
 pdfium-render = { package = "kreuzberg-pdfium-render", path = "../kreuzberg-pdfium-render", features = ["thread_safe", "image_latest"], optional = true }
 pulldown-cmark = { version = "0.13" }
 quick-xml = { version = "0.39.2", features = ["serialize"], optional = true }
@@ -392,7 +392,7 @@ optional = true
 # Override getrandom to enable js feature for WASM targets
 # This is needed because ring/rustls (via ureq) depend on getrandom without js feature
 getrandom = { version = "0.4.2", features = ["wasm_js"] }
-tree-sitter-language-pack = { version = "1.6.2", features = ["serde"], default-features = false, optional = true }
+tree-sitter-language-pack = { version = "1.7.0", features = ["serde"], default-features = false, optional = true }
 wasm-bindgen-rayon = { version = "1.3", optional = true }
 
 [build-dependencies]

data/vendor/kreuzberg/README.md

@@ -18,7 +18,7 @@ High-performance document intelligence library for Rust. Extract text, metadata,
 
 This is the core Rust library that powers the Python, TypeScript, and Ruby bindings.
 
-> **🚀 Version 4.9.2 Release**
+> **🚀 Version 4.9.6 Release**
 > This is a pre-release version. We invite you to test the library and [report any issues](https://github.com/kreuzberg-dev/kreuzberg/issues) you encounter.
 >
 > **Note**: The Rust crate is not currently published to crates.io for this RC. Use git dependencies or language bindings (Python, TypeScript, Ruby) instead.

data/vendor/kreuzberg/src/chunking/semantic/mod.rs

@@ -25,10 +25,6 @@ const SEGMENT_SIZE: usize = 200;
 #[cfg(feature = "embeddings")]
 const DEFAULT_TOPIC_THRESHOLD: f32 = 0.75;
 
-/// Safety ceiling for auto-budget when no embedding model is configured.
-/// Prevents unbounded chunks in header-less documents.
-const AUTO_BUDGET_CEILING: usize = 4000;
-
 /// Split text into semantically coherent chunks.
 ///
 /// Splits text into fine-grained segments, detects structural (and optionally
@@ -46,6 +42,8 @@ pub fn chunk_semantic(
         });
     }
 
+    warn_if_fallback_path(config);
+
     let seg_size = SEGMENT_SIZE;
     let has_markdown_headers = text.lines().any(crate::utils::markdown_utils::is_markdown_header);
     let splitter_segments: Vec<&str> = if has_markdown_headers {
@@ -165,11 +163,33 @@ fn compute_boundaries(_segments: &[Segment<'_>], forced: &[bool], _config: &Chun
     Ok(forced.to_vec())
 }
 
-/// Resolve the safety ceiling for chunk size.
+/// Warn when the semantic chunker is invoked without an embedding model.
+///
+/// Without an embedding, `chunk_semantic` falls back to a structural-boundary
+/// heuristic (ALL-CAPS headers, numbered sections, blank-line paragraphs).
+/// Topic-similarity chunking requires an embedding model. This warning makes
+/// the fallback mode discoverable to callers who think they're getting
+/// embedding-driven topic detection.
+#[cfg(feature = "embeddings")]
+fn warn_if_fallback_path(config: &ChunkingConfig) {
+    if config.embedding.is_none() {
+        tracing::warn!(
+            "chunker_type='semantic' without an EmbeddingConfig falls back to a \
+             structural-boundary heuristic; topic-similarity chunking requires an \
+             embedding model. Either configure `embedding` or switch to \
+             chunker_type='text'/'markdown' to silence this warning."
+        );
+    }
+}
+
+#[cfg(not(feature = "embeddings"))]
+fn warn_if_fallback_path(_config: &ChunkingConfig) {}
+
+/// Resolve the size ceiling for merged chunks.
 ///
-/// When an embedding preset is configured, use its chunk_size as the ceiling
-/// (chunks must fit in the model's context window). Otherwise use a generous
-/// default that prevents unbounded chunks in header-less documents.
+/// When an embedding preset is configured, use its `chunk_size` so chunks fit
+/// in the model's context window. Otherwise honor the caller's configured
+/// `max_characters`.
 fn resolve_ceiling(config: &ChunkingConfig) -> usize {
     #[cfg(feature = "embeddings")]
     if let Some(ref emb) = config.embedding
@@ -178,8 +198,7 @@ fn resolve_ceiling(config: &ChunkingConfig) -> usize {
     {
         return size;
     }
-    let _ = config;
-    AUTO_BUDGET_CEILING
+    config.max_characters
 }
 
 #[cfg(test)]
@@ -306,30 +325,124 @@ mod tests {
     }
 
     #[test]
-    fn ceiling_caps_oversized_headerless_text() {
-        // A large block of text with no headers should be split at the ceiling,
-        // not produce one unbounded chunk.
-        let text = "word ".repeat(1500); // ~7500 chars, exceeds AUTO_BUDGET_CEILING
+    fn max_characters_caps_oversized_headerless_text() {
+        // A large block of text with no headers must be split so every chunk
+        // respects the caller's configured max_characters.
+        let text = "word ".repeat(1500); // ~7500 chars
+        let max = 1000;
         let config = ChunkingConfig {
-            max_characters: 1000, // ignored by semantic chunker
+            max_characters: max,
             overlap: 0,
             trim: true,
             chunker_type: ChunkerType::Semantic,
             ..Default::default()
         };
         let result = chunk_semantic(&text, &config, None).unwrap();
-        assert!(result.chunks.len() >= 2, "should split at ceiling, got 1 chunk");
+        assert!(result.chunks.len() >= 2, "should split at max_characters, got 1 chunk");
         for (i, chunk) in result.chunks.iter().enumerate() {
             assert!(
-                chunk.content.chars().count() <= super::AUTO_BUDGET_CEILING + 100,
-                "chunk {} exceeds ceiling: {} > {}",
+                chunk.content.chars().count() <= max,
+                "chunk {} exceeds max_characters: {} > {}",
                 i,
                 chunk.content.chars().count(),
-                super::AUTO_BUDGET_CEILING
+                max
             );
         }
     }
 
+    #[test]
+    fn max_characters_controls_fallback_chunk_size() {
+        // bb-yq35 repro: with no embedding configured, different max_characters
+        // values must produce different chunking output.
+        let sample = format!(
+            "{}{}{}",
+            "Solar panel efficiency improves. ".repeat(200),
+            "\n\nFDA clinical trials require double-blind. ".repeat(200),
+            "\n\nQuantum entanglement needs cooling. ".repeat(200),
+        );
+
+        let run = |max: usize| {
+            let config = ChunkingConfig {
+                max_characters: max,
+                overlap: 0,
+                trim: true,
+                chunker_type: ChunkerType::Semantic,
+                ..Default::default()
+            };
+            chunk_semantic(&sample, &config, None).unwrap()
+        };
+
+        let small = run(500);
+        let large = run(1500);
+
+        assert!(
+            small.chunks.len() > large.chunks.len(),
+            "smaller max_characters must yield more chunks: small={}, large={}",
+            small.chunks.len(),
+            large.chunks.len()
+        );
+        for chunk in &small.chunks {
+            assert!(
+                chunk.content.chars().count() <= 500,
+                "small chunk exceeds cap: {}",
+                chunk.content.chars().count()
+            );
+        }
+        for chunk in &large.chunks {
+            assert!(
+                chunk.content.chars().count() <= 1500,
+                "large chunk exceeds cap: {}",
+                chunk.content.chars().count()
+            );
+        }
+    }
+
+    #[cfg(feature = "embeddings")]
+    #[test]
+    fn semantic_without_embedding_warns() {
+        use std::io::Write;
+        use std::sync::{Arc, Mutex};
+
+        #[derive(Clone, Default)]
+        struct Buf(Arc<Mutex<Vec<u8>>>);
+        impl Write for Buf {
+            fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+                self.0.lock().unwrap().extend_from_slice(buf);
+                Ok(buf.len())
+            }
+            fn flush(&mut self) -> std::io::Result<()> {
+                Ok(())
+            }
+        }
+        impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for Buf {
+            type Writer = Buf;
+            fn make_writer(&'a self) -> Self::Writer {
+                self.clone()
+            }
+        }
+
+        let buffer = Buf::default();
+        let subscriber = tracing_subscriber::fmt()
+            .with_writer(buffer.clone())
+            .with_max_level(tracing::Level::WARN)
+            .with_ansi(false)
+            .finish();
+
+        tracing::subscriber::with_default(subscriber, || {
+            let config = ChunkingConfig {
+                chunker_type: ChunkerType::Semantic,
+                ..Default::default()
+            };
+            let _ = chunk_semantic("hello world", &config, None).unwrap();
+        });
+
+        let captured = String::from_utf8(buffer.0.lock().unwrap().clone()).unwrap();
+        assert!(
+            captured.contains("without an EmbeddingConfig"),
+            "expected fallback warning in captured logs, got: {captured:?}"
+        );
+    }
+
     #[test]
     fn sections_with_headers_produce_separate_chunks() {
         // Each section has enough content that the segments span multiple paragraphs.

data/vendor/kreuzberg/src/core/config/extraction/types.rs

@@ -40,6 +40,18 @@ pub struct ImageExtractionConfig {
     /// Maximum DPI threshold
     #[serde(default = "default_max_dpi")]
     pub max_dpi: i32,
+
+    /// Maximum number of image objects to extract per PDF page.
+    ///
+    /// Some PDFs (e.g. technical diagrams stored as thousands of raster fragments)
+    /// can trigger extremely long or indefinite extraction times when every image
+    /// object on a dense page is decoded individually via pdfium FFI. Setting this
+    /// limit causes kreuzberg to stop collecting individual images once the count
+    /// per page reaches the cap and emit a warning instead.
+    ///
+    /// `None` (default) means no limit — all images are extracted.
+    #[serde(default)]
+    pub max_images_per_page: Option<u32>,
 }
 
 /// Token reduction configuration.
@@ -98,3 +110,44 @@ fn default_reduction_mode() -> String {
 fn default_confidence() -> f64 {
     0.8
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_max_images_per_page_defaults_none() {
+        let config = ImageExtractionConfig::default();
+        assert_eq!(config.max_images_per_page, None);
+    }
+
+    #[test]
+    fn test_max_images_per_page_serializes_as_null_when_none() {
+        let config = ImageExtractionConfig::default();
+        let json = serde_json::to_string(&config).unwrap();
+        assert!(json.contains("\"max_images_per_page\":null"));
+    }
+
+    #[test]
+    fn test_max_images_per_page_roundtrips_via_json() {
+        let config = ImageExtractionConfig {
+            max_images_per_page: Some(50),
+            ..Default::default()
+        };
+        let json = serde_json::to_string(&config).unwrap();
+        let back: ImageExtractionConfig = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.max_images_per_page, Some(50));
+    }
+
+    /// Regression test for issue #766: missing field in JSON must not break
+    /// deserialization (backwards-compat — existing configs without this key
+    /// must still deserialize cleanly).
+    #[test]
+    fn test_max_images_per_page_absent_in_json_deserializes_as_none() {
+        let json = r#"{"extract_images":true,"target_dpi":300,"max_image_dimension":4096,
+                       "inject_placeholders":true,"auto_adjust_dpi":true,
+                       "min_dpi":72,"max_dpi":600}"#;
+        let config: ImageExtractionConfig = serde_json::from_str(json).unwrap();
+        assert_eq!(config.max_images_per_page, None);
+    }
+}

data/vendor/kreuzberg/src/core/config/ocr.rs

@@ -271,6 +271,13 @@ pub struct OcrConfig {
     /// - `{{ language }}` — The document language code (e.g., "eng", "deu").
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub vlm_prompt: Option<String>,
+
+    /// Hardware acceleration for ONNX Runtime models (e.g. PaddleOCR, layout detection).
+    ///
+    /// Not user-configurable via config files — injected at runtime from
+    /// `ExtractionConfig::acceleration` before each `process_image` call.
+    #[serde(skip)]
+    pub acceleration: Option<super::acceleration::AccelerationConfig>,
 }
 
 impl Default for OcrConfig {
@@ -288,6 +295,7 @@ impl Default for OcrConfig {
             auto_rotate: false,
             vlm_config: None,
             vlm_prompt: None,
+            acceleration: None,
         }
     }
 }

data/vendor/kreuzberg/src/core/config/processing.rs

@@ -14,11 +14,13 @@ use std::path::PathBuf;
 /// * `Text` - Generic text splitter, splits on whitespace and punctuation
 /// * `Markdown` - Markdown-aware splitter, preserves formatting and structure
 /// * `Yaml` - YAML-aware splitter, creates one chunk per top-level key
-/// * `Semantic` - Topic-aware chunker that splits at natural document boundaries
-///   (headers, paragraph breaks, topic shifts). Works out of the box with no extra
-///   configuration. Optionally add an `EmbeddingConfig` for embedding-based topic
-///   detection; `topic_threshold` (default 0.75) and `max_characters` (default 1000)
-///   are automatically applied when not specified.
+/// * `Semantic` - Topic-aware chunker. With an `EmbeddingConfig`, splits at
+///   embedding-based topic shifts tuned by `topic_threshold` (default 0.75,
+///   lower = more splits). Without an embedding, falls back to a
+///   structural-boundary heuristic (ALL-CAPS headers, numbered sections,
+///   blank-line paragraphs) and merges groups into chunks capped at
+///   `max_characters` (default 1000). `topic_threshold` has no effect in the
+///   fallback path. For best results, pair with an embedding model.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(rename_all = "lowercase")]
 pub enum ChunkerType {
@@ -265,15 +267,10 @@ impl ChunkingConfig {
             }
         };
 
-        let embedding = match &self.embedding {
-            Some(existing) => Some(existing.clone()),
-            None => Some(EmbeddingConfig {
-                model: EmbeddingModelType::Preset {
-                    name: preset_name.clone(),
-                },
-                ..EmbeddingConfig::default()
-            }),
-        };
+        // Preserve the caller's embedding choice, including None.
+        // Presets configure chunking parameters only; users must explicitly
+        // provide an EmbeddingConfig to opt into embedding generation.
+        let embedding = self.embedding.clone();
 
         Self {
             max_characters: preset.chunk_size,
@@ -566,11 +563,9 @@ mod tests {
         let resolved = config.resolve_preset();
         assert_eq!(resolved.max_characters, 1024);
         assert_eq!(resolved.overlap, 100);
-        assert!(resolved.embedding.is_some());
-        match &resolved.embedding.unwrap().model {
-            EmbeddingModelType::Preset { name } => assert_eq!(name, "balanced"),
-            _ => panic!("Expected Preset model type"),
-        }
+        // Preset configures chunking parameters only; embedding stays None unless
+        // the caller explicitly provided one (#797).
+        assert!(resolved.embedding.is_none());
     }
 
     #[test]
@@ -684,4 +679,69 @@ mod tests {
             _ => panic!("Expected Custom variant"),
         }
     }
+
+    // --- Issue #797 regression tests ---
+
+    /// Preset with no explicit embedding: embedding must remain None.
+    ///
+    /// Before the fix, `resolve_preset()` would silently inject an
+    /// `EmbeddingConfig` whenever a preset was configured, causing every
+    /// chunk to have an unexpected `.embedding` field populated.
+    #[test]
+    #[cfg(feature = "embeddings")]
+    fn test_resolve_preset_does_not_inject_embedding_when_none() {
+        let config = ChunkingConfig {
+            preset: Some("multilingual".to_string()),
+            embedding: None,
+            ..Default::default()
+        };
+        let resolved = config.resolve_preset();
+        assert!(
+            resolved.embedding.is_none(),
+            "preset alone must not inject an EmbeddingConfig (#797)"
+        );
+    }
+
+    /// Preset with an explicit embedding: the embedding must be preserved unchanged.
+    #[test]
+    #[cfg(feature = "embeddings")]
+    fn test_resolve_preset_preserves_explicit_embedding_config() {
+        let explicit = EmbeddingConfig {
+            model: EmbeddingModelType::Custom {
+                model_id: "my-org/model".to_string(),
+                dimensions: 768,
+            },
+            batch_size: 16,
+            ..Default::default()
+        };
+        let config = ChunkingConfig {
+            preset: Some("multilingual".to_string()),
+            embedding: Some(explicit),
+            ..Default::default()
+        };
+        let resolved = config.resolve_preset();
+        let emb = resolved
+            .embedding
+            .expect("explicit embedding must survive resolve_preset");
+        assert_eq!(emb.batch_size, 16);
+        match emb.model {
+            EmbeddingModelType::Custom { model_id, dimensions } => {
+                assert_eq!(model_id, "my-org/model");
+                assert_eq!(dimensions, 768);
+            }
+            other => panic!("expected Custom model type, got {other:?}"),
+        }
+    }
+
+    /// No preset, no embedding: embedding must stay None (regression guard).
+    #[test]
+    fn test_resolve_preset_no_preset_no_embedding_stays_none() {
+        let config = ChunkingConfig {
+            preset: None,
+            embedding: None,
+            ..Default::default()
+        };
+        let resolved = config.resolve_preset();
+        assert!(resolved.embedding.is_none(), "no-preset path must not touch embedding");
+    }
 }

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

@@ -64,11 +64,16 @@ where
 }
 
 /// Run a single extraction task with semaphore gating, timing, optional timeout, and batch mode.
+///
+/// When `cancel_token` is provided and the timeout fires, the token is signalled so that
+/// any blocking pdfium operations in progress can observe the cancellation at the next
+/// inter-page checkpoint and stop early.
 #[cfg(feature = "tokio-runtime")]
 async fn run_timed_extraction<F, Fut>(
     index: usize,
     semaphore: Arc<tokio::sync::Semaphore>,
     timeout_secs: Option<u64>,
+    cancel_token: Option<crate::cancellation::CancellationToken>,
     extract_fn: F,
 ) -> (usize, Result<ExtractionResult>, u64)
 where
@@ -84,6 +89,11 @@ where
         Some(secs) => match tokio::time::timeout(std::time::Duration::from_secs(secs), extraction_future).await {
             Ok(inner) => inner,
             Err(_elapsed) => {
+                // Signal the cancellation token so that any blocking pdfium thread can
+                // detect it at the next inter-page checkpoint and stop processing.
+                if let Some(ref token) = cancel_token {
+                    token.cancel();
+                }
                 let elapsed_ms = start.elapsed().as_millis() as u64;
                 Err(KreuzbergError::Timeout {
                     elapsed_ms,
@@ -200,7 +210,8 @@ pub async fn batch_extract_file(
             let (ref path, ref file_config) = items[index];
             let resolved = resolve_config(&cfg, file_config);
             let timeout = resolved.extraction_timeout_secs;
-            run_timed_extraction(index, sem, timeout, || {
+            let cancel_token = resolved.cancel_token.clone();
+            run_timed_extraction(index, sem, timeout, cancel_token, || {
                 let path = path.clone();
                 async move { extract_file(&path, None, &resolved).await }
             })
@@ -301,7 +312,8 @@ pub async fn batch_extract_bytes(
             let (bytes, mime_type, file_config) = slots[index].lock().take().expect("batch item already consumed");
             let resolved = resolve_config(&cfg, &file_config);
             let timeout = resolved.extraction_timeout_secs;
-            run_timed_extraction(index, sem, timeout, || async move {
+            let cancel_token = resolved.cancel_token.clone();
+            run_timed_extraction(index, sem, timeout, cancel_token, || async move {
                 extract_bytes(&bytes, &mime_type, &resolved).await
             })
             .await