docling-rs 2.2.0__tar.gz → 2.2.2__tar.gz

{docling_rs-2.2.0 → docling_rs-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-rs
-Version: 2.2.0
+Version: 2.2.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling"
 description = "DocumentConverter and format backends for docling.rs (a Rust port of docling)."
-version = "2.2.0"
+version = "2.2.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -79,9 +79,9 @@ headless_chrome = { version = "1.0", optional = true }
 # O_EXCL temp file with an unpredictable name for the browser pre-render page
 # (avoids a predictable /tmp path a local attacker could pre-plant a symlink at).
 tempfile = { version = "3", optional = true }
-docling-asr = { path = "../docling-asr", version = "2.2.0", optional = true }
-docling-core = { path = "../docling-core", version = "2.2.0" }
-docling-pdf = { path = "../docling-pdf", version = "2.2.0", optional = true, default-features = false }
+docling-asr = { path = "../docling-asr", version = "2.2.2", optional = true }
+docling-core = { path = "../docling-core", version = "2.2.2" }
+docling-pdf = { path = "../docling-pdf", version = "2.2.2", optional = true, default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "gif", "bmp", "tiff", "webp"] }
 mail-parser = "0.11"
 pulldown-cmark = { version = "0.13.4", default-features = false }

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling/src/error.rs

@@ -81,7 +81,14 @@ impl fmt::Display for ConversionError {
             ConversionError::Panic(msg) => write!(f, "conversion panicked: {msg}"),
             ConversionError::Timeout(msg) => write!(f, "document timeout: {msg}"),
             ConversionError::WithSource { context, source } => {
-                write!(f, "parse error: {context}: {source}")
+                // A source that already names its format (`PdfError`'s
+                // `pdf: …`) is not prefixed twice (`pdf: pdf: …`).
+                let msg = source.to_string();
+                if msg.starts_with(&format!("{context}: ")) {
+                    write!(f, "parse error: {msg}")
+                } else {
+                    write!(f, "parse error: {context}: {msg}")
+                }
             }
         }
     }
@@ -121,6 +128,22 @@ mod tests {
         );
     }
 
