A fast, helpful, and open-source document parser
feat: expose PDF document provenance metadata
Pierre-Loic doulcet975790517a00
diff --git a/README.md b/README.mdindex f11568f..57480cb 100644--- a/README.md+++ b/README.md@@ -256,8 +256,12 @@ link annotations. The field is absent by default; enabled untagged pages contain### Document metadata, content bounds, and XFA packetsParse results (Rust/Node/Python APIs) carry the document's `/Info` `creator`-and `producer` entries when present; these are API-only and never appear in-CLI JSON output. Enable `--extract-content-bounds` (Rust/Python+and `producer` entries when present, plus `doc_meta`+(`docMeta` in JavaScript/WASM) with the `/Info` creation/modification+dates, PDF version and encryption permissions, signature state, incremental-save+markers, trailer ID comparison, raw XMP packet (capped at 64 KiB), and source+file size. These document fields are API-only and never appear in CLI JSON+output. Enable `--extract-content-bounds` (Rust/Python`extract_content_bounds`, JavaScript/WASM `extractContentBounds`) to add aper-page `content_bounds`: the union bbox of the page's top-level contentobjects in viewport coords (absent for empty pages). Enablediff --git a/crates/liteparse-napi/src/types.rs b/crates/liteparse-napi/src/types.rsindex 99b9002..dd8e07c 100644--- a/crates/liteparse-napi/src/types.rs+++ b/crates/liteparse-napi/src/types.rs@@ -874,10 +874,50 @@ pub struct JsParseResult {pub creator: Option<String>,/// The document's `/Info` `Producer` entry, when present.pub producer: Option<String>,+ /// Document-level provenance metadata.+ pub doc_meta: JsDocumentMetadata,/// Raw XFA packets; present only when `extractXfaPackets` is enabled.pub xfa_packets: Option<Vec<JsXfaPacket>>,}+#[napi(object)]+#[derive(Clone)]+pub struct JsDocumentMetadata {+ pub creation_date: Option<String>,+ pub mod_date: Option<String>,+ pub file_version: Option<i32>,+ pub is_encrypted: Option<bool>,+ pub security_handler_revision: Option<i32>,+ pub permissions: Option<f64>,+ pub eof_section_count: Option<u32>,+ pub startxref_count: Option<u32>,+ pub trailer_id_pair_differs: Option<bool>,+ pub raw_file_size: Option<f64>,+ pub xmp: Option<String>,+ pub signature_count: Option<u32>,+ pub signature_byte_range_reaches_eof: Option<bool>,+}++impl JsDocumentMetadata {+ fn from_rust(metadata: &liteparse::types::DocumentMetadata) -> Self {+ Self {+ creation_date: metadata.creation_date.clone(),+ mod_date: metadata.mod_date.clone(),+ file_version: metadata.file_version,+ is_encrypted: metadata.is_encrypted,+ security_handler_revision: metadata.security_handler_revision,+ permissions: metadata.permissions.map(|value| value as f64),+ eof_section_count: metadata.eof_section_count,+ startxref_count: metadata.startxref_count,+ trailer_id_pair_differs: metadata.trailer_id_pair_differs,+ raw_file_size: metadata.raw_file_size.map(|value| value as f64),+ xmp: metadata.xmp.clone(),+ signature_count: metadata.signature_count,+ signature_byte_range_reaches_eof: metadata.signature_byte_range_reaches_eof,+ }+ }+}+/// One raw packet from an XFA form document's `/XFA` array.#[napi(object)]#[derive(Clone)]@@ -1063,6 +1103,7 @@ impl JsParseResult {form_type: result.form_type,creator: result.creator.clone(),producer: result.producer.clone(),+ doc_meta: JsDocumentMetadata::from_rust(&result.doc_meta),xfa_packets: result.xfa_packets.as_ref()diff --git a/crates/liteparse-python/src/lib.rs b/crates/liteparse-python/src/lib.rsindex 9cf5839..851dce7 100644--- a/crates/liteparse-python/src/lib.rs+++ b/crates/liteparse-python/src/lib.rs@@ -610,9 +610,62 @@ struct PyParseResult {#[pyo3(get)]producer: Option<String>,#[pyo3(get)]+ doc_meta: PyDocumentMetadata,+ #[pyo3(get)]xfa_packets: Option<Vec<PyXfaPacket>>,}+#[pyclass(frozen, from_py_object)]+#[derive(Clone)]+struct PyDocumentMetadata {+ #[pyo3(get)]+ creation_date: Option<String>,+ #[pyo3(get)]+ mod_date: Option<String>,+ #[pyo3(get)]+ file_version: Option<i32>,+ #[pyo3(get)]+ is_encrypted: Option<bool>,+ #[pyo3(get)]+ security_handler_revision: Option<i32>,+ #[pyo3(get)]+ permissions: Option<u64>,+ #[pyo3(get)]+ eof_section_count: Option<u32>,+ #[pyo3(get)]+ startxref_count: Option<u32>,+ #[pyo3(get)]+ trailer_id_pair_differs: Option<bool>,+ #[pyo3(get)]+ raw_file_size: Option<u64>,+ #[pyo3(get)]+ xmp: Option<String>,+ #[pyo3(get)]+ signature_count: Option<u32>,+ #[pyo3(get)]+ signature_byte_range_reaches_eof: Option<bool>,+}++impl From<liteparse::types::DocumentMetadata> for PyDocumentMetadata {+ fn from(metadata: liteparse::types::DocumentMetadata) -> Self {+ Self {+ creation_date: metadata.creation_date,+ mod_date: metadata.mod_date,+ file_version: metadata.file_version,+ is_encrypted: metadata.is_encrypted,+ security_handler_revision: metadata.security_handler_revision,+ permissions: metadata.permissions,+ eof_section_count: metadata.eof_section_count,+ startxref_count: metadata.startxref_count,+ trailer_id_pair_differs: metadata.trailer_id_pair_differs,+ raw_file_size: metadata.raw_file_size,+ xmp: metadata.xmp,+ signature_count: metadata.signature_count,+ signature_byte_range_reaches_eof: metadata.signature_byte_range_reaches_eof,+ }+ }+}+/// One raw packet from an XFA form document's `/XFA` array.#[pyclass(frozen, from_py_object)]#[derive(Clone)]@@ -676,6 +729,7 @@ impl PyParseResult {form_type: result.form_type,creator: result.creator,producer: result.producer,+ doc_meta: result.doc_meta.into(),xfa_packets: result.xfa_packets.map(|packets| {packets.into_iter()@@ -1470,6 +1524,7 @@ fn _liteparse(m: &Bound<'_, PyModule>) -> PyResult<()> {m.add_class::<LiteParse>()?;m.add_class::<PyLiteParseConfig>()?;m.add_class::<PyParseResult>()?;+ m.add_class::<PyDocumentMetadata>()?;m.add_class::<PyExtractedImage>()?;m.add_class::<PyImageRect>()?;m.add_class::<PyParsedPage>()?;diff --git a/crates/liteparse-wasm/src/lib.rs b/crates/liteparse-wasm/src/lib.rsindex 482690a..4409e84 100644--- a/crates/liteparse-wasm/src/lib.rs+++ b/crates/liteparse-wasm/src/lib.rs@@ -612,11 +612,65 @@ pub struct ParseResult {/// The document's `/Info` `Producer` entry, when present.#[serde(skip_serializing_if = "Option::is_none")]pub producer: Option<String>,+ /// Document-level provenance metadata.+ pub doc_meta: DocumentMetadata,/// Raw XFA packets; present only when `extractXfaPackets` is enabled.#[serde(skip_serializing_if = "Option::is_none")]pub xfa_packets: Option<Vec<XfaPacket>>,}+#[derive(Serialize, Tsify)]+#[tsify(into_wasm_abi)]+#[serde(rename_all = "camelCase")]+pub struct DocumentMetadata {+ #[serde(skip_serializing_if = "Option::is_none")]+ pub creation_date: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub mod_date: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub file_version: Option<i32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub is_encrypted: Option<bool>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub security_handler_revision: Option<i32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub permissions: Option<f64>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub eof_section_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub startxref_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub trailer_id_pair_differs: Option<bool>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub raw_file_size: Option<f64>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub xmp: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub signature_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub signature_byte_range_reaches_eof: Option<bool>,+}++impl From<&liteparse::types::DocumentMetadata> for DocumentMetadata {+ fn from(metadata: &liteparse::types::DocumentMetadata) -> Self {+ Self {+ creation_date: metadata.creation_date.clone(),+ mod_date: metadata.mod_date.clone(),+ file_version: metadata.file_version,+ is_encrypted: metadata.is_encrypted,+ security_handler_revision: metadata.security_handler_revision,+ permissions: metadata.permissions.map(|value| value as f64),+ eof_section_count: metadata.eof_section_count,+ startxref_count: metadata.startxref_count,+ trailer_id_pair_differs: metadata.trailer_id_pair_differs,+ raw_file_size: metadata.raw_file_size.map(|value| value as f64),+ xmp: metadata.xmp.clone(),+ signature_count: metadata.signature_count,+ signature_byte_range_reaches_eof: metadata.signature_byte_range_reaches_eof,+ }+ }+}+/// One raw packet from an XFA form document's `/XFA` array.#[derive(Serialize, Tsify)]#[tsify(into_wasm_abi)]@@ -980,6 +1034,7 @@ impl LiteParse {form_type: result.form_type,creator: result.creator.clone(),producer: result.producer.clone(),+ doc_meta: DocumentMetadata::from(&result.doc_meta),xfa_packets: result.xfa_packets.as_ref().map(|packets| {packets.iter()diff --git a/crates/liteparse/src/document_metadata.rs b/crates/liteparse/src/document_metadata.rsnew file mode 100644index 0000000..05f892d--- /dev/null+++ b/crates/liteparse/src/document_metadata.rs@@ -0,0 +1,219 @@+//! Document-level PDF provenance metadata extraction.++use crate::types::{DocumentMetadata, PdfInput};+use pdfium::Document;+use std::io::{Read, Seek, SeekFrom};++const SCAN_BUFFER_BYTES: usize = 1 << 20;+const SCAN_OVERLAP: usize = 64;+const XMP_MAX_BYTES: usize = 64 * 1024;++pub(crate) fn extract(input: &PdfInput, document: &Document<'_>) -> DocumentMetadata {+ let mut metadata = match input {+ #[cfg(not(target_arch = "wasm32"))]+ PdfInput::Path(path) => std::fs::File::open(path)+ .ok()+ .map(|mut file| extract_raw_facts(&mut file))+ .unwrap_or_default(),+ PdfInput::Bytes(bytes) => extract_raw_facts(&mut std::io::Cursor::new(bytes)),+ #[cfg(target_arch = "wasm32")]+ PdfInput::Path(_) => DocumentMetadata::default(),+ };++ metadata.creation_date = document.meta_text("CreationDate");+ metadata.mod_date = document.meta_text("ModDate");+ metadata.file_version = document.file_version();+ let security_revision = document.security_handler_revision();+ metadata.is_encrypted = Some(security_revision != -1);+ if security_revision != -1 {+ metadata.security_handler_revision = Some(security_revision);+ metadata.permissions = Some(document.permissions());+ }+ let signatures = document.signature_summary(metadata.raw_file_size);+ metadata.signature_count = Some(signatures.count);+ metadata.signature_byte_range_reaches_eof = signatures.byte_range_reaches_eof;+ metadata+}++fn extract_raw_facts<R: Read + Seek>(reader: &mut R) -> DocumentMetadata {+ let mut metadata = DocumentMetadata::default();+ let file_size = reader.seek(SeekFrom::End(0)).ok();+ metadata.raw_file_size = file_size;+ if reader.seek(SeekFrom::Start(0)).is_err() {+ return metadata;+ }++ let mut buffer = vec![0u8; SCAN_BUFFER_BYTES];+ let mut carry = 0usize;+ let mut file_offset = 0u64;+ let mut eof_count = 0u32;+ let mut startxref_count = 0u32;+ let mut xmp_start = None;++ loop {+ let got = match reader.read(&mut buffer[carry..]) {+ Ok(got) => got,+ Err(_) => break,+ };+ let window_len = carry + got;+ if window_len == 0 {+ break;+ }+ let countable = if got > 0 && window_len > SCAN_OVERLAP {+ window_len - SCAN_OVERLAP+ } else {+ window_len+ };+ let window = &buffer[..window_len];+ eof_count = eof_count.saturating_add(count_occurrences_before(window, b"%%EOF", countable));+ startxref_count = startxref_count.saturating_add(count_occurrences_before(+ window,+ b"startxref",+ countable,+ ));+ if xmp_start.is_none()+ && let Some(offset) = find_bytes(window, b"<?xpacket begin")+ {+ xmp_start = Some(file_offset + offset as u64);+ }+ if got == 0 {+ break;+ }+ file_offset += countable as u64;+ carry = window_len - countable;+ buffer.copy_within(countable..window_len, 0);+ }++ metadata.eof_section_count = Some(eof_count);+ metadata.startxref_count = Some(startxref_count);++ if let Some(file_size) = file_size {+ let tail_start = file_size.saturating_sub(SCAN_BUFFER_BYTES as u64);+ if reader.seek(SeekFrom::Start(tail_start)).is_ok() {+ let mut tail = vec![0u8; (file_size - tail_start) as usize];+ if let Ok(got) = reader.read(&mut tail) {+ tail.truncate(got);+ metadata.trailer_id_pair_differs = trailer_id_pair_differs(&tail);+ }+ }+ }++ if let Some(xmp_start) = xmp_start+ && reader.seek(SeekFrom::Start(xmp_start)).is_ok()+ {+ let mut xmp = vec![0u8; XMP_MAX_BYTES];+ if let Ok(got) = reader.read(&mut xmp) {+ xmp.truncate(got);+ if let Some(packet_end) = find_bytes(&xmp, b"<?xpacket end") {+ let suffix = &xmp[packet_end..];+ let end = find_bytes(suffix, b"?>")+ .map(|offset| packet_end + offset + 2)+ .unwrap_or(packet_end + b"<?xpacket end".len());+ xmp.truncate(end.min(xmp.len()));+ }+ metadata.xmp = Some(String::from_utf8_lossy(&xmp).into_owned());+ }+ }++ metadata+}++fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {+ (!needle.is_empty() && haystack.len() >= needle.len())+ .then(|| {+ haystack+ .windows(needle.len())+ .position(|part| part == needle)+ })+ .flatten()+}++fn count_occurrences_before(haystack: &[u8], needle: &[u8], start_limit: usize) -> u32 {+ let mut count = 0u32;+ let mut cursor = 0usize;+ while let Some(offset) = find_bytes(&haystack[cursor..], needle) {+ if cursor + offset >= start_limit {+ break;+ }+ count = count.saturating_add(1);+ cursor += offset + needle.len();+ }+ count+}++fn trailer_id_pair_differs(bytes: &[u8]) -> Option<bool> {+ let mut cursor = 0usize;+ let mut last_pair: Option<(&[u8], &[u8])> = None;+ while let Some(offset) = find_bytes(&bytes[cursor..], b"/ID") {+ let id_start = cursor + offset;+ let mut pos = id_start + 3;+ while bytes+ .get(pos)+ .is_some_and(|b| matches!(b, b' ' | b'\r' | b'\n' | b'\t'))+ {+ pos += 1;+ }+ if bytes.get(pos) == Some(&b'[') {+ pos += 1;+ let mut values = Vec::with_capacity(2);+ while pos < bytes.len() && bytes[pos] != b']' && values.len() < 2 {+ if bytes[pos] == b'<' {+ let start = pos + 1;+ if let Some(close) = bytes[start..].iter().position(|b| *b == b'>') {+ values.push(&bytes[start..start + close]);+ pos = start + close;+ }+ }+ pos += 1;+ }+ if values.len() == 2 {+ last_pair = Some((values[0], values[1]));+ }+ }+ cursor = id_start + 3;+ }+ last_pair.map(|(first, second)| first != second)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn extracts_raw_provenance_facts() {+ let pdf = b"%PDF-1.4\n/ID [<aaaa><bbbb>]\nstartxref\n1\n%%EOF\n\+ update\n/ID [ <cccc> <dddd> ]\nstartxref\n2\n%%EOF\n\+ <?xpacket begin='x'?><x:xmpmeta>ok</x:xmpmeta><?xpacket end='w'?>tail";+ let metadata = extract_raw_facts(&mut std::io::Cursor::new(pdf));+ assert_eq!(metadata.raw_file_size, Some(pdf.len() as u64));+ assert_eq!(metadata.eof_section_count, Some(2));+ assert_eq!(metadata.startxref_count, Some(2));+ assert_eq!(metadata.trailer_id_pair_differs, Some(true));+ assert_eq!(+ metadata.xmp.as_deref(),+ Some("<?xpacket begin='x'?><x:xmpmeta>ok</x:xmpmeta><?xpacket end='w'?>")+ );+ }++ #[test]+ fn trailer_id_uses_last_valid_pair() {+ assert_eq!(+ trailer_id_pair_differs(b"/ID [<aa><bb>] junk /ID [<cc><cc>]"),+ Some(false)+ );+ assert_eq!(trailer_id_pair_differs(b"no trailer id"), None);+ }++ #[test]+ fn finds_markers_that_cross_scan_chunks_without_double_counting() {+ let mut pdf = vec![b'x'; SCAN_BUFFER_BYTES - 7];+ pdf.extend_from_slice(b"startxref\n%%EOF\n<?xpacket begin='x'?>payload");+ let metadata = extract_raw_facts(&mut std::io::Cursor::new(pdf));+ assert_eq!(metadata.startxref_count, Some(1));+ assert_eq!(metadata.eof_section_count, Some(1));+ assert_eq!(+ metadata.xmp.as_deref(),+ Some("<?xpacket begin='x'?>payload")+ );+ }+}diff --git a/crates/liteparse/src/lib.rs b/crates/liteparse/src/lib.rsindex 56dd89b..f4d5582 100644--- a/crates/liteparse/src/lib.rs+++ b/crates/liteparse/src/lib.rs@@ -12,7 +12,7 @@ pub use font_db_resolver::FontDbResolver;pub use glyph_resolver::{GLYPH_RESOLVER_FONT_SIZE, GlyphResolver};pub use parser::{LiteParse, ParseResult, ScreenshotResult};pub use search::{SearchOptions, search_items};-pub use types::{ParsedPage, TextItem, WordBox};+pub use types::{DocumentMetadata, ParsedPage, TextItem, WordBox};// ── Modules with user-facing types (visible in docs) ───────────────────pub mod config;@@ -28,6 +28,7 @@ mod acroform_repair;#[cfg(not(target_arch = "wasm32"))]#[doc(hidden)]pub mod conversion;+mod document_metadata;#[doc(hidden)]pub mod extract;#[doc(hidden)]diff --git a/crates/liteparse/src/output/json.rs b/crates/liteparse/src/output/json.rsindex 01bd782..173d9db 100644--- a/crates/liteparse/src/output/json.rs+++ b/crates/liteparse/src/output/json.rs@@ -395,6 +395,7 @@ mod tests {form_type: None,creator: Some("LibreOffice".into()),producer: Some("LibreOffice 7.4".into()),+ doc_meta: crate::types::DocumentMetadata::default(),xfa_packets: Some(vec![crate::types::XfaPacket {index: 0,name: Some("datasets".into()),@@ -406,6 +407,7 @@ mod tests {serde_json::from_str(&format_json_result(&result, false).unwrap()).unwrap();assert!(value.get("creator").is_none());assert!(value.get("producer").is_none());+ assert!(value.get("doc_meta").is_none());assert_eq!(value["xfa_packets"][0]["name"], "datasets");assert_eq!(value["xfa_packets"][0]["content_length"], 11);assert_eq!(value["images"][0]["bbox"]["x"], 10.0);diff --git a/crates/liteparse/src/parser.rs b/crates/liteparse/src/parser.rsindex 4f387ac..43a865b 100644--- a/crates/liteparse/src/parser.rs+++ b/crates/liteparse/src/parser.rs@@ -14,7 +14,8 @@ use crate::projection;#[cfg(not(target_arch = "wasm32"))]use crate::render;use crate::types::{- ExtractedImage, OutlineTarget, Page, ParsedPage, PdfInput, ScreenshotRect, XfaPacket,+ DocumentMetadata, ExtractedImage, OutlineTarget, Page, ParsedPage, PdfInput, ScreenshotRect,+ XfaPacket,};use pdfium::Library;@@ -42,6 +43,9 @@ pub struct ParseResult {pub creator: Option<String>,/// The document's `/Info` `Producer` entry, when present.pub producer: Option<String>,+ /// Document provenance metadata (dates, version/security, signatures,+ /// incremental-save markers, trailer IDs, raw XMP, and source size).+ pub doc_meta: DocumentMetadata,/// Raw XFA packets, present only when `extract_xfa_packets` is enabled./// `Some([])` means extraction ran on a non-XFA document.pub xfa_packets: Option<Vec<XfaPacket>>,@@ -429,6 +433,7 @@ impl LiteParse {form_type,creator,producer,+ doc_meta,xfa_packets,) = {let lib = Library::init();@@ -455,6 +460,16 @@ impl LiteParse {.then(|| document.form_type());let creator = document.meta_text("Creator");let producer = document.meta_text("Producer");+ #[cfg(not(target_arch = "wasm32"))]+ let doc_meta = if repaired_input.is_some() {+ let source_document =+ extract::load_document_from_input(&lib, &validated_input, password)?;+ crate::document_metadata::extract(&validated_input, &source_document)+ } else {+ crate::document_metadata::extract(&validated_input, &document)+ };+ #[cfg(target_arch = "wasm32")]+ let doc_meta = crate::document_metadata::extract(&validated_input, &document);let xfa_packets = self.config.extract_xfa_packets.then(|| {document.xfa_packets()@@ -540,6 +555,7 @@ impl LiteParse {form_type,creator,producer,+ doc_meta,xfa_packets,)};@@ -631,6 +647,7 @@ impl LiteParse {form_type,creator,producer,+ doc_meta,xfa_packets,})}@@ -671,6 +688,7 @@ impl LiteParse {form_type: None,creator: None,producer: None,+ doc_meta: DocumentMetadata::default(),xfa_packets: None,}}diff --git a/crates/liteparse/src/types.rs b/crates/liteparse/src/types.rsindex aacaee4..01e55f9 100644--- a/crates/liteparse/src/types.rs+++ b/crates/liteparse/src/types.rs@@ -10,6 +10,40 @@ pub enum PdfInput {Bytes(Vec<u8>),}+/// Document-level provenance metadata extracted from PDFium plus a bounded+/// streaming scan of the source PDF. Fields stay optional so malformed+/// metadata never prevents the document itself from being parsed.+#[derive(Debug, Clone, Default, Serialize)]+pub struct DocumentMetadata {+ #[serde(skip_serializing_if = "Option::is_none")]+ pub creation_date: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub mod_date: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub file_version: Option<i32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub is_encrypted: Option<bool>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub security_handler_revision: Option<i32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub permissions: Option<u64>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub eof_section_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub startxref_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub trailer_id_pair_differs: Option<bool>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub raw_file_size: Option<u64>,+ /// Raw XMP packet text, capped at 64 KiB.+ #[serde(skip_serializing_if = "Option::is_none")]+ pub xmp: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub signature_count: Option<u32>,+ #[serde(skip_serializing_if = "Option::is_none")]+ pub signature_byte_range_reaches_eof: Option<bool>,+}+/// Represents a single text item extracted from a PDF page,/// including its content, position, size, rotation, and font metadata.#[derive(Debug, Clone, Default, Serialize)]diff --git a/crates/liteparse/tests/integration_test.rs b/crates/liteparse/tests/integration_test.rsindex 186f2bd..42e5c6c 100644--- a/crates/liteparse/tests/integration_test.rs+++ b/crates/liteparse/tests/integration_test.rs@@ -151,28 +151,46 @@ async fn test_parse_office_doc_integration() {#[tokio::test]#[serial]async fn test_parse_pdf_integration() {- let lit = LiteParse::new(LiteParseConfig::default());+ let lit = LiteParse::new(LiteParseConfig {+ ocr_enabled: false,+ ..LiteParseConfig::default()+ });let parsed = lit.parse("../../integration_tests_data/sample.pdf").await.expect("Should be able to parse");assert_eq!(parsed.pages.len(), 1);+ assert!(parsed.doc_meta.file_version.is_some());+ assert_eq!(parsed.doc_meta.is_encrypted, Some(false));+ assert!(parsed.doc_meta.raw_file_size.is_some_and(|size| size > 0));+ assert!(+ parsed+ .doc_meta+ .eof_section_count+ .is_some_and(|count| count > 0)+ );+ assert_eq!(parsed.doc_meta.signature_count, Some(0));}#[tokio::test]#[serial]async fn test_parse_bytes_pdf_integration() {let fixture_path = "../../integration_tests_data/sample.pdf";- let lit = LiteParse::new(LiteParseConfig::default());+ let lit = LiteParse::new(LiteParseConfig {+ ocr_enabled: false,+ ..LiteParseConfig::default()+ });let data = tokio::fs::read(fixture_path).await.expect("Should be able to read file");+ let expected_size = data.len() as u64;let input = PdfInput::Bytes(data);let parsed = lit.parse_input(input).await.expect("Should be able to parse");assert_eq!(parsed.pages.len(), 1);+ assert_eq!(parsed.doc_meta.raw_file_size, Some(expected_size));}/// Stress test: many concurrent `parse_input` calls on a multi-threadeddiff --git a/crates/pdfium-sys/bindings.rs b/crates/pdfium-sys/bindings.rsindex 27a0477..ed73e49 100644--- a/crates/pdfium-sys/bindings.rs+++ b/crates/pdfium-sys/bindings.rs@@ -563,6 +563,22 @@ unsafe extern "C" {fileVersion: *mut ::std::os::raw::c_int,) -> FPDF_BOOL;}+unsafe extern "C" {+ pub fn FPDF_GetSignatureCount(document: FPDF_DOCUMENT) -> ::std::os::raw::c_int;+}+unsafe extern "C" {+ pub fn FPDF_GetSignatureObject(+ document: FPDF_DOCUMENT,+ index: ::std::os::raw::c_int,+ ) -> FPDF_SIGNATURE;+}+unsafe extern "C" {+ pub fn FPDFSignatureObj_GetByteRange(+ signature: FPDF_SIGNATURE,+ buffer: *mut ::std::os::raw::c_int,+ length: ::std::os::raw::c_ulong,+ ) -> ::std::os::raw::c_ulong;+}unsafe extern "C" {pub fn FPDF_GetLastError() -> ::std::os::raw::c_ulong;}diff --git a/crates/pdfium-sys/src/dynamic.rs b/crates/pdfium-sys/src/dynamic.rsindex b1fb7bb..7a595e8 100644--- a/crates/pdfium-sys/src/dynamic.rs+++ b/crates/pdfium-sys/src/dynamic.rs@@ -67,6 +67,18 @@ pub struct PdfiumBindings {*mut std::os::raw::c_void,std::os::raw::c_ulong,) -> std::os::raw::c_ulong,+ pub FPDF_GetFileVersion:+ unsafe extern "C" fn(FPDF_DOCUMENT, *mut std::os::raw::c_int) -> FPDF_BOOL,+ pub FPDF_GetSecurityHandlerRevision: unsafe extern "C" fn(FPDF_DOCUMENT) -> std::os::raw::c_int,+ pub FPDF_GetDocPermissions: unsafe extern "C" fn(FPDF_DOCUMENT) -> std::os::raw::c_ulong,+ pub FPDF_GetSignatureCount: unsafe extern "C" fn(FPDF_DOCUMENT) -> std::os::raw::c_int,+ pub FPDF_GetSignatureObject:+ unsafe extern "C" fn(FPDF_DOCUMENT, std::os::raw::c_int) -> FPDF_SIGNATURE,+ pub FPDFSignatureObj_GetByteRange: unsafe extern "C" fn(+ FPDF_SIGNATURE,+ *mut std::os::raw::c_int,+ std::os::raw::c_ulong,+ ) -> std::os::raw::c_ulong,pub FPDF_GetXFAPacketCount: unsafe extern "C" fn(FPDF_DOCUMENT) -> std::os::raw::c_int,pub FPDF_GetXFAPacketName: unsafe extern "C" fn(FPDF_DOCUMENT,@@ -524,6 +536,12 @@ impl PdfiumBindings {FORM_DoPageAAction: load_fn!(lib, "FORM_DoPageAAction"),FPDF_FFLDraw: load_fn!(lib, "FPDF_FFLDraw"),FPDF_GetMetaText: load_fn!(lib, "FPDF_GetMetaText"),+ FPDF_GetFileVersion: load_fn!(lib, "FPDF_GetFileVersion"),+ FPDF_GetSecurityHandlerRevision: load_fn!(lib, "FPDF_GetSecurityHandlerRevision"),+ FPDF_GetDocPermissions: load_fn!(lib, "FPDF_GetDocPermissions"),+ FPDF_GetSignatureCount: load_fn!(lib, "FPDF_GetSignatureCount"),+ FPDF_GetSignatureObject: load_fn!(lib, "FPDF_GetSignatureObject"),+ FPDFSignatureObj_GetByteRange: load_fn!(lib, "FPDFSignatureObj_GetByteRange"),FPDF_GetXFAPacketCount: load_fn!(lib, "FPDF_GetXFAPacketCount"),FPDF_GetXFAPacketName: load_fn!(lib, "FPDF_GetXFAPacketName"),FPDF_GetXFAPacketContent: load_fn!(lib, "FPDF_GetXFAPacketContent"),diff --git a/crates/pdfium-sys/wrapper.h b/crates/pdfium-sys/wrapper.hindex e35d841..46d184d 100644--- a/crates/pdfium-sys/wrapper.h+++ b/crates/pdfium-sys/wrapper.h@@ -5,3 +5,4 @@#include "fpdf_annot.h"#include "fpdf_structtree.h"#include "fpdf_transformpage.h"+#include "fpdf_signature.h"diff --git a/crates/pdfium/src/document.rs b/crates/pdfium/src/document.rsindex 7e7f18e..19d2ea8 100644--- a/crates/pdfium/src/document.rs+++ b/crates/pdfium/src/document.rs@@ -50,6 +50,14 @@ pub struct XfaPacket {pub content: Option<Vec<u8>>,}+/// Signature summary used for document provenance metadata.+#[derive(Debug, Clone, Copy)]+pub struct SignatureSummary {+ pub count: u32,+ /// `None` when signatures exist but PDFium did not expose any byte range.+ pub byte_range_reaches_eof: Option<bool>,+}+impl<'lib> Document<'lib> {pub fn page_count(&self) -> i32 {unsafe { ffi!(FPDF_GetPageCount(self.handle)) }@@ -133,6 +141,72 @@ impl<'lib> Document<'lib> {Some(String::from_utf16_lossy(&buf[..end]))}+ /// Encoded PDF version (`14` means PDF 1.4), when present.+ pub fn file_version(&self) -> Option<i32> {+ let mut version = 0;+ let ok = unsafe { ffi!(FPDF_GetFileVersion(self.handle, &mut version)) };+ (ok != 0).then_some(version)+ }++ /// PDF security-handler revision, or `-1` for an unencrypted document.+ pub fn security_handler_revision(&self) -> i32 {+ unsafe { ffi!(FPDF_GetSecurityHandlerRevision(self.handle)) }+ }++ /// Document permission flags reported by PDFium.+ pub fn permissions(&self) -> u64 {+ unsafe { ffi!(FPDF_GetDocPermissions(self.handle)) as u64 }+ }++ /// Count signatures and determine whether every readable final byte-range+ /// segment reaches the current end of the file.+ pub fn signature_summary(&self, file_size: Option<u64>) -> SignatureSummary {+ const MAX_BYTE_RANGE_VALUES: usize = 8;+ let count = unsafe { ffi!(FPDF_GetSignatureCount(self.handle)) }.max(0) as u32;+ if count == 0 {+ return SignatureSummary {+ count,+ byte_range_reaches_eof: None,+ };+ }++ let mut known = false;+ let mut reaches_eof = true;+ for index in 0..count {+ let signature = unsafe { ffi!(FPDF_GetSignatureObject(self.handle, index as i32)) };+ if signature.is_null() {+ continue;+ }+ let mut ranges = [0i32; MAX_BYTE_RANGE_VALUES];+ let len = unsafe {+ ffi!(FPDFSignatureObj_GetByteRange(+ signature,+ ranges.as_mut_ptr(),+ ranges.len() as std::os::raw::c_ulong,+ ))+ } as usize;+ if !(2..=MAX_BYTE_RANGE_VALUES).contains(&len) {+ continue;+ }+ known = true;+ let start = i64::from(ranges[len - 2]);+ let length = i64::from(ranges[len - 1]);+ if let Some(file_size) = file_size+ && (start < 0+ || length < 0+ || u64::try_from(start + length)+ .ok()+ .is_some_and(|range_end| range_end < file_size))+ {+ reaches_eof = false;+ }+ }+ SignatureSummary {+ count,+ byte_range_reaches_eof: known.then_some(reaches_eof),+ }+ }+/// Number of packets in the document's `/XFA` array (0 for non-XFA docs).pub fn xfa_packet_count(&self) -> i32 {unsafe { ffi!(FPDF_GetXFAPacketCount(self.handle)) }diff --git a/crates/pdfium/src/lib.rs b/crates/pdfium/src/lib.rsindex 48f607d..3ce12e3 100644--- a/crates/pdfium/src/lib.rs+++ b/crates/pdfium/src/lib.rs@@ -9,7 +9,7 @@ mod text_page;mod types;pub use bitmap::Bitmap;-pub use document::{Document, FormEnvironment, OutlineEntry, XfaPacket};+pub use document::{Document, FormEnvironment, OutlineEntry, SignatureSummary, XfaPacket};pub use error::PdfiumError;pub use font::{Font, FontType};pub use library::Library;diff --git a/packages/node/README.md b/packages/node/README.mdindex f1972ad..155e44d 100644--- a/packages/node/README.md+++ b/packages/node/README.md@@ -99,8 +99,10 @@ all tagged-PDF roots and recursive elements with type, ID, actual/alternate texttitle, typed attributes, MCIDs, children, and referenced link annotations. Untaggedpages have an empty `roots` array; the field is omitted when disabled.-Every result also carries the document's `/Info` `creator`/`producer` when-present (API-level only, not in CLI JSON), and with `extractContentBounds`+Every result also carries the document's `/Info` `creator`/`producer` and a+`docMeta` provenance object with dates, PDF version/security, signature state,+incremental-save markers, trailer ID comparison, raw XMP (capped at 64 KiB),+and source size. These are API-level only, not in CLI JSON. With `extractContentBounds`each page carries a `contentBounds` union bbox of its top-level contentobjects. With `extractXfaPackets`, `result.xfaPackets` lists each raw XFApacket (index, name, content length, XML content); non-XFA documents yield andiff --git a/packages/node/native.d.ts b/packages/node/native.d.tsindex ad9ad0e..bc52fc7 100644--- a/packages/node/native.d.ts+++ b/packages/node/native.d.ts@@ -319,9 +319,26 @@ export interface JsParseResult {creator?: string/** The document's `/Info` `Producer` entry, when present. */producer?: string+ /** Document-level provenance metadata. */+ docMeta: JsDocumentMetadata/** Raw XFA packets; present only when `extractXfaPackets` is enabled. */xfaPackets?: Array<JsXfaPacket>}+export interface JsDocumentMetadata {+ creationDate?: string+ modDate?: string+ fileVersion?: number+ isEncrypted?: boolean+ securityHandlerRevision?: number+ permissions?: number+ eofSectionCount?: number+ startxrefCount?: number+ trailerIdPairDiffers?: boolean+ rawFileSize?: number+ xmp?: string+ signatureCount?: number+ signatureByteRangeReachesEof?: boolean+}/** One raw packet from an XFA form document's `/XFA` array. */export interface JsXfaPacket {index: numberdiff --git a/packages/node/src/lib.ts b/packages/node/src/lib.tsindex f28e902..16eb162 100644--- a/packages/node/src/lib.ts+++ b/packages/node/src/lib.ts@@ -351,10 +351,32 @@ export interface ParseResult {creator?: string;/** The document's `/Info` `Producer` entry, when present. */producer?: string;+ /** Document-level provenance metadata from PDFium and the source PDF. */+ docMeta: DocumentMetadata;/** Raw XFA packets; present only when `extractXfaPackets` is enabled. */xfaPackets?: XfaPacket[];}+/** Provenance and tamper-analysis facts extracted from the source PDF. */+export interface DocumentMetadata {+ creationDate?: string;+ modDate?: string;+ /** Encoded PDF version (`14` means PDF 1.4). */+ fileVersion?: number;+ isEncrypted?: boolean;+ securityHandlerRevision?: number;+ permissions?: number;+ eofSectionCount?: number;+ startxrefCount?: number;+ trailerIdPairDiffers?: boolean;+ rawFileSize?: number;+ /** Raw XMP packet text, capped at 64 KiB. */+ xmp?: string;+ signatureCount?: number;+ /** False when bytes were appended after a readable signature byte range. */+ signatureByteRangeReachesEof?: boolean;+}+/** One raw packet from an XFA form document's `/XFA` array. */export interface XfaPacket {index: number;@@ -560,6 +582,7 @@ export class LiteParse {formType: result.formType,creator: result.creator,producer: result.producer,+ docMeta: result.docMeta,xfaPackets: result.xfaPackets,};}@@ -584,6 +607,7 @@ export class LiteParse {text: result.text,images: (result.images ?? []).map(toImage),imageErrorCount: result.imageErrorCount ?? 0,+ docMeta: result.docMeta,};}diff --git a/packages/node/src/native.ts b/packages/node/src/native.tsindex cb4d06f..9301a02 100644--- a/packages/node/src/native.ts+++ b/packages/node/src/native.ts@@ -239,9 +239,26 @@ export interface NativeParseResult {formType?: number;creator?: string;producer?: string;+ docMeta: NativeDocumentMetadata;xfaPackets?: NativeXfaPacket[];}+export interface NativeDocumentMetadata {+ creationDate?: string;+ modDate?: string;+ fileVersion?: number;+ isEncrypted?: boolean;+ securityHandlerRevision?: number;+ permissions?: number;+ eofSectionCount?: number;+ startxrefCount?: number;+ trailerIdPairDiffers?: boolean;+ rawFileSize?: number;+ xmp?: string;+ signatureCount?: number;+ signatureByteRangeReachesEof?: boolean;+}+export interface NativeXfaPacket {index: number;name?: string;diff --git a/packages/python/README.md b/packages/python/README.mdindex c552ad3..2380507 100644--- a/packages/python/README.md+++ b/packages/python/README.md@@ -92,6 +92,12 @@ all tagged-PDF roots and recursive elements with type, ID, actual/alternate texttitle, typed attributes, MCIDs, children, and referenced link annotations. Untaggedpages have an empty ``roots`` list; the field is ``None`` when disabled.+Every result also carries ``creator``/``producer`` from the PDF ``/Info``+dictionary and a ``doc_meta`` provenance object with dates, PDF+version/security, signature state, incremental-save markers, trailer ID+comparison, raw XMP (capped at 64 KiB), and source size. These document fields+are API-only and do not alter default CLI JSON.+## Parsing from BytesPass raw PDF bytes directly — useful for web uploads or downloaded files:diff --git a/packages/python/liteparse/__init__.py b/packages/python/liteparse/__init__.pyindex c069726..ef7adc6 100644--- a/packages/python/liteparse/__init__.py+++ b/packages/python/liteparse/__init__.py@@ -13,6 +13,7 @@ from .types import (LiteParseConfig,PageComplexityStats,ParseResult,+ DocumentMetadata,XfaPacket,ParsedPage,TextItem,@@ -38,6 +39,7 @@ __all__ = ["StructureTreeElement","LiteParseConfig","ParseResult",+ "DocumentMetadata","XfaPacket","ParsedPage","TextItem",diff --git a/packages/python/liteparse/parser.py b/packages/python/liteparse/parser.pyindex 3b78f9a..b5c41b0 100644--- a/packages/python/liteparse/parser.py+++ b/packages/python/liteparse/parser.py@@ -20,6 +20,7 @@ from .types import (ParsedPage,ParseError,ParseResult,+ DocumentMetadata,ScreenshotRect,ScreenshotResult,TextItem,@@ -308,6 +309,7 @@ def _convert_native_result(native_result: Any) -> ParseResult:for img in getattr(native_result, "images", [])]native_xfa_packets = getattr(native_result, "xfa_packets", None)+ native_doc_meta = getattr(native_result, "doc_meta", None)return ParseResult(pages=pages,text=native_result.text,@@ -316,6 +318,27 @@ def _convert_native_result(native_result: Any) -> ParseResult:form_type=getattr(native_result, "form_type", None),creator=getattr(native_result, "creator", None),producer=getattr(native_result, "producer", None),+ doc_meta=DocumentMetadata(+ creation_date=getattr(native_doc_meta, "creation_date", None),+ mod_date=getattr(native_doc_meta, "mod_date", None),+ file_version=getattr(native_doc_meta, "file_version", None),+ is_encrypted=getattr(native_doc_meta, "is_encrypted", None),+ security_handler_revision=getattr(+ native_doc_meta, "security_handler_revision", None+ ),+ permissions=getattr(native_doc_meta, "permissions", None),+ eof_section_count=getattr(native_doc_meta, "eof_section_count", None),+ startxref_count=getattr(native_doc_meta, "startxref_count", None),+ trailer_id_pair_differs=getattr(+ native_doc_meta, "trailer_id_pair_differs", None+ ),+ raw_file_size=getattr(native_doc_meta, "raw_file_size", None),+ xmp=getattr(native_doc_meta, "xmp", None),+ signature_count=getattr(native_doc_meta, "signature_count", None),+ signature_byte_range_reaches_eof=getattr(+ native_doc_meta, "signature_byte_range_reaches_eof", None+ ),+ ),xfa_packets=([XfaPacket(diff --git a/packages/python/liteparse/types.py b/packages/python/liteparse/types.pyindex 247e8e1..59eda9e 100644--- a/packages/python/liteparse/types.py+++ b/packages/python/liteparse/types.py@@ -214,6 +214,26 @@ class XfaPacket:content: Optional[str]+@dataclass+class DocumentMetadata:+ """Document-level provenance metadata from PDFium and the source PDF."""+ creation_date: Optional[str] = None+ mod_date: Optional[str] = None+ #: Encoded PDF version (14 means PDF 1.4).+ file_version: Optional[int] = None+ is_encrypted: Optional[bool] = None+ security_handler_revision: Optional[int] = None+ permissions: Optional[int] = None+ eof_section_count: Optional[int] = None+ startxref_count: Optional[int] = None+ trailer_id_pair_differs: Optional[bool] = None+ raw_file_size: Optional[int] = None+ #: Raw XMP packet text, capped at 64 KiB.+ xmp: Optional[str] = None+ signature_count: Optional[int] = None+ signature_byte_range_reaches_eof: Optional[bool] = None++@dataclassclass ParseResult:"""Result of parsing a document."""@@ -227,6 +247,8 @@ class ParseResult:creator: Optional[str] = None#: The document's ``/Info`` ``Producer`` entry, when present.producer: Optional[str] = None+ #: Document-level provenance metadata.+ doc_meta: DocumentMetadata = field(default_factory=DocumentMetadata)#: Raw XFA packets; present only when ``extract_xfa_packets=True``.xfa_packets: Optional[List[XfaPacket]] = None