kreuzberg 4.2.10 → 4.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abf625c4f7eedb0ba24619d640ac572192a112bf29876c25c662c8faf8a7219c
-  data.tar.gz: 460cdf492f802db89332e989340070448c5b60bb44ce0860a1104889814bb9ac
+  metadata.gz: 869101ec7a3d0814c2baed8606879024e94880ead0003d441a16199d25fd3a16
+  data.tar.gz: 9852c4c51345f362095306f40d910c2e1d4ae19f385754d4c8d3a960123f96ee
 SHA512:
-  metadata.gz: 6e9b8b00347a73747e7ab8aad698f2d7a5798609dd1b086fe6df3a723c49bd05c5dff3c8ad0e7c83720cc3944b1a9d66fdec710405c9f1e22e43fe55387cdc92
-  data.tar.gz: dab907905f37a8fbc13d4c3e7e893cf6162fe57c6d735bfe08dfec32ea721706ab683d1baa4cfa6b0db4db8c393e7909ee3cf98195881ea31c8dc5ce0cda0b6a
+  metadata.gz: 579be7645c2f406ce8e7c4cc85ed511edb7c5879bc8674fe9ec4eb4375cf240113968f0ce35747bd10fae52ff5849df4616d8c6db299db609696da24b2700fff
+  data.tar.gz: adc5969c0480739fd57a6bdb832db435d64e16ee0b2827197f05fcf4f52a7e7c03affd704b4c1064df49391bb105c4166531b8c4ba96538906b38f863744c843

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kreuzberg (4.2.10)
+    kreuzberg (4.2.12)
       rb_sys (~> 0.9.119)
 
 GEM
@@ -123,7 +123,7 @@ GEM
       rubocop (~> 1.81)
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
-    sorbet-runtime (0.6.12914)
+    sorbet-runtime (0.6.12925)
     steep (1.10.0)
       activesupport (>= 5.1)
       concurrent-ruby (>= 1.1.10)
@@ -209,7 +209,7 @@ CHECKSUMS
   i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
   io-console (0.8.2) sha256=d6e3ae7a7cc7574f4b8893b4fca2162e57a825b223a177b7afa236c5ef9814cc
   json (2.18.1) sha256=fe112755501b8d0466b5ada6cf50c8c3f41e897fa128ac5d263ec09eedc9f986
-  kreuzberg (4.2.10)
+  kreuzberg (4.2.12)
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
   listen (3.10.0) sha256=c6e182db62143aeccc2e1960033bebe7445309c7272061979bb098d03760c9d2
@@ -244,7 +244,7 @@ CHECKSUMS
   rubocop-rspec (3.9.0) sha256=8fa70a3619408237d789aeecfb9beef40576acc855173e60939d63332fdb55e2
   ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
   securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
-  sorbet-runtime (0.6.12914) sha256=6d3c985d671dab9ab8ea244b51888b6e8e8e65e881e5bf816d1ac0950479dce6
+  sorbet-runtime (0.6.12925) sha256=ddd6fb1d8aaf6bc19119ffadbc4b96536f3d6766fa82059112dacb90977c6eca
   steep (1.10.0) sha256=1b295b55f9aaff1b8d3ee42453ee55bc2a1078fda0268f288edb2dc014f4d7d1
   strscan (3.1.7) sha256=5f76462b94a3ea50b44973225b7d75b2cb96d4e1bee9ef1319b99ca117b72c8c
   terminal-table (4.0.0) sha256=f504793203f8251b2ea7c7068333053f0beeea26093ec9962e62ea79f94301d2

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.2.10" alt="Go">
+    <img src="https://img.shields.io/github/v/tag/kreuzberg-dev/kreuzberg?label=Go&color=007ec6&filter=v4.2.12" 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.lock