+    /// A source whose message already names the context is not prefixed
+    /// with it again (`parse error: pdf: pdf: …`).
+    #[test]
+    fn with_source_does_not_repeat_the_context() {
+        let cause = std::io::Error::other("pdf: not a readable PDF");
+        assert_eq!(
+            ConversionError::with_source("pdf", cause).to_string(),
+            "parse error: pdf: not a readable PDF"
+        );
+        let cause = std::io::Error::other("bad header");
+        assert_eq!(
+            ConversionError::with_source("pdf", cause).to_string(),
+            "parse error: pdf: bad header"
+        );
+    }
+
     #[test]
     fn stringly_variants_have_no_source() {
         assert!(ConversionError::Parse("x".into()).source().is_none());

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-asr/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-asr"
 description = "Audio/ASR pipeline for docling.rs (Whisper via ONNX; a Rust port of docling's ASR pipeline)."
-version = "2.2.0"
+version = "2.2.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -25,10 +25,10 @@ xnnpack = ["docling-onnx/xnnpack"]
 ort-load-dynamic = ["docling-onnx/load-dynamic", "ort/load-dynamic"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.0" }
+docling-core = { path = "../docling-core", version = "2.2.2" }
 # Shared ONNX execution-provider selection (DOCLING_RS_EP, #288) — routes the
 # Whisper encoder/decoder sessions through the same switch as docling-pdf.
-docling-onnx = { path = "../docling-onnx", version = "2.2.0" }
+docling-onnx = { path = "../docling-onnx", version = "2.2.2" }
 # Same ort as docling-pdf so the workspace keeps a single ONNX runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }
 serde_json = "1"

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-core"
 description = "Core DoclingDocument data model and serializers for docling.rs (a Rust port of docling)."
-version = "2.2.0"
+version = "2.2.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/chunker.rs

@@ -471,6 +471,7 @@ impl Walker<'_> {
                 let self_ref = self.alloc.text();
                 self.emit_inline(text, self_ref);
             }
+            Node::LabeledText { .. } => self.one(&node.labeled_as_paragraph()),
             Node::CheckboxItem { checked, text } => {
                 let self_ref = self.alloc.text();
                 let mark = if *checked { "- [x] " } else { "- [ ] " };
@@ -1120,6 +1121,7 @@ fn cell_chunk_text(t: &Table, r: usize, c: usize) -> String {
 fn block_chunk_text(node: &Node) -> String {
     match node {
         Node::Paragraph { text } => unescape_text(text),
+        Node::LabeledText { .. } => block_chunk_text(&node.labeled_as_paragraph()),
         Node::InlineGroup { md_text, .. } => unescape_text(md_text),
         Node::Code { text, .. } => format!("```\n{}\n```", unescape_text(text)),
         Node::Table(inner) => triplet_table_text(inner),

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/doclang.rs

@@ -901,6 +901,17 @@ fn emit_nodes(out: &mut Out, depth: i32, nodes: &[Node], i: &mut usize, level: u
                 emit_caption(out, depth, text, href.as_deref());
                 *i += 1;
             }
+            Node::LabeledText { .. } => {
+                let para = nodes[*i].labeled_as_paragraph();
+                emit_nodes(
+                    out,
+                    depth,
+                    std::slice::from_ref(para.as_ref()),
+                    &mut 0,
+                    level,
+                );
+                *i += 1;
+            }
             Node::CheckboxItem { checked, text } => {
                 // A `<text>` with a `<checkbox class="selected|unselected"/>` head
                 // element and the label text child (block form).
@@ -1722,6 +1733,9 @@ fn emit_located(out: &mut Out, depth: i32, location: &[u16; 4], inner: &Node) {
         Node::Paragraph { text } => {
             emit_text_element(out, depth, "text", "text", text, Some(location));
         }
+        Node::LabeledText { .. } => {
+            emit_located(out, depth, location, &inner.labeled_as_paragraph())
+        }
         Node::Picture {
             caption,
             caption_href,

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/document.rs

@@ -173,6 +173,18 @@ pub enum Node {
     /// renders it as `[text](href)`, JSON puts `hyperlink` on the caption
     /// item, DocLang emits the block-form `<caption>` with an `<href>` head.
     Caption { text: String, href: Option<String> },
+    /// A body text item with a docling label of its own and an optional
+    /// hyperlink — the PDF pipeline's `footnote` regions, whose item docling
+    /// keeps as a `footnote` text with the link annotation covering it as its
+    /// `hyperlink` (`PageAssembleModel._match_hyperlink`). The JSON writes
+    /// exactly that (label, raw text, `hyperlink`); every other serializer
+    /// renders it as the paragraph [`Self::labeled_markdown`] spells —
+    /// docling's Markdown wraps a linked item's whole text, `[text](uri)`.
+    LabeledText {
+        label: String,
+        text: String,
+        href: Option<String>,
+    },
     /// A chart (docling's `PictureItem` classified as a chart, carrying a
     /// `PictureTabularChartData` annotation). Markdown and JSON render it exactly
     /// like a [`Node::Picture`] placeholder (an `<!-- image -->` / `picture`
@@ -658,6 +670,23 @@ pub struct ListItemDclx {
     pub runs: Vec<InlineRun>,
 }
 
+impl Node {
+    /// The paragraph a [`Node::LabeledText`] renders as outside the JSON:
+    /// its text, wrapped as `[text](uri)` when it carries a hyperlink. Any
+    /// other node is returned unchanged.
+    pub fn labeled_as_paragraph(&self) -> std::borrow::Cow<'_, Node> {
+        match self {
+            Node::LabeledText { text, href, .. } => std::borrow::Cow::Owned(Node::Paragraph {
+                text: match href {
+                    Some(uri) => format!("[{text}]({uri})"),
+                    None => text.clone(),
+                },
+            }),
+            other => std::borrow::Cow::Borrowed(other),
+        }
+    }
+}
+
 impl InlineRun {
     /// A run with no active formatting (renders as bare inline text).
     pub fn is_plain(&self) -> bool {

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/json.rs

@@ -1103,6 +1103,15 @@ impl Builder {
                 };
                 Some(self.add_text("caption", text, parent, extra))
             }
+            // A PDF footnote: docling's own label, and its link as the item's
+            // `hyperlink` rather than Markdown baked into the text.
+            Node::LabeledText { label, text, href } => {
+                let extra = match href {
+                    Some(url) => json!({ "hyperlink": url }),
+                    None => json!({}),
+                };
+                Some(self.add_text(label, text, parent, extra))
+            }
             Node::Paragraph { text } => {
                 // A whole-paragraph display equation is a formula item (docling
                 // wraps it in `$$…$$` and, unlike a text item, never escapes it).
@@ -3624,4 +3633,39 @@ mod tests {
         assert_eq!(v["pictures"][0]["children"], serde_json::json!([]));
         assert_eq!(v["tables"][0]["children"], serde_json::json!([]));
     }
+
+    /// A PDF footnote (#620 follow-up): the JSON keeps docling's
+    /// `footnote` label, the raw text and the link as `hyperlink`; the
+    /// Markdown still wraps the whole item as `[text](uri)`, and the plain
+    /// text drops the link like docling-core's `export_to_text`.
+    #[test]
+    fn a_labeled_text_keeps_its_label_and_hyperlink_out_of_the_text() {
+        let mut doc = DoclingDocument::new("t");
+        doc.push(Node::LabeledText {
+            label: "footnote".into(),
+            text: "1 https://example.com/a\\_b".into(),
+            href: Some("https://example.com/a_b".into()),
+        });
+        doc.push(Node::LabeledText {
+            label: "footnote".into(),
+            text: "© 2022 the authors".into(),
+            href: None,
+        });
+        let v: Value = serde_json::from_str(&doc.export_to_json()).unwrap();
+        let t = &v["texts"][0];
+        assert_eq!(t["label"], "footnote");
+        assert_eq!(t["text"], "1 https://example.com/a_b");
+        assert_eq!(t["orig"], "1 https://example.com/a_b");
+        assert_eq!(t["hyperlink"], "https://example.com/a_b");
+        assert_eq!(v["texts"][1]["label"], "footnote");
+        assert!(v["texts"][1].get("hyperlink").is_none());
+        assert_eq!(
+            doc.export_to_markdown(),
+            "[1 https://example.com/a\\_b](https://example.com/a_b)\n\n© 2022 the authors\n"
+        );
+        assert_eq!(
+            doc.export_to_text(),
+            "1 https://example.com/a_b\n\n© 2022 the authors"
+        );
+    }
 }

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/latex.rs

@@ -458,6 +458,9 @@ fn render_one(node: &Node, list_level: usize, inline: bool, parts: &mut Vec<Stri
         }
         // A standalone caption item is a text item to the LaTeX serializer.
         Node::Caption { text, .. } => push(parts, inline_md(text)),
+        Node::LabeledText { .. } => {
+            render_one(&node.labeled_as_paragraph(), list_level, inline, parts)
+        }
         Node::Paragraph { text } => {
             // A whole-paragraph `$$…$$` is a formula item in the JSON — never
             // escaped, re-wrapped by the serializer.

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-core/src/markdown.rs

@@ -959,6 +959,7 @@ fn render_item(node: &Node, blocks: &mut Vec<String>, ctx: &mut Ctx) {
         // nothing to Markdown — only DocLang/JSON keep it.
         Node::Paragraph { text } if text.is_empty() => {}
         Node::Paragraph { text } => blocks.push(ctx.breaks(&ctx.text(text))),
+        Node::LabeledText { .. } => render_item(&node.labeled_as_paragraph(), blocks, ctx),
         // A standalone caption item renders like a text item; its hyperlink
         // annotation becomes a Markdown link around the whole caption.
         Node::Caption { text, .. } if text.is_empty() => {}

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-onnx/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-onnx"
 description = "Shared ONNX Runtime execution-provider selection for docling.rs (DOCLING_RS_EP)."
-version = "2.2.0"
+version = "2.2.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -41,7 +41,7 @@ xnnpack = ["ort/xnnpack"]
 load-dynamic = ["ort/load-dynamic", "dep:libloading"]
 
 [dependencies]
-docling-core = { path = "../docling-core", version = "2.2.0" }
+docling-core = { path = "../docling-core", version = "2.2.2" }
 # Same ort build as docling-pdf/docling-asr so the workspace keeps a single
 # ONNX Runtime.
 ort = { version = "2.0.0-rc.13", default-features = false, features = ["std", "download-binaries", "tls-rustls"] }

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-pdf/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "docling-pdf"
 description = "PDF/image backend for docling.rs: pure-Rust text layer and page renderer + ONNX layout/table/OCR pipeline."
-version = "2.2.0"
+version = "2.2.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/docling-project/docling.rs"
@@ -71,10 +71,10 @@ ort-load-dynamic = ["ml", "docling-onnx/load-dynamic", "ort/load-dynamic"]
 # what current LTS distros ship (Ubuntu 24.04 = 1.17). Newer libheif-rs
 # requires libheif >= 1.18 and can be selected once baselines move.
 libheif-rs = { version = "~1.0", default-features = false, optional = true }
-docling-core = { path = "../docling-core", version = "2.2.0" }
+docling-core = { path = "../docling-core", version = "2.2.2" }
 # Shared ONNX execution-provider selection (DOCLING_RS_EP, #74/#288);
 # re-exported as `docling_pdf::ep`.
-docling-onnx = { path = "../docling-onnx", version = "2.2.0", optional = true }
+docling-onnx = { path = "../docling-onnx", version = "2.2.2", optional = true }
 pdfium-render = { version = "0.8", optional = true }
 # Runtime loading of the opt-in docling-parse renderer plugin (#478,
 # `dparse_render.rs`) — the same mechanism pdfium-render uses for libpdfium.

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-pdf/src/assemble.rs

@@ -3516,18 +3516,27 @@ pub fn assemble_page(
                 let hyperlink = (region.label == "footnote")
                     .then(|| region_hyperlink(region, &page.links))
                     .flatten();
-                let text = match hyperlink {
-                    Some(uri) => {
-                        // The strict-mode anchor pairs this item covers are
-                        // superseded by the baked whole-item link.
-                        links.retain(|(anchor, href)| {
-                            !(href == &uri && region_texts[i].contains(anchor.as_str()))
-                        });
-                        format!("[{escaped}]({uri})")
+                if let Some(uri) = &hyperlink {
+                    // The strict-mode anchor pairs this item covers are
+                    // superseded by the whole-item link.
+                    links.retain(|(anchor, href)| {
+                        !(href == uri && region_texts[i].contains(anchor.as_str()))
+                    });
+                }
+                // A footnote keeps docling's label and carries its link as
+                // the item's `hyperlink` (the JSON's `text` stays the raw
+                // footnote, not Markdown); every other serializer renders it
+                // as the `[text](uri)` paragraph it was before.
+                let node = if region.label == "footnote" {
+                    Node::LabeledText {
+                        label: "footnote".into(),
+                        text: escaped,
+                        href: hyperlink,
                     }
-                    None => escaped,
+                } else {
+                    Node::Paragraph { text: escaped }
                 };
-                nodes.push(located(loc, Node::Paragraph { text }))
+                nodes.push(located(loc, node))
             }
         }
     }
@@ -3711,9 +3720,22 @@ fn is_merge_trailer(n: &Node) -> bool {
                 | Node::PictureChildren(_)
         )
         || matches!(n, Node::Located { inner, .. } if matches!(inner.as_ref(), Node::Table(_)))
+        || is_footnote_node(n)
         || as_paragraph(n).is_some_and(looks_like_caption)
 }
 
+/// Whether a node is a footnote item (a [`Node::LabeledText`] labelled
+/// `footnote`), looking through a [`Node::Located`] wrapper — one of
+/// docling's merge skip-labels: a footnote between the two halves of a
+/// paragraph is looked past, never merged into.
+fn is_footnote_node(n: &Node) -> bool {
+    let n = match n {
+        Node::Located { inner, .. } => inner.as_ref(),
+        other => other,
+    };
+    matches!(n, Node::LabeledText { label, .. } if label == "footnote")
+}
+
 /// Rebuild node `i` as a paragraph with `text`, preserving its `<location>`
 /// wrapper (and thus provenance) if it had one.
 fn reparagraph(node: &Node, text: String) -> Node {

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-pdf/src/lib.rs

@@ -263,6 +263,12 @@ pub fn convert_text_layer(bytes: &[u8], name: &str) -> Result<DoclingDocument, P
     convert_text_layer_pages(bytes, name, None)
 }
 
+/// The error for bytes no reader here can parse as a PDF — not a PDF at
+/// all, or one damaged past the parser's repairs. Said about the file, not
+/// about a missing renderer or text layer: no library would read it either.
+pub(crate) const UNREADABLE: &str =
+    "not a readable PDF: the file is damaged or not a PDF (its structure could not be parsed)";
+
 /// [`convert_text_layer`] restricted to a **1-based inclusive** page window
 /// (issue #80's `--pages`); `None` converts everything. The window is
 /// validated the same way as [`Pipeline::pages`]: `first <= last`, 1-based,
@@ -282,6 +288,11 @@ pub fn convert_text_layer_pages(
     let mut doc = DoclingDocument::new(name);
     let mut total = 0usize;
     let parsed = textparse::pdf_text_pages(bytes);
+    // No pages at all: tell a file nothing can open apart from a PDF that
+    // merely has no text layer (the caller's "scanned? needs OCR" hint).
+    if parsed.is_empty() && textparse::load_document(bytes).is_none() {
+        return Err(PdfError::Document(UNREADABLE.into()));
+    }
     // A vestigial layer (a few typed-in form fields over scanned pages) is not
     // the document's text: return the empty document, which callers already
     // report as "no text layer" — so an OCR-capable caller falls back to OCR
@@ -3499,6 +3510,29 @@ mod median_tests {
     }
 }
 
+#[cfg(test)]
+mod unreadable_tests {
+    /// The text-layer path (the wasm build's only one) tells a file nothing
+    /// can open apart from a PDF that merely has no text layer: garbage is
+    /// an error about the file, a real PDF converts.
+    #[test]
+    fn text_layer_path_reports_an_unreadable_file() {
+        for bytes in [b"garbage".as_slice(), b"", b"%PDF-1.7\n%%EOF\n"] {
+            let err = super::convert_text_layer(bytes, "x.pdf").unwrap_err();
+            assert!(err.to_string().contains("not a readable PDF"), "{err}");
+        }
+        let real = std::fs::read(
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../tests/data/pdf/sources/multi_page.pdf"),
+        )
+        .unwrap();
+        assert!(!super::convert_text_layer(&real, "multi_page.pdf")
+            .unwrap()
+            .nodes
+            .is_empty());
+    }
+}
+
 #[cfg(test)]
 mod send_check {
     /// The Node bindings (`docling-node`) run a shared [`super::Pipeline`] on

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-pdf/src/pdfium_backend.rs

@@ -1302,10 +1302,12 @@ mod native {
     pub(super) struct Session<'a>(Infallible, PhantomData<&'a ()>);
     pub(super) struct Page<'a>(Infallible, PhantomData<&'a ()>);
 
+    /// Reached only for a file the pure-Rust object model could not read
+    /// (every entry point tries it first), so the error is about the file:
+    /// naming the missing library sent users of a corrupt or non-PDF upload
+    /// looking for a pdfium install that would not have helped either.
     pub(super) fn bind() -> Result<Lib, PdfError> {
-        Err(PdfError::Document(
-            "pdfium support is not compiled in (docling-pdf feature `pdfium`)".into(),
-        ))
+        Err(PdfError::Document(crate::UNREADABLE.into()))
     }
 
     impl Lib {

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-pdf/tests/text_layer.rs

@@ -89,10 +89,19 @@ fn scanned_page_extracts_table_and_keeps_chart() {
 
 #[test]
 fn scanned_pdf_yields_empty_document() {
-    // No content stream at all — the no-text-layer contract is an empty doc,
-    // not an error (callers decide whether to fall back to OCR).
-    let doc = docling_pdf::convert_text_layer(b"%PDF-1.4\n%%EOF", "scan.pdf").expect("no error");
+    // An image-only page — the no-text-layer contract is an empty doc, not
+    // an error (callers decide whether to fall back to OCR).
+    let scan = std::fs::read(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../tests/data/scanned/sources/ocr_test_raster.pdf"),
+    )
+    .unwrap();
+    let doc = docling_pdf::convert_text_layer(&scan, "scan.pdf").expect("no error");
     assert!(doc.nodes.is_empty());
+    // Bytes that are no readable PDF at all are an error about the file,
+    // not an empty "scanned" document.
+    let err = docling_pdf::convert_text_layer(b"%PDF-1.4\n%%EOF", "x.pdf").unwrap_err();
+    assert!(err.to_string().contains("not a readable PDF"), "{err}");
 }
 
 /// #211: HEIC is detected by content, and without the `heif` feature the

{docling_rs-2.2.0 → docling_rs-2.2.2}/docling-py/Cargo.lock

@@ -764,7 +764,7 @@ dependencies = [
 
 [[package]]
 name = "docling"
-version = "2.2.0"
+version = "2.2.2"
 dependencies = [
  "calamine",
  "csv",
@@ -794,7 +794,7 @@ dependencies = [
 
 [[package]]
 name = "docling-asr"
-version = "2.2.0"
+version = "2.2.2"
 dependencies = [
  "docling-core",
  "docling-onnx",
@@ -805,7 +805,7 @@ dependencies = [
 
 [[package]]
 name = "docling-core"
-version = "2.2.0"
+version = "2.2.2"
 dependencies = [
  "png 0.18.1",
  "pulldown-cmark",
@@ -816,7 +816,7 @@ dependencies = [
 
 [[package]]
 name = "docling-onnx"
-version = "2.2.0"
+version = "2.2.2"
 dependencies = [
  "docling-core",
  "libloading 0.8.9",
@@ -825,7 +825,7 @@ dependencies = [
 
 [[package]]
 name = "docling-pdf"
-version = "2.2.0"
+version = "2.2.2"
 dependencies = [
  "docling-core",
  "docling-onnx",

{docling_rs-2.2.0 → docling_rs-2.2.2}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "maturin"
 name = "docling-rs"
 # Fallback for local maturin builds — pypi-publish.yml overwrites this with the
 # workspace version (root Cargo.toml) on every release.
-version = "2.2.0"
+version = "2.2.2"
 description = "Rust port of docling (docling.rs): convert PDF/DOCX/HTML/... to Markdown or docling JSON. Python bindings."
 readme = "README.md"
 license = { text = "MIT" }