docling-parse 7.23.0__tar.gz → 7.24.0__tar.gz

{docling_parse-7.23.0 → docling_parse-7.24.0}/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [v7.24.0](https://github.com/docling-project/docling-parse/releases/tag/v7.24.0) - 2026-10-27
+
+### Feature
+
+* Report why a document failed to load, so a password is told from a damaged file ([#414](https://github.com/docling-project/docling-parse/issues/414)) ([`3317576`](https://github.com/docling-project/docling-parse/commit/33175762f5324d987e4d8bb01f191900c96a5cc2))
+
+### Fix
+
+* Resolve /CIDToGIDMap streams for CIDFontType2 glyph lookup ([#426](https://github.com/docling-project/docling-parse/issues/426)) ([`8099e94`](https://github.com/docling-project/docling-parse/commit/8099e94fe9a872fe2ceb63618ecbda5beb91e9da))
+* Decode image XObject samples only when a page draws them ([#425](https://github.com/docling-project/docling-parse/issues/425)) ([`341aea5`](https://github.com/docling-project/docling-parse/commit/341aea52ce999d266bd62d5bde625502e7c13ea7))
+
+## [v7.23.1](https://github.com/docling-project/docling-parse/releases/tag/v7.23.1) - 2026-10-26
+
+### Fix
+
+* Transcode non-UTF-8 widget names instead of losing the page ([#392](https://github.com/docling-project/docling-parse/issues/392)) ([`15c3f6a`](https://github.com/docling-project/docling-parse/commit/15c3f6a9609b00271cf7551a1ea216b2f91d1e01))
+* Fail a page whose content the truncated file no longer contains ([#415](https://github.com/docling-project/docling-parse/issues/415)) ([`7b7b273`](https://github.com/docling-project/docling-parse/commit/7b7b273339722541a6576631e95996a295df052c))
+* Keep the page when a damaged content stream breaks one operator ([#418](https://github.com/docling-project/docling-parse/issues/418)) ([`1357898`](https://github.com/docling-project/docling-parse/commit/1357898b1d749f975841c055a5dd194cc3f56b00))
+* Fall back from noncharacter ToUnicode mappings ([#395](https://github.com/docling-project/docling-parse/issues/395)) ([`3c91d2b`](https://github.com/docling-project/docling-parse/commit/3c91d2b372c9554e38aba6c14fda2b60ba0deee5))
+* Treat a space glyph mapped to a control character as a space ([#408](https://github.com/docling-project/docling-parse/issues/408)) ([`6d41900`](https://github.com/docling-project/docling-parse/commit/6d419002e6d2b4fab40a40f5e0048a9f1a74e4f3))
+* Ignore implausible vertical metrics in a font descriptor ([#412](https://github.com/docling-project/docling-parse/issues/412)) ([`2a9a6f8`](https://github.com/docling-project/docling-parse/commit/2a9a6f8b3a1f0d286da57e83911204bc3073f044))
+* **render:** Paint Type3 glyphs whose CharProc draws an image ([#422](https://github.com/docling-project/docling-parse/issues/422)) ([`dc69024`](https://github.com/docling-project/docling-parse/commit/dc690243ef79104c835facc0d776f15d5b31eec9))
+* Update pinned third-party libraries with known CVEs ([#423](https://github.com/docling-project/docling-parse/issues/423)) ([`bbfae48`](https://github.com/docling-project/docling-parse/commit/bbfae4839e31396ba06c1ebbd46362a4447269b1))
+
+### Documentation
+
+* Adding performance numbers ([#353](https://github.com/docling-project/docling-parse/issues/353)) ([`f8512ab`](https://github.com/docling-project/docling-parse/commit/f8512ab517428eea2c1e70d9b8db141bdbfa9ab8))
+
 ## [v7.23.0](https://github.com/docling-project/docling-parse/releases/tag/v7.23.0) - 2026-10-22
 
 ### Feature

{docling_parse-7.23.0 → docling_parse-7.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.23.0
+Version: 7.24.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.23.0 → docling_parse-7.24.0}/app/pybind_parse.cpp

@@ -848,6 +848,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
     Returns:
         List[str]: A list of keys for the currently loaded documents.)")
+
+    .def("take_load_error",
+	 [](docling::docling_parser &self, const std::string &key) -> std::map<std::string, std::string> {
+	   return self.take_load_error(key);
+	 },
+	 pybind11::arg("key"),
+	 R"(
+    Return and clear why the last load of `key` failed.
+
+    Parameters:
+        key (str): The key passed to the failed load call.
+
+    Returns:
+        dict[str, str]: {"category": ..., "message": ...}, or an empty dict when
+        no failure is recorded for the key. category is one of "password",
+        "damaged", "unsupported", "io" and "unknown"; message is the text of
+        the underlying (qpdf) error.)")
     
     .def("load_document",
 	 [](docling::docling_parser &self,
@@ -1116,6 +1133,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Returns:
         bool: True if the document was successfully loaded.)")
 
+    .def("take_load_error",
+         [](docling::docling_threaded_parser& self, const std::string& key) -> std::map<std::string, std::string> {
+           return self.take_load_error(key);
+         },
+         pybind11::arg("key"),
+         R"(
+    Return and clear why the last load of `key` failed.
+
+    Parameters:
+        key (str): The key passed to the failed load call.
+
+    Returns:
+        dict[str, str]: {"category": ..., "message": ...}, or an empty dict when
+        no failure is recorded for the key. category is one of "password",
+        "damaged", "unsupported", "io" and "unknown"; message is the text of
+        the underlying (qpdf) error.)")
+
     .def("load_document_from_bytesio",
          [](docling::docling_threaded_parser& self,
             const std::string& key,

{docling_parse-7.23.0 → docling_parse-7.24.0}/cmake/extlib_freetype.cmake

@@ -19,7 +19,12 @@ else()
     file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/lib)
 
     set(FREETYPE_URL https://github.com/freetype/freetype.git)
-    set(FREETYPE_TAG VER-2-13-3)
+    # VER-2-13-3 is affected by CVE-2026-23865, an integer overflow in
+    # tt_var_load_item_variation_store (src/truetype/ttgxvar.c) leading to an
+    # out-of-bounds read when parsing HVAR/VVAR/MVAR tables of OpenType
+    # variable fonts. Fixed in VER-2-14-2; VER-2-14-3 is the latest patch
+    # release of that line.
+    set(FREETYPE_TAG VER-2-14-3)
     # GCC/MinGW -> libfreetype.a, MSVC -> freetype.lib (Windows arm64 uses MSVC).
     # DISABLE_FORCE_DEBUG_POSTFIX + Release avoid the "d" postfix, so the name is
     # stable per-toolchain.

{docling_parse-7.23.0 → docling_parse-7.24.0}/cmake/extlib_lcms2.cmake

@@ -33,7 +33,11 @@ else()
     file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/lib)
 
     set(LCMS2_URL https://github.com/mm2/Little-CMS.git)
-    set(LCMS2_TAG lcms2.17)
+    # lcms2.17 (and also 2.18) is affected by CVE-2026-41254 /
+    # GHSA-4xp6-rcgg-m9qq, an integer overflow in CubeSize (src/cmslut.c).
+    # Fixed in lcms2.19 (commits da6110b1, e0641b18); lcms2.19.1 is the
+    # latest release containing those fixes.
+    set(LCMS2_TAG lcms2.19.1)
 
     if(WIN32)
         # Windows (MSVC and MinGW): use vendored CMakeLists. Upstream has no

{docling_parse-7.23.0 → docling_parse-7.24.0}/cmake/extlib_openjpeg.cmake

@@ -18,7 +18,15 @@ else()
     file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/lib)
 
     set(OPENJPEG_URL https://github.com/uclouvain/openjpeg.git)
-    set(OPENJPEG_TAG v2.5.3)
+    # v2.5.3 (and also the latest tag v2.5.4) is affected by OSV-2025-219, a
+    # heap-buffer-overflow WRITE in opj_j2k_read_tile_header /
+    # opj_j2k_read_sod (OSS-Fuzz 403673832, severity HIGH). The fix is merged
+    # on master but no release tag contains it yet, so pin the fix commit
+    # directly: d33cbecc is the merge of uclouvain/openjpeg#1621 ("Fix heap
+    # buffer overflow in opj_j2k_read_sod") and contains the other OSV fixed
+    # commit 91d08b1 as a parent. Replace this with the v2.5.5+ tag once one
+    # is released.
+    set(OPENJPEG_TAG d33cbecc148d3affcdf403211fddc2cc5d442379)
     # GCC/MinGW -> libopenjp2.a, MSVC -> openjp2.lib (Windows arm64 uses MSVC).
     if(MSVC)
         set(OPENJPEG_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/openjp2.lib)

{docling_parse-7.23.0 → docling_parse-7.24.0}/docling_parse/pdf_parser.py

@@ -3,7 +3,7 @@
 import hashlib
 import logging
 import math
-from enum import IntEnum
+from enum import Enum, IntEnum
 from io import BytesIO
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Union
@@ -77,6 +77,78 @@ from docling_parse.pdf_parsers import (  # type: ignore[import]
 _log = logging.getLogger(__name__)
 
 
+class PdfLoadErrorCategory(str, Enum):
+    """Why docling-parse could not load a document.
+
+    The values are the categories the native loader reports, see
+    `src/parse/qpdf/load_error.h`.
+    """
+
+    PASSWORD = "password"
+    """The document is encrypted and the password is missing or wrong."""
+    DAMAGED = "damaged"
+    """qpdf could not repair the file."""
+    UNSUPPORTED = "unsupported"
+    """The file uses a feature qpdf does not implement."""
+    IO = "io"
+    """The file is missing or unreadable."""
+    UNKNOWN = "unknown"
+
+
+class PdfLoadError(RuntimeError):
+    """docling-parse could not load a document.
+
+    A RuntimeError, so handlers written for the former generic error keep
+    working, and the message keeps its former prefix. `category` says what
+    went wrong; `detail` is the message of the underlying (qpdf) failure.
+    """
+
+    def __init__(
+        self,
+        key: str,
+        category: PdfLoadErrorCategory,
+        detail: str,
+        *,
+        reason: str | None = None,
+    ):
+        self.key = key
+        self.category = category
+        self.detail = detail
+
+        message = f"Failed to load document with key {key}"
+        description = reason or detail
+        if description:
+            message = f"{message}: {description}"
+        super().__init__(message)
+
+
+class PdfPasswordError(PdfLoadError):
+    """The document is encrypted and was opened without a valid password.
+
+    `password_supplied` tells whether the caller gave a (wrong) password or
+    none at all: qpdf reports both as the same invalid-password error.
+    """
+
+    def __init__(self, key: str, detail: str, *, password_supplied: bool):
+        self.password_supplied = password_supplied
+        if password_supplied:
+            reason = "the supplied password is incorrect"
+        else:
+            reason = "the document is encrypted and requires a password"
+        super().__init__(key, PdfLoadErrorCategory.PASSWORD, detail, reason=reason)
+
+
+def _load_error(native_parser, key: str, password: str | None) -> PdfLoadError:
+    """Build the exception for a failed load from the native parser's record."""
+    info = native_parser.take_load_error(key)
+    category = PdfLoadErrorCategory(info.get("category", PdfLoadErrorCategory.UNKNOWN))
+    detail = info.get("message", "")
+
+    if category is PdfLoadErrorCategory.PASSWORD:
+        return PdfPasswordError(key, detail, password_supplied=password is not None)
+    return PdfLoadError(key, category, detail)
+
+
 class PdfAnnotations(BaseModel):
     """PDF document annotations including form fields, language, metadata, and table of contents.
 
@@ -1004,7 +1076,14 @@ class DoclingPdfParser:
         decode_config: DecodeConfig | None = None,
         content_config: ContentConfig | None = None,
     ) -> PdfDocument:
+        """Load a document and return a handle to its pages.
 
+        Raises:
+            PdfPasswordError: The document is encrypted and `password` is
+                missing or wrong.
+            PdfLoadError: The document could not be loaded for another
+                reason; see its `category` and `detail`.
+        """
         if isinstance(path_or_stream, str):
             path_or_stream = Path(path_or_stream)
 
@@ -1048,7 +1127,7 @@ class DoclingPdfParser:
 
             return result_doc
         else:
-            raise RuntimeError(f"Failed to load document with key {key}")
+            raise _load_error(self.parser, key, password)
 
     def _load_document(
         self,
@@ -1571,6 +1650,12 @@ class DoclingThreadedPdfParser:
 
         Returns:
             str: The document key.
+
+        Raises:
+            PdfPasswordError: The document is encrypted and `password` is
+                missing or wrong.
+            PdfLoadError: The document could not be loaded for another
+                reason; see its `category` and `detail`.
         """
         if page_numbers is not None and page_range is not None:
             raise ValueError("page_numbers and page_range are mutually exclusive")
@@ -1608,7 +1693,7 @@ class DoclingThreadedPdfParser:
             )
 
         if not success:
-            raise RuntimeError(f"Failed to load document with key {key}")
+            raise _load_error(self._parser, key, password)
 
         self._page_counts[key] = self._parser.number_of_pages(key)
         self._scheduled_page_counts[key] = self._parser.scheduled_number_of_pages(key)

{docling_parse-7.23.0 → docling_parse-7.24.0}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.23.0
+Version: 7.24.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.23.0 → docling_parse-7.24.0}/docling_parse.egg-info/SOURCES.txt

@@ -612,9 +612,11 @@ src/parse/pdf_states/grph.h
 src/parse/pdf_states/shape.h
 src/parse/pdf_states/text.h
 src/parse/qpdf/annots.h
+src/parse/qpdf/load_error.h
 src/parse/qpdf/logger.h
 src/parse/qpdf/object.h
 src/parse/qpdf/outline.h
+src/parse/qpdf/page_integrity.h
 src/parse/qpdf/qpdf_compat.h
 src/parse/qpdf/stream_decoder.h
 src/parse/qpdf/stream_filters.h
@@ -751,11 +753,15 @@ tests/test_unit_acroform_widgets.py
 tests/test_unit_actual_text.py
 tests/test_unit_bitmap_artifacts.py
 tests/test_unit_ccitt_images.py
+tests/test_unit_cid_to_gid_map.py
 tests/test_unit_cjk_fonts.py
 tests/test_unit_clipping.py
 tests/test_unit_cmap_encoding.py
 tests/test_unit_colorspace.py
 tests/test_unit_colorspaces.py
+tests/test_unit_control_char_word_space.py
+tests/test_unit_damaged_content_streams.py
+tests/test_unit_damaged_pages.py
 tests/test_unit_font_fallback.py
 tests/test_unit_font_name_resolution.py
 tests/test_unit_gid_glyph_names.py
@@ -765,6 +771,7 @@ tests/test_unit_invalid_font_metrics.py
 tests/test_unit_jbig2_masks.py
 tests/test_unit_jpeg_images.py
 tests/test_unit_load_failure.py
+tests/test_unit_load_failure_reason.py
 tests/test_unit_nul_mapping.py
 tests/test_unit_page_count.py
 tests/test_unit_patterns.py
@@ -774,6 +781,7 @@ tests/test_unit_shading.py
 tests/test_unit_shadings.py
 tests/test_unit_shape_boundary_origin.py
 tests/test_unit_shape_queries_page_frame.py
+tests/test_unit_shared_resource_images.py
 tests/test_unit_standard_font_widths.py
 tests/test_unit_stroke_curves.py
 tests/test_unit_text_render_modes.py

{docling_parse-7.23.0 → docling_parse-7.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.23.0"
+version = "7.24.0"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]

{docling_parse-7.23.0 → docling_parse-7.24.0}/src/parse/page_items/embedded_font_blob.h

@@ -32,7 +32,8 @@ namespace pdflib
                        bool is_cid_font,
                        bool cid_to_gid_identity,
                        bool uses_builtin_encoding,
-                       std::shared_ptr<const std::vector<uint8_t> > bytes);
+                       std::shared_ptr<const std::vector<uint8_t> > bytes,
+                       std::vector<uint16_t> code_to_gid_map);
 
     // Content-derived identity (FNV-1a over the decoded bytes + size).
     // PDF object ids are NOT used: they are only unique within one document,
@@ -53,6 +54,24 @@ namespace pdflib
     // /CIDToGIDMap is /Identity or absent
     bool get_cid_to_gid_identity() const { return cid_to_gid_identity; }
 
+    // True when a CID font's character codes address glyphs directly: an
+    // identity /CIDToGIDMap, or a /CIDToGIDMap stream whose CIDs the
+    // /Encoding CMap resolves.
+    bool has_code_to_gid() const
+    {
+      return is_cid_font and (cid_to_gid_identity or not code_to_gid_map.empty());
+    }
+
+    // Glyph index of a PDF character code under has_code_to_gid(). An
+    // identity map takes the code itself, as before (exact for
+    // Identity-H/V); an unmapped code gives GID 0.
+    uint32_t code_to_gid(int64_t code) const
+    {
+      if(cid_to_gid_identity) { return static_cast<uint32_t>(code); }
+      return (code >= 0 and static_cast<size_t>(code) < code_to_gid_map.size())
+        ? code_to_gid_map[static_cast<size_t>(code)] : 0;
+    }
+
     // True for a simple font that is symbolic (/FontDescriptor /Flags bit 3)
     // and has no /Encoding override: its PDF character codes address the
     // font program's builtin cmap directly (PDF 32000-1, 9.6.6.4). Shaping
@@ -83,6 +102,10 @@ namespace pdflib
     bool uses_builtin_encoding;
 
     std::shared_ptr<const std::vector<uint8_t> > bytes;
+
+    // /CIDToGIDMap stream composed with the /Encoding CMap (code -> GID);
+    // empty when the map is identity or absent, or its CIDs are unresolved
+    std::vector<uint16_t> code_to_gid_map;
   };
 
   inline embedded_font_blob::embedded_font_blob():
@@ -94,7 +117,8 @@ namespace pdflib
     is_cid_font(false),
     cid_to_gid_identity(false),
     uses_builtin_encoding(false),
-    bytes(nullptr)
+    bytes(nullptr),
+    code_to_gid_map()
   {}
 
   inline embedded_font_blob::embedded_font_blob(std::string cache_key_,
@@ -105,7 +129,8 @@ namespace pdflib
                                                 bool is_cid_font_,
                                                 bool cid_to_gid_identity_,
                                                 bool uses_builtin_encoding_,
-                                                std::shared_ptr<const std::vector<uint8_t> > bytes_):
+                                                std::shared_ptr<const std::vector<uint8_t> > bytes_,
+                                                std::vector<uint16_t> code_to_gid_map_):
     cache_key(std::move(cache_key_)),
     font_name(std::move(font_name_)),
     base_font(std::move(base_font_)),
@@ -114,7 +139,8 @@ namespace pdflib
     is_cid_font(is_cid_font_),
     cid_to_gid_identity(cid_to_gid_identity_),
     uses_builtin_encoding(uses_builtin_encoding_),
-    bytes(std::move(bytes_))
+    bytes(std::move(bytes_)),
+    code_to_gid_map(std::move(code_to_gid_map_))
   {}
 
   inline bool embedded_font_blob::has_bytes() const

{docling_parse-7.23.0 → docling_parse-7.24.0}/src/parse/pdf_decoders/document.h

@@ -11,9 +11,12 @@
 #include <qpdf/Buffer.hh>
 #include <qpdf/QPDFAcroFormDocumentHelper.hh>
 #include <qpdf/QPDF.hh>
+#include <qpdf/QPDFExc.hh>
 #include <qpdf/QPDFWriter.hh>
 
+#include <parse/qpdf/load_error.h>
 #include <parse/qpdf/logger.h>
+#include <parse/qpdf/page_integrity.h>
 
 namespace pdflib
 {
@@ -33,6 +36,12 @@ namespace pdflib
 
     std::string get_filename() { return filename; }
 
+    // Why the last process_document_* call returned false: a category
+    // from load_error and the message of the underlying failure. Both
+    // are empty while no load has failed.
+    const std::string& get_load_error_category() const { return load_error_category; }
+    const std::string& get_load_error_message() const { return load_error_message; }
+
     nlohmann::json get_annotations();
 
     nlohmann::json get_meta_xml();
@@ -78,6 +87,12 @@ namespace pdflib
 
     void ensure_annots_loaded();
 
+    // Throws missing_page_object_error when the page references an
+    // object the file does not contain (docling-parse#374).
+    void ensure_page_content_present(int page_number);
+
+    void record_load_error(const std::string& category, const std::string& message);
+
     void update_timings(pdf_timings& timings_, bool set_timer);
 
   private:
@@ -102,6 +117,14 @@ namespace pdflib
 
     int number_of_pages;
 
+    // qpdf had to repair the file while loading it (for example by
+    // reconstructing the cross-reference table). Set once at load time
+    // and read by the worker threads afterwards.
+    bool qpdf_reported_damage;
+
+    std::string load_error_category;
+    std::string load_error_message;
+
     nlohmann::json json_annots;
     bool annots_loaded;
 
@@ -120,6 +143,7 @@ namespace pdflib
     qpdf_pages({}),
 
     number_of_pages(-1),
+    qpdf_reported_damage(false),
 
     json_annots(nlohmann::json::value_t::null),
     annots_loaded(false),
@@ -139,6 +163,7 @@ namespace pdflib
     qpdf_pages({}),
 
     number_of_pages(-1),
+    qpdf_reported_damage(false),
 
     json_annots(nlohmann::json::value_t::null),
     annots_loaded(false),
@@ -223,6 +248,7 @@ namespace pdflib
     std::ifstream ifs(fs_path, std::ios::binary | std::ios::ate);
     if(!ifs.is_open())
       {
+        record_load_error(load_error::IO, "could not open file: " + filename);
         LOG_S(ERROR) << "could not open file: " << filename;
         return false;
       }
@@ -233,6 +259,7 @@ namespace pdflib
     auto file_buffer = std::make_shared<std::string>(file_size, '\0');
     if(!ifs.read(file_buffer->data(), file_size))
       {
+        record_load_error(load_error::IO, "could not read file: " + filename);
         LOG_S(ERROR) << "could not read file: " << filename;
         return false;
       }
@@ -258,6 +285,9 @@ namespace pdflib
     buffer = _buffer;
     password = _password;
 
+    load_error_category.clear();
+    load_error_message.clear();
+
     LOG_S(INFO) << "start processing buffer of size " << buffer->size() << " by qpdf ...";
     
     utils::timer timer;
@@ -292,11 +322,20 @@ namespace pdflib
 
 	qpdf_pages = qpdf_document.getAllPages();
 	number_of_pages = qpdf_pages.size();
+	qpdf_reported_damage = qpdf_document.anyWarnings();
 	
         LOG_S(INFO) << "#-pages: " << number_of_pages;	
       }
+    catch(const QPDFExc & exc)
+      {
+        // qpdf says why: an invalid password, a file it could not repair, ...
+        record_load_error(load_error::category_of(exc.getErrorCode()), exc.what());
+        LOG_S(ERROR) << "could not process buffer by qpdf: " << exc.what();
+        return false;
+      }
     catch(const std::exception & exc)
       {
+        record_load_error(load_error::UNKNOWN, exc.what());
         LOG_S(ERROR) << "could not process buffer by qpdf: " << exc.what();
         return false;
       }
@@ -308,6 +347,13 @@ namespace pdflib
     return true;
   }
 
+  void pdf_decoder<DOCUMENT>::record_load_error(const std::string& category,
+                                                const std::string& message)
+  {
+    load_error_category = category;
+    load_error_message = message;
+  }
+
   std::pair<int, std::shared_ptr<std::string> > pdf_decoder<DOCUMENT>::get_thread_safe_page_buffer(
     int page_ind,
     bool keep_qpdf_warnings)
@@ -403,10 +449,38 @@ namespace pdflib
     return *src_afdh;
   }
 
+  void pdf_decoder<DOCUMENT>::ensure_page_content_present(int page_number)
+  {
+    std::string missing;
+    {
+      // Resolving the page's references may load objects into the shared
+      // qpdf document, which is only ever touched under this mutex.
+      std::lock_guard<std::mutex> lock(thread_safe_buffer_mutex);
+      missing = qpdf_page_integrity::find_missing_content(qpdf_pages.at(page_number));
+    }
+
+    if(missing.empty())
+      {
+        return;
+      }
+
+    std::string message = "page references " + missing + ", which is not in the file";
+    if(qpdf_reported_damage)
+      {
+        message += " (qpdf had to repair the document while loading it)";
+      }
+    message += ": the PDF is truncated or damaged";
+
+    LOG_S(ERROR) << message;
+    throw missing_page_object_error(message);
+  }
+
   pdf_decoder<DOCUMENT>::page_decoder_ptr
   pdf_decoder<DOCUMENT>::make_thread_safe_page_decoder(int page_number,
                                                        bool keep_qpdf_warnings)
   {
+    ensure_page_content_present(page_number);
+
     std::pair<int, std::shared_ptr<std::string> > result =
       get_thread_safe_page_buffer(page_number, keep_qpdf_warnings);
 
@@ -510,6 +584,7 @@ namespace pdflib
       else
         {
 	  LOG_S(INFO) << "decoding page thread-unsafe";
+          ensure_page_content_present(page_number);
           QPDFObjectHandle qpdf_page = qpdf_pages.at(page_number);
 
           page_decoder = std::make_shared<pdf_decoder<PAGE>>(qpdf_page, page_number);

{docling_parse-7.23.0 → docling_parse-7.24.0}/src/parse/pdf_decoders/page.h

@@ -1557,11 +1557,11 @@ namespace pdflib
     std::string text = "";
     QPDFObjectHandle value = field.getValue();
     if(value.isString()) { text = value.getUTF8Value(); }
-    else if(value.isName()) { text = value.getName(); }
+    else if(value.isName()) { text = name_to_utf8(value); }
 
     std::string appearance_state = "";
     QPDFObjectHandle appearance = annot.getKey("/AS");
-    if(appearance.isName()) { appearance_state = appearance.getName(); }
+    if(appearance.isName()) { appearance_state = name_to_utf8(appearance); }
 
     page_item<PAGE_WIDGET> widget;
     {