@@ -2755,7 +2755,7 @@ dependencies = [
 
 [[package]]
 name = "kreuzberg-rb"
-version = "4.0.0"
+version = "4.2.10"
 dependencies = [
  "async-trait",
  "html-to-markdown-rs",

data/ext/kreuzberg_rb/native/Cargo.toml

@@ -37,7 +37,7 @@ collapsible_if = "allow"
 
 [package]
 name = "kreuzberg-rb"
-version = "4.2.10"
+version = "4.2.12"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/lib/kreuzberg/version.rb

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

data/vendor/Cargo.toml

@@ -3,7 +3,7 @@ members = ["kreuzberg", "kreuzberg-tesseract", "kreuzberg-ffi"]
 resolver = "2"
 
 [workspace.package]
-version = "4.2.10"
+version = "4.2.12"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/vendor/kreuzberg/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg"
-version = "4.2.10"
+version = "4.2.12"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -35,7 +35,6 @@ excel = ["dep:calamine", "dep:polars", "tokio-runtime"]
 office = [
     "dep:roxmltree",
     "dep:zip",
-    "dep:docx-lite",
     "dep:quick-xml",
     "dep:pulldown-cmark",
     "dep:biblatex",
@@ -151,10 +150,10 @@ pdfium-render = { package = "kreuzberg-pdfium-render", version = "0.9.0", featur
     "image_latest",
 ], optional = true }
 lopdf = { version = "0.39.0", optional = true }
-calamine = { version = "0.32.0", features = ["dates"], optional = true }
+calamine = { version = "0.33.0", features = ["dates"], optional = true }
 polars = { version = "0.52.0", default-features = false, features = ["ipc"], optional = true }
 roxmltree = { version = "0.21.1", optional = true }
-zip = { version = "7.2.0", optional = true }
+zip = { version = "7.4.0", optional = true }
 mail-parser = { version = "0.11.1", optional = true }
 msg_parser = { version = "0.1.1", optional = true }
 html-to-markdown-rs = { workspace = true, features = [
@@ -165,7 +164,6 @@ quick-xml = { version = "0.39.0", features = ["serialize"], optional = true }
 tar = { version = "0.4.44", optional = true }
 sevenz-rust2 = { version = "0.20.1", optional = true }
 lzma-rust2 = { workspace = true, optional = true }
-docx-lite = { version = "0.2.0", optional = true }
 
 pulldown-cmark = { version = "0.13", optional = true }
 biblatex = { version = "0.11", optional = true }
@@ -218,7 +216,7 @@ smartcore = { version = "0.4", default-features = false, features = ["serde"] }
 tempfile = { workspace = true }
 filetime = "0.2"
 tar = "0.4.44"
-zip = "7.2.0"
+zip = "7.4.0"
 serial_test = "3.3.1"
 anyhow = { workspace = true }
 tokio-test = "0.4"
@@ -239,7 +237,7 @@ fastembed = { version = "5.8", default-features = false, features = [
     "ort-load-dynamic",
 ], optional = true }
 # Force ureq (transitive dep via hf-hub) to use rustls on non-Windows
-ureq = { version = "3.1", default-features = false, features = ["rustls", "json"] }
+ureq = { version = "3.2", default-features = false, features = ["rustls", "json"] }
 
 # Use native-tls on Windows to avoid aws-lc-sys CMake build issues with MinGW
 [target.'cfg(all(target_os = "windows", not(target_arch = "wasm32")))'.dependencies]
@@ -253,7 +251,7 @@ fastembed = { version = "5.8", default-features = false, features = [
     "ort-load-dynamic",
 ], optional = true }
 # Force ureq (transitive dep via hf-hub) to use native-tls on Windows
-ureq = { version = "3.1", default-features = false, features = ["native-tls", "json"] }
+ureq = { version = "3.2", default-features = false, features = ["native-tls", "json"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-rayon = { version = "1.3", optional = true }

data/vendor/kreuzberg/README.md

@@ -17,7 +17,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.2.10 Release**
+> **🚀 Version 4.2.12 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/core/extractor/batch.rs

@@ -9,6 +9,7 @@ use crate::{KreuzbergError, Result};
 use std::borrow::Cow;
 use std::path::Path;
 use std::sync::Arc;
+use std::time::Instant;
 
 use super::bytes::extract_bytes;
 use super::file::extract_file;
@@ -82,10 +83,18 @@ pub async fn batch_extract_file(
 
         tasks.spawn(async move {
             let _permit = semaphore_clone.acquire().await.unwrap();
-            let result =
+            let start = Instant::now();
+            let mut result =
                 crate::core::batch_mode::with_batch_mode(async { extract_file(&path_buf, None, &config_clone).await })
                     .await;
-            (index, result)
+            let elapsed_ms = start.elapsed().as_millis() as u64;
+
+            // Add extraction timing to result metadata for benchmarking
+            if let Ok(ref mut r) = result {
+                r.metadata.extraction_duration_ms = Some(elapsed_ms);
+            }
+
+            (index, result, elapsed_ms)
         });
     }
 
@@ -93,10 +102,11 @@ pub async fn batch_extract_file(
 
     while let Some(task_result) = tasks.join_next().await {
         match task_result {
-            Ok((index, Ok(result))) => {
+            Ok((index, Ok(result), _elapsed_ms)) => {
+                // Timing already added to result.metadata.extraction_duration_ms
                 results[index] = Some(result);
             }
-            Ok((index, Err(e))) => {
+            Ok((index, Err(e), elapsed_ms)) => {
                 // All errors (including Io) should create error results
                 // instead of causing early return that abandons running tasks
                 let metadata = Metadata {
@@ -104,6 +114,7 @@ pub async fn batch_extract_file(
                         error_type: format!("{:?}", e),
                         message: e.to_string(),
                     }),
+                    extraction_duration_ms: Some(elapsed_ms),
                     ..Default::default()
                 };
 
@@ -196,11 +207,19 @@ pub async fn batch_extract_bytes(
 
         tasks.spawn(async move {
             let _permit = semaphore_clone.acquire().await.unwrap();
-            let result = crate::core::batch_mode::with_batch_mode(async {
+            let start = Instant::now();
+            let mut result = crate::core::batch_mode::with_batch_mode(async {
                 extract_bytes(&bytes, &mime_type, &config_clone).await
             })
             .await;
-            (index, result)
+            let elapsed_ms = start.elapsed().as_millis() as u64;
+
+            // Add extraction timing to result metadata for benchmarking
+            if let Ok(ref mut r) = result {
+                r.metadata.extraction_duration_ms = Some(elapsed_ms);
+            }
+
+            (index, result, elapsed_ms)
         });
     }
 
@@ -208,10 +227,11 @@ pub async fn batch_extract_bytes(
 
     while let Some(task_result) = tasks.join_next().await {
         match task_result {
-            Ok((index, Ok(result))) => {
+            Ok((index, Ok(result), _elapsed_ms)) => {
+                // Timing already added to result.metadata.extraction_duration_ms
                 results[index] = Some(result);
             }
-            Ok((index, Err(e))) => {
+            Ok((index, Err(e), elapsed_ms)) => {
                 // All errors (including Io) should create error results
                 // instead of causing early return that abandons running tasks
                 let metadata = Metadata {
@@ -219,6 +239,7 @@ pub async fn batch_extract_bytes(
                         error_type: format!("{:?}", e),
                         message: e.to_string(),
                     }),
+                    extraction_duration_ms: Some(elapsed_ms),
                     ..Default::default()
                 };
 

data/vendor/kreuzberg/src/extraction/{docx.rs → docx/mod.rs}

@@ -1,31 +1,21 @@
-//! DOCX (Microsoft Word) text extraction using docx-lite.
+//! DOCX (Microsoft Word) text extraction.
 //!
-//! This module provides high-performance text extraction from DOCX files using the docx-lite
-//! library, which uses streaming XML parsing for efficiency.
+//! This module provides high-performance text extraction from DOCX files using
+//! streaming XML parsing for efficiency.
 //!
 //! Page break detection is best-effort, detecting only explicit page breaks (`<w:br w:type="page"/>`)
 //! in the document XML. This does not account for automatic pagination based on content reflowing.
 
+pub mod parser;
+
 use crate::error::{KreuzbergError, Result};
 use crate::extraction::capacity;
 use crate::types::PageBoundary;
 use std::io::Cursor;
 
-/// Extract text from DOCX bytes using docx-lite.
-///
-/// # Arguments
-/// * `bytes` - The DOCX file contents as bytes
-///
-/// # Returns
-/// * `Ok(String)` - The extracted text content
-/// * `Err(KreuzbergError)` - If extraction fails
-///
-/// # Performance
-/// docx-lite uses streaming XML parsing for minimal memory overhead and high throughput
-/// (~160 MB/s average).
+/// Extract text from DOCX bytes.
 pub fn extract_text(bytes: &[u8]) -> Result<String> {
-    docx_lite::extract_text_from_bytes(bytes)
-        .map_err(|e| KreuzbergError::parsing(format!("DOCX text extraction failed: {}", e)))
+    parser::extract_text_from_bytes(bytes)
 }
 
 /// Extract text and page boundaries from DOCX bytes.

data/vendor/kreuzberg/src/extraction/docx/parser.rs

@@ -0,0 +1,686 @@
+//! Inline DOCX XML parser.
+//!
+//! Vendored and adapted from [docx-lite](https://github.com/v-lawyer/docx-lite) v0.2.0
+//! (MIT OR Apache-2.0, V-Lawyer Team). See ATTRIBUTIONS.md for details.
+//!
+//! Changes from upstream:
+//! - `Paragraph::to_text()` joins runs with `" "` instead of `""` (fixes #359)
+//! - Adapted to use kreuzberg's existing `quick-xml` and `zip` versions
+//! - Removed file-path based APIs (we only need bytes/reader)
+
+use std::collections::HashMap;
+use std::io::{Cursor, Read, Seek};
+
+use quick_xml::Reader;
+use quick_xml::events::Event;
+
+// --- Types ---
+
+#[derive(Debug, Clone, Default)]
+pub struct Document {
+    pub paragraphs: Vec<Paragraph>,
+    pub tables: Vec<Table>,
+    pub lists: Vec<ListItem>,
+    pub headers: Vec<HeaderFooter>,
+    pub footers: Vec<HeaderFooter>,
+    pub footnotes: Vec<Note>,
+    pub endnotes: Vec<Note>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Paragraph {
+    pub runs: Vec<Run>,
+    pub style: Option<String>,
+    pub numbering_id: Option<i64>,
+    pub numbering_level: Option<i64>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Run {
+    pub text: String,
+    pub bold: bool,
+    pub italic: bool,
+    pub underline: bool,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Table {
+    pub rows: Vec<TableRow>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct TableRow {
+    pub cells: Vec<TableCell>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct TableCell {
+    pub paragraphs: Vec<Paragraph>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ListItem {
+    pub level: u32,
+    pub list_type: ListType,
+    pub number: Option<String>,
+    pub text: String,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ListType {
+    Bullet,
+    Numbered,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct HeaderFooter {
+    pub paragraphs: Vec<Paragraph>,
+    pub tables: Vec<Table>,
+    pub header_type: HeaderFooterType,
+}
+
+#[derive(Debug, Clone, Default, PartialEq)]
+pub enum HeaderFooterType {
+    #[default]
+    Default,
+    First,
+    Even,
+    Odd,
+}
+
+#[derive(Debug, Clone)]
+pub struct Note {
+    pub id: String,
+    pub note_type: NoteType,
+    pub paragraphs: Vec<Paragraph>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum NoteType {
+    Footnote,
+    Endnote,
+}
+
+// --- Impls ---
+
+impl Document {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn extract_text(&self) -> String {
+        let mut text = String::new();
+
+        let mut list_index = 0;
+        for paragraph in &self.paragraphs {
+            if let (Some(_num_id), Some(_level)) = (paragraph.numbering_id, paragraph.numbering_level) {
+                let para_text = paragraph.to_text();
+                if !para_text.is_empty() {
+                    text.push_str(&para_text);
+                    text.push('\n');
+                }
+                list_index += 1;
+                let _ = list_index; // suppress unused warning
+            } else {
+                let para_text = paragraph.to_text();
+                if !para_text.is_empty() {
+                    text.push_str(&para_text);
+                    text.push('\n');
+                }
+            }
+        }
+
+        for table in &self.tables {
+            for row in &table.rows {
+                for cell in &row.cells {
+                    for paragraph in &cell.paragraphs {
+                        let para_text = paragraph.to_text();
+                        if !para_text.is_empty() {
+                            text.push_str(&para_text);
+                            text.push('\t');
+                        }
+                    }
+                }
+                text.push('\n');
+            }
+            text.push('\n');
+        }
+
+        text
+    }
+}
+
+impl Paragraph {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Concatenate text runs to produce paragraph text.
+    ///
+    /// In DOCX, whitespace between words is stored inside `<w:t>` elements
+    /// (e.g. `<w:t>Hello </w:t><w:t>World</w:t>`), so runs are joined
+    /// directly without adding extra separators. The parser must use
+    /// `trim_text(false)` to preserve this whitespace.
+    pub fn to_text(&self) -> String {
+        let mut text = String::new();
+        for run in &self.runs {
+            text.push_str(&run.text);
+        }
+        text
+    }
+
+    pub fn add_run(&mut self, run: Run) {
+        self.runs.push(run);
+    }
+}
+
+impl Run {
+    pub fn new(text: String) -> Self {
+        Self {
+            text,
+            ..Default::default()
+        }
+    }
+}
+
+impl Table {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl HeaderFooter {
+    pub fn extract_text(&self) -> String {
+        let mut text = String::new();
+
+        for paragraph in &self.paragraphs {
+            let para_text = paragraph.to_text();
+            if !para_text.is_empty() {
+                text.push_str(&para_text);
+                text.push('\n');
+            }
+        }
+
+        for table in &self.tables {
+            for row in &table.rows {
+                for cell in &row.cells {
+                    for paragraph in &cell.paragraphs {
+                        let para_text = paragraph.to_text();
+                        if !para_text.is_empty() {
+                            text.push_str(&para_text);
+                            text.push('\t');
+                        }
+                    }
+                }
+                text.push('\n');
+            }
+        }
+
+        text
+    }
+}
+
+// --- Parser ---
+
+struct DocxParser<R: Read + Seek> {
+    archive: zip::ZipArchive<R>,
+}
+
+impl<R: Read + Seek> DocxParser<R> {
+    fn new(reader: R) -> Result<Self, DocxParseError> {
+        let archive = zip::ZipArchive::new(reader)?;
+        Ok(Self { archive })
+    }
+
+    fn parse(mut self) -> Result<Document, DocxParseError> {
+        let mut document = Document::new();
+
+        let document_xml = self.read_file("word/document.xml")?;
+        self.parse_document_xml(&document_xml, &mut document)?;
+
+        if let Ok(numbering_xml) = self.read_file("word/numbering.xml") {
+            let numbering_defs = self.parse_numbering(&numbering_xml)?;
+            self.process_lists(&mut document, &numbering_defs);
+        }
+
+        self.parse_headers_footers(&mut document)?;
+
+        if let Ok(footnotes_xml) = self.read_file("word/footnotes.xml") {
+            self.parse_notes(&footnotes_xml, &mut document.footnotes, NoteType::Footnote)?;
+        }
+
+        if let Ok(endnotes_xml) = self.read_file("word/endnotes.xml") {
+            self.parse_notes(&endnotes_xml, &mut document.endnotes, NoteType::Endnote)?;
+        }
+
+        Ok(document)
+    }
+
+    fn read_file(&mut self, path: &str) -> Result<String, DocxParseError> {
+        let mut file = self
+            .archive
+            .by_name(path)
+            .map_err(|_| DocxParseError::FileNotFound(path.to_string()))?;
+
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+        Ok(contents)
+    }
+
+    fn parse_document_xml(&self, xml: &str, document: &mut Document) -> Result<(), DocxParseError> {
+        let mut reader = Reader::from_str(xml);
+        reader.config_mut().trim_text(false);
+
+        let mut buf = Vec::new();
+        let mut current_paragraph: Option<Paragraph> = None;
+        let mut current_run: Option<Run> = None;
+        let mut current_table: Option<Table> = None;
+        let mut current_row: Option<TableRow> = None;
+        let mut current_cell: Option<TableCell> = None;
+        let mut in_text = false;
+        let mut in_table = false;
+
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e)) => match e.name().as_ref() {
+                    b"w:p" => {
+                        if in_table {
+                            if current_cell.is_none() {
+                                current_cell = Some(TableCell::default());
+                            }
+                        } else {
+                            current_paragraph = Some(Paragraph::new());
+                        }
+                    }
+                    b"w:numPr" => {
+                        if let Some(ref mut para) = current_paragraph {
+                            para.numbering_id = Some(1);
+                            para.numbering_level = Some(0);
+                        }
+                    }
+                    b"w:r" => {
+                        current_run = Some(Run::default());
+                    }
+                    b"w:t" => {
+                        in_text = true;
+                    }
+                    b"w:tbl" => {
+                        in_table = true;
+                        current_table = Some(Table::new());
+                    }
+                    b"w:tr" => {
+                        current_row = Some(TableRow::default());
+                    }
+                    b"w:tc" => {
+                        current_cell = Some(TableCell::default());
+                    }
+                    b"w:b" => {
+                        if let Some(ref mut run) = current_run {
+                            run.bold = true;
+                        }
+                    }
+                    b"w:i" => {
+                        if let Some(ref mut run) = current_run {
+                            run.italic = true;
+                        }
+                    }
+                    b"w:u" => {
+                        if let Some(ref mut run) = current_run {
+                            run.underline = true;
+                        }
+                    }
+                    _ => {}
+                },
+                Ok(Event::Text(e)) => {
+                    if in_text {
+                        if let Some(ref mut run) = current_run {
+                            let text = e.decode()?.into_owned();
+                            run.text.push_str(&text);
+                        }
+                    }
+                }
+                Ok(Event::End(ref e)) => match e.name().as_ref() {
+                    b"w:t" => {
+                        in_text = false;
+                    }
+                    b"w:r" => {
+                        if let Some(run) = current_run.take() {
+                            if in_table {
+                                if let Some(ref mut cell) = current_cell {
+                                    if cell.paragraphs.is_empty() {
+                                        cell.paragraphs.push(Paragraph::new());
+                                    }
+                                    if let Some(para) = cell.paragraphs.last_mut() {
+                                        para.add_run(run);
+                                    }
+                                }
+                            } else if let Some(ref mut para) = current_paragraph {
+                                para.add_run(run);
+                            }
+                        }
+                    }
+                    b"w:p" => {
+                        if in_table {
+                            // handled via cell
+                        } else if let Some(para) = current_paragraph.take() {
+                            document.paragraphs.push(para);
+                        }
+                    }
+                    b"w:tc" => {
+                        if let Some(cell) = current_cell.take() {
+                            if let Some(ref mut row) = current_row {
+                                row.cells.push(cell);
+                            }
+                        }
+                    }
+                    b"w:tr" => {
+                        if let Some(row) = current_row.take() {
+                            if let Some(ref mut table) = current_table {
+                                table.rows.push(row);
+                            }
+                        }
+                    }
+                    b"w:tbl" => {
+                        in_table = false;
+                        if let Some(table) = current_table.take() {
+                            document.tables.push(table);
+                        }
+                    }
+                    _ => {}
+                },
+                Ok(Event::Eof) => break,
+                Err(e) => return Err(e.into()),
+                _ => {}
+            }
+            buf.clear();
+        }
+
+        Ok(())
+    }
+
+    fn parse_numbering(&self, xml: &str) -> Result<HashMap<i64, ListType>, DocxParseError> {
+        let mut numbering_defs = HashMap::new();
+        let mut reader = Reader::from_str(xml);
+        reader.config_mut().trim_text(false);
+
+        let mut buf = Vec::new();
+        let mut current_num_id: Option<i64> = None;
+
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e)) => {
+                    if e.name().as_ref() == b"w:num" {
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"w:numId" {
+                                if let Ok(id_str) = std::str::from_utf8(&attr.value) {
+                                    current_num_id = id_str.parse().ok();
+                                }
+                            }
+                        }
+                    }
+                }
+                Ok(Event::End(ref e)) => {
+                    if e.name().as_ref() == b"w:num" {
+                        if let Some(id) = current_num_id {
+                            numbering_defs.insert(id, ListType::Bullet);
+                        }
+                        current_num_id = None;
+                    }
+                }
+                Ok(Event::Eof) => break,
+                _ => {}
+            }
+            buf.clear();
+        }
+
+        Ok(numbering_defs)
+    }
+
+    fn process_lists(&self, document: &mut Document, numbering_defs: &HashMap<i64, ListType>) {
+        for paragraph in &document.paragraphs {
+            if let (Some(num_id), Some(level)) = (paragraph.numbering_id, paragraph.numbering_level) {
+                let list_type = numbering_defs.get(&num_id).cloned().unwrap_or(ListType::Bullet);
+
+                let list_item = ListItem {
+                    level: level as u32,
+                    list_type,
+                    number: None,
+                    text: paragraph.to_text(),
+                };
+
+                document.lists.push(list_item);
+            }
+        }
+    }
+
+    fn parse_headers_footers(&mut self, document: &mut Document) -> Result<(), DocxParseError> {
+        for i in 1..=3 {
+            let header_path = format!("word/header{}.xml", i);
+            if let Ok(header_xml) = self.read_file(&header_path) {
+                let mut header = HeaderFooter::default();
+                self.parse_header_footer_content(&header_xml, &mut header)?;
+                document.headers.push(header);
+            }
+
+            let footer_path = format!("word/footer{}.xml", i);
+            if let Ok(footer_xml) = self.read_file(&footer_path) {
+                let mut footer = HeaderFooter::default();
+                self.parse_header_footer_content(&footer_xml, &mut footer)?;
+                document.footers.push(footer);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn parse_header_footer_content(&self, xml: &str, header_footer: &mut HeaderFooter) -> Result<(), DocxParseError> {
+        let mut reader = Reader::from_str(xml);
+        reader.config_mut().trim_text(false);
+
+        let mut buf = Vec::new();
+        let mut current_paragraph: Option<Paragraph> = None;
+        let mut current_run: Option<Run> = None;
+        let mut in_text = false;
+
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e)) => match e.name().as_ref() {
+                    b"w:p" => current_paragraph = Some(Paragraph::new()),
+                    b"w:r" => current_run = Some(Run::default()),
+                    b"w:t" => in_text = true,
+                    _ => {}
+                },
+                Ok(Event::Text(e)) => {
+                    if in_text {
+                        if let Some(ref mut run) = current_run {
+                            let text = e.decode()?.into_owned();
+                            run.text.push_str(&text);
+                        }
+                    }
+                }
+                Ok(Event::End(ref e)) => match e.name().as_ref() {
+                    b"w:t" => in_text = false,
+                    b"w:r" => {
+                        if let Some(run) = current_run.take() {
+                            if let Some(ref mut para) = current_paragraph {
+                                para.add_run(run);
+                            }
+                        }
+                    }
+                    b"w:p" => {
+                        if let Some(para) = current_paragraph.take() {
+                            header_footer.paragraphs.push(para);
+                        }
+                    }
+                    _ => {}
+                },
+                Ok(Event::Eof) => break,
+                _ => {}
+            }
+            buf.clear();
+        }
+
+        Ok(())
+    }
+
+    fn parse_notes(&self, xml: &str, notes: &mut Vec<Note>, note_type: NoteType) -> Result<(), DocxParseError> {
+        let mut reader = Reader::from_str(xml);
+        reader.config_mut().trim_text(false);
+
+        let mut buf = Vec::new();
+        let mut current_note: Option<Note> = None;
+        let mut current_paragraph: Option<Paragraph> = None;
+        let mut current_run: Option<Run> = None;
+        let mut in_text = false;
+
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(ref e)) => match e.name().as_ref() {
+                    b"w:footnote" | b"w:endnote" => {
+                        let mut id = String::new();
+                        for attr in e.attributes().flatten() {
+                            if attr.key.as_ref() == b"w:id" {
+                                id = String::from_utf8_lossy(&attr.value).to_string();
+                            }
+                        }
+                        current_note = Some(Note {
+                            id,
+                            note_type: note_type.clone(),
+                            paragraphs: Vec::new(),
+                        });
+                    }
+                    b"w:p" => current_paragraph = Some(Paragraph::new()),
+                    b"w:r" => current_run = Some(Run::default()),
+                    b"w:t" => in_text = true,
+                    _ => {}
+                },
+                Ok(Event::Text(e)) => {
+                    if in_text {
+                        if let Some(ref mut run) = current_run {
+                            let text = e.decode()?.into_owned();
+                            run.text.push_str(&text);
+                        }
+                    }
+                }
+                Ok(Event::End(ref e)) => match e.name().as_ref() {
+                    b"w:t" => in_text = false,
+                    b"w:r" => {
+                        if let Some(run) = current_run.take() {
+                            if let Some(ref mut para) = current_paragraph {
+                                para.add_run(run);
+                            }
+                        }
+                    }
+                    b"w:p" => {
+                        if let Some(para) = current_paragraph.take() {
+                            if let Some(ref mut note) = current_note {
+                                note.paragraphs.push(para);
+                            }
+                        }
+                    }
+                    b"w:footnote" | b"w:endnote" => {
+                        if let Some(note) = current_note.take() {
+                            if note.id != "-1" && note.id != "0" {
+                                notes.push(note);
+                            }
+                        }
+                    }
+                    _ => {}
+                },
+                Ok(Event::Eof) => break,
+                _ => {}
+            }
+            buf.clear();
+        }
+
+        Ok(())
+    }
+}
+
+// --- Error ---
+
+#[derive(Debug, thiserror::Error)]
+enum DocxParseError {
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("ZIP error: {0}")]
+    Zip(#[from] zip::result::ZipError),
+
+    #[error("XML parsing error: {0}")]
+    Xml(#[from] quick_xml::Error),
+
+    #[error("Required file not found in DOCX: {0}")]
+    FileNotFound(String),
+}
+
+// quick-xml's unescape returns an encoding error type
+impl From<quick_xml::encoding::EncodingError> for DocxParseError {
+    fn from(e: quick_xml::encoding::EncodingError) -> Self {
+        DocxParseError::Xml(quick_xml::Error::Encoding(e))
+    }
+}
+
+// --- Public API ---
+
+/// Parse a DOCX document from bytes and return the structured document.
+pub fn parse_document(bytes: &[u8]) -> crate::error::Result<Document> {
+    let cursor = Cursor::new(bytes);
+    let parser = DocxParser::new(cursor)
+        .map_err(|e| crate::error::KreuzbergError::parsing(format!("DOCX parsing failed: {}", e)))?;
+    parser
+        .parse()
+        .map_err(|e| crate::error::KreuzbergError::parsing(format!("DOCX parsing failed: {}", e)))
+}
+
+/// Extract text from DOCX bytes.
+pub fn extract_text_from_bytes(bytes: &[u8]) -> crate::error::Result<String> {
+    let doc = parse_document(bytes)?;
+    Ok(doc.extract_text())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Runs are concatenated directly; whitespace comes from the XML text content.
+    #[test]
+    fn test_paragraph_to_text_concatenates_runs() {
+        let mut para = Paragraph::new();
+        para.add_run(Run::new("Hello ".to_string()));
+        para.add_run(Run::new("World".to_string()));
+        assert_eq!(para.to_text(), "Hello World");
+    }
+
+    /// Mid-word run splits (e.g. drop caps) must not insert extra spaces.
+    #[test]
+    fn test_paragraph_to_text_mid_word_split() {
+        let mut para = Paragraph::new();
+        para.add_run(Run::new("S".to_string()));
+        para.add_run(Run::new("ermocination".to_string()));
+        assert_eq!(para.to_text(), "Sermocination");
+    }
+
+    #[test]
+    fn test_paragraph_to_text_single_run() {
+        let mut para = Paragraph::new();
+        para.add_run(Run::new("Hello".to_string()));
+        assert_eq!(para.to_text(), "Hello");
+    }
+
+    #[test]
+    fn test_paragraph_to_text_no_runs() {
+        let para = Paragraph::new();
+        assert_eq!(para.to_text(), "");
+    }
+
+    /// Whitespace between words is stored in the run text, not added by join.
+    #[test]
+    fn test_paragraph_to_text_whitespace_in_runs() {
+        let mut para = Paragraph::new();
+        para.add_run(Run::new("The ".to_string()));
+        para.add_run(Run::new("quick ".to_string()));
+        para.add_run(Run::new("fox".to_string()));
+        assert_eq!(para.to_text(), "The quick fox");
+    }
+}

data/vendor/kreuzberg/src/extraction/transform/mod.rs

@@ -253,6 +253,7 @@ mod tests {
             image_preprocessing: None,
             json_schema: None,
             error: None,
+            extraction_duration_ms: None,
             additional: Default::default(),
         }
     }

data/vendor/kreuzberg/src/extractors/docx.rs

@@ -1,6 +1,6 @@
 #![cfg(all(feature = "tokio-runtime", feature = "office"))]
 
-//! DOCX extractor using docx-lite for high-performance text extraction.
+//! DOCX extractor for high-performance text extraction.
 //!
 //! Supports: Microsoft Word (.docx)
 
@@ -14,10 +14,10 @@ use async_trait::async_trait;
 use std::borrow::Cow;
 use std::io::Cursor;
 
-/// High-performance DOCX extractor using docx-lite.
+/// High-performance DOCX extractor.
 ///
 /// This extractor provides:
-/// - Fast text extraction via streaming XML parsing (~160 MB/s average)
+/// - Fast text extraction via streaming XML parsing
 /// - Comprehensive metadata extraction (core.xml, app.xml, custom.xml)
 pub struct DocxExtractor;
 
@@ -52,7 +52,7 @@ impl Plugin for DocxExtractor {
     }
 
     fn description(&self) -> &str {
-        "High-performance DOCX text extraction using docx-lite with metadata support"
+        "High-performance DOCX text extraction with metadata support"
     }
 
     fn author(&self) -> &str {
@@ -60,15 +60,15 @@ impl Plugin for DocxExtractor {
     }
 }
 
-/// Convert docx-lite table to Kreuzberg Table struct with markdown representation.
+/// Convert parsed DOCX table to Kreuzberg Table struct with markdown representation.
 ///
 /// # Arguments
-/// * `docx_table` - The table from docx-lite library
+/// * `docx_table` - The parsed DOCX table
 /// * `table_index` - Index of the table in the document (used as page_number)
 ///
 /// # Returns
 /// * `Table` - Converted table with cells and markdown representation
-fn convert_docx_table_to_table(docx_table: &docx_lite::Table, table_index: usize) -> Table {
+fn convert_docx_table_to_table(docx_table: &crate::extraction::docx::parser::Table, table_index: usize) -> Table {
     let cells: Vec<Vec<String>> = docx_table
         .rows
         .iter()
@@ -97,14 +97,6 @@ fn convert_docx_table_to_table(docx_table: &docx_lite::Table, table_index: usize
     }
 }
 
-/// Convert 2D cell data to markdown table format.
-///
-/// # Arguments
-/// * `cells` - 2D vector of cell strings (rows × columns)
-///
-/// # Returns
-/// * `String` - Markdown formatted table
-
 #[async_trait]
 impl DocumentExtractor for DocxExtractor {
     #[cfg_attr(feature = "otel", tracing::instrument(
@@ -126,9 +118,7 @@ impl DocumentExtractor for DocxExtractor {
             tokio::task::spawn_blocking(
                 move || -> crate::error::Result<(String, Vec<Table>, Option<Vec<PageBoundary>>)> {
                     let _guard = span.entered();
-                    let cursor = Cursor::new(&content_owned);
-                    let doc = docx_lite::parse_document(cursor)
-                        .map_err(|e| crate::error::KreuzbergError::parsing(format!("DOCX parsing failed: {}", e)))?;
+                    let doc = crate::extraction::docx::parser::parse_document(&content_owned)?;
 
                     let text = doc.extract_text();
 
@@ -147,9 +137,7 @@ impl DocumentExtractor for DocxExtractor {
             .await
             .map_err(|e| crate::error::KreuzbergError::parsing(format!("DOCX extraction task failed: {}", e)))??
         } else {
-            let cursor = Cursor::new(content);
-            let doc = docx_lite::parse_document(cursor)
-                .map_err(|e| crate::error::KreuzbergError::parsing(format!("DOCX parsing failed: {}", e)))?;
+            let doc = crate::extraction::docx::parser::parse_document(content)?;
 
             let text = doc.extract_text();
 
@@ -373,7 +361,7 @@ mod tests {
 
     #[test]
     fn test_convert_docx_table_to_table() {
-        use docx_lite::{Paragraph, Run, Table as DocxTable, TableCell, TableRow};
+        use crate::extraction::docx::parser::{Paragraph, Run, Table as DocxTable, TableCell, TableRow};
 
         let mut table = DocxTable::new();
 

data/vendor/kreuzberg/src/types/metadata.rs

@@ -132,6 +132,13 @@ pub struct Metadata {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub error: Option<ErrorMetadata>,
 
+    /// Extraction duration in milliseconds (for benchmarking).
+    ///
+    /// This field is populated by batch extraction to provide per-file timing
+    /// information. It's `None` for single-file extraction (which uses external timing).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extraction_duration_ms: Option<u64>,
+
     /// Additional custom fields from postprocessors.
     ///
     /// This flattened map allows Python/TypeScript postprocessors to add

data/vendor/kreuzberg/tests/api_embed.rs

@@ -83,6 +83,7 @@ async fn test_embed_empty_texts() {
 
 /// Test embed endpoint with custom embedding configuration.
 #[tokio::test]
+#[cfg_attr(target_arch = "aarch64", ignore = "ONNX Runtime model loading unstable on ARM")]
 async fn test_embed_with_custom_config() {
     let app = create_router(ExtractionConfig::default());
 
@@ -125,6 +126,7 @@ async fn test_embed_with_custom_config() {
 
 /// Test embed endpoint with single text.
 #[tokio::test]
+#[cfg_attr(target_arch = "aarch64", ignore = "ONNX Runtime model loading unstable on ARM")]
 async fn test_embed_single_text() {
     let app = create_router(ExtractionConfig::default());
 
@@ -201,6 +203,7 @@ async fn test_embed_batch() {
 
 /// Test embed endpoint with long text.
 #[tokio::test]
+#[cfg_attr(target_arch = "aarch64", ignore = "ONNX Runtime model loading unstable on ARM")]
 async fn test_embed_long_text() {
     let app = create_router(ExtractionConfig::default());
 
@@ -317,6 +320,7 @@ async fn test_embed_rejects_simple_json_array() {
 
 /// Test embed endpoint preserves embedding vector values across calls.
 #[tokio::test]
+#[cfg_attr(target_arch = "aarch64", ignore = "ONNX Runtime model loading unstable on ARM")]
 async fn test_embed_deterministic() {
     let app = create_router(ExtractionConfig::default());
 
@@ -376,6 +380,7 @@ async fn test_embed_deterministic() {
 
 /// Test embed endpoint with different embedding presets.
 #[tokio::test]
+#[cfg_attr(target_arch = "aarch64", ignore = "ONNX Runtime model loading unstable on ARM")]
 async fn test_embed_different_presets() {
     let app = create_router(ExtractionConfig::default());
 

data/vendor/kreuzberg/tests/issue_359_list_whitespace_test.rs

@@ -0,0 +1,33 @@
+//! Regression test for https://github.com/kreuzberg-dev/kreuzberg/issues/359
+//!
+//! DOCX list items with multiple text runs should preserve whitespace between runs.
+//! e.g. "Sermocination ypsiliform" must not become "Sermocinationypsiliform".
+
+#![cfg(feature = "office")]
+
+use kreuzberg::{ExtractionConfig, extract_file};
+
+#[tokio::test]
+async fn test_issue_359_docx_list_run_whitespace() {
+    let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("parent")
+        .parent()
+        .expect("workspace root");
+    let test_file = workspace_root.join("test_documents/docx/issue_359_list_whitespace.docx");
+
+    if !test_file.exists() {
+        println!("Skipping test: {:?} not found", test_file);
+        return;
+    }
+
+    let result = extract_file(&test_file, None, &ExtractionConfig::default())
+        .await
+        .expect("Should extract DOCX successfully");
+
+    assert!(
+        result.content.contains("Sermocination ypsiliform"),
+        "Expected 'Sermocination ypsiliform' with space between runs, got: {:?}",
+        result.content
+    );
+}

data/vendor/kreuzberg-tesseract/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kreuzberg-tesseract"
-version = "4.2.10"
+version = "4.2.12"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -26,7 +26,7 @@ image = { workspace = true, features = ["png"] }
 [build-dependencies]
 cc = { version = "^1.2.55", optional = true }
 cmake = { version = "0.1.57", optional = true }
-zip = { version = "7.2.0", optional = true }
+zip = { version = "7.4.0", optional = true }
 
 # Use native-tls on Windows to avoid aws-lc-sys CMake build issues with MinGW
 [target.'cfg(target_os = "windows")'.build-dependencies]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kreuzberg
 version: !ruby/object:Gem::Version
-  version: 4.2.10
+  version: 4.2.12
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 2026-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -427,7 +427,8 @@ files:
 - vendor/kreuzberg/src/extraction/archive/tar.rs
 - vendor/kreuzberg/src/extraction/archive/zip.rs
 - vendor/kreuzberg/src/extraction/capacity.rs
-- vendor/kreuzberg/src/extraction/docx.rs
+- vendor/kreuzberg/src/extraction/docx/mod.rs
+- vendor/kreuzberg/src/extraction/docx/parser.rs
 - vendor/kreuzberg/src/extraction/email.rs
 - vendor/kreuzberg/src/extraction/excel.rs
 - vendor/kreuzberg/src/extraction/html/converter.rs
@@ -745,6 +746,7 @@ files:
 - vendor/kreuzberg/tests/image_integration.rs
 - vendor/kreuzberg/tests/instrumentation_test.rs
 - vendor/kreuzberg/tests/issue_350_regression_test.rs
+- vendor/kreuzberg/tests/issue_359_list_whitespace_test.rs
 - vendor/kreuzberg/tests/jats_extractor_tests.rs
 - vendor/kreuzberg/tests/jupyter_extractor_tests.rs
 - vendor/kreuzberg/tests/keywords_integration.rs