Skip to content

A fast, helpful, and open-source document parser

feat: expose PDF document provenance metadata

Pierre-Loic doulcet975790517a00
diff --git a/README.md b/README.md
index 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 packets
Parse 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 a
per-page `content_bounds`: the union bbox of the page's top-level content
objects in viewport coords (absent for empty pages). Enable
diff --git a/crates/liteparse-napi/src/types.rs b/crates/liteparse-napi/src/types.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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-threaded
diff --git a/crates/pdfium-sys/bindings.rs b/crates/pdfium-sys/bindings.rs
index 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.rs
index 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.h
index 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.rs
index 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.rs
index 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.md
index 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 text
title, typed attributes, MCIDs, children, and referenced link annotations. Untagged
pages 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 content
objects. With `extractXfaPackets`, `result.xfaPackets` lists each raw XFA
packet (index, name, content length, XML content); non-XFA documents yield an
diff --git a/packages/node/native.d.ts b/packages/node/native.d.ts
index 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: number
diff --git a/packages/node/src/lib.ts b/packages/node/src/lib.ts
index 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.ts
index 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.md
index 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 text
title, typed attributes, MCIDs, children, and referenced link annotations. Untagged
pages 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 Bytes
Pass raw PDF bytes directly — useful for web uploads or downloaded files:
diff --git a/packages/python/liteparse/__init__.py b/packages/python/liteparse/__init__.py
index 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.py
index 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.py
index 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
+
+
@dataclass
class 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