DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
PDF: preserve catalogs and full references in layer variants
andeecollard62a26d9e352e
diff --git a/ROADMAP.md b/ROADMAP.mdindex d3ef17e47..d853936f2 100644--- a/ROADMAP.md+++ b/ROADMAP.md@@ -11,6 +11,10 @@DesignCraft aims at full Adobe InDesign parity — and to be better: faster, open (documented JSON format + IDML), scriptable by agents (MCP), and available on the web.+- **2026-10-23** · PDF layer visibility variants retain catalog/configuration entries and full+ object references; bounded incremental updates replace the existing catalog. Synthetic+ regression tests cover metadata, output-intent references and nonzero generations. No readiness percentage change.+## Status (2026-10-01)**Working today**diff --git a/crates/engine/src/cmd/pdflayers.rs b/crates/engine/src/cmd/pdflayers.rsindex c8badf533..d03aa4e52 100644--- a/crates/engine/src/cmd/pdflayers.rs+++ b/crates/engine/src/cmd/pdflayers.rs@@ -63,31 +63,84 @@ pub(crate) mod tests {/// A one-page PDF (100×100 pt) with two layers: "Blue" (left half) and "Red" (right half).pub(crate) fn two_layer_pdf() -> Vec<u8> {+ two_layer_pdf_generation(0)+ }++ fn two_layer_pdf_generation(generation: i32) -> Vec<u8> {let content = "/OC /a BDC 0 0 1 rg 0 0 50 100 re f EMC /OC /b BDC 1 0 0 rg 50 0 50 100 re f EMC";let objs = [- "<</Type/Catalog/Pages 2 0 R/OCProperties<</OCGs[5 0 R 6 0 R]/D<</Order[5 0 R 6 0 R]>>>>>>".to_string(),+ "<</Type/Catalog/Lang(en-GB)/Metadata 7 0 R/OutputIntents[8 0 R]/Pages 2 0 R/OCProperties<</OCGs[5 0 R 6 0 R]/D<</Order[5 0 R 6 0 R]/Name(Default)/Locked[5 0 R]>>>>>>".to_string(),"<</Type/Pages/Kids[3 0 R]/Count 1>>".to_string(),"<</Type/Page/Parent 2 0 R/MediaBox[0 0 100 100]/Resources<</Properties<</a 5 0 R/b 6 0 R>>>>/Contents 4 0 R>>".to_string(),format!("<</Length {}>>\nstream\n{content}\nendstream", content.len()),"<</Type/OCG/Name(Blue)>>".to_string(),"<</Type/OCG/Name(Red)>>".to_string(),+ "<</Type/Metadata/Subtype/XML/Length 4>>\nstream\n<x/>\nendstream".to_string(),+ "<</Type/OutputIntent/S/GTS_PDFX/OutputConditionIdentifier(Test)>>".to_string(),];let mut out = b"%PDF-1.7\n".to_vec();let mut offs = Vec::new();for (i, o) in objs.iter().enumerate() {offs.push(out.len());- out.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());+ out.extend_from_slice(format!("{} {generation} obj\n{}\nendobj\n", i + 1, o.replace(" 0 R", &format!(" {generation} R"))).as_bytes());}let x = out.len();let mut t = format!("xref\n0 {}\n0000000000 65535 f\r\n", objs.len() + 1);for o in offs {- t.push_str(&format!("{o:010} 00000 n\r\n"));+ t.push_str(&format!("{o:010} {generation:05} n\r\n"));}- t.push_str(&format!("trailer\n<</Size {}/Root 1 0 R>>\nstartxref\n{x}\n%%EOF\n", objs.len() + 1));+ t.push_str(&format!("trailer\n<</Size {}/Root 1 {generation} R>>\nstartxref\n{x}\n%%EOF\n", objs.len() + 1));out.extend_from_slice(t.as_bytes());out}+ #[test]+ fn pdf_layer_update_preserves_catalog_configuration_and_generations() {+ for generation in [0, 1] {+ let original = two_layer_pdf_generation(generation);+ let updated = designcraft_render::pdf_hide_layers(&original, &["Red".into()]).unwrap();+ assert_eq!(designcraft_render::pdf_layers(&updated), vec![("Blue".into(), true), ("Red".into(), false)]);+ let appended = std::str::from_utf8(&updated[original.len()..]).unwrap();+ for token in [+ "/Lang(en-GB)".to_string(),+ format!("/Metadata 7 {generation} R"),+ format!("/OutputIntents[8 {generation} R]"),+ format!("/Locked[5 {generation} R]"),+ "/Name(Default)".into(),+ format!("/Root 1 {generation} R"),+ ] {+ assert!(appended.contains(&token), "missing {token}: {appended}");+ }+ assert!(!appended.contains("9999000"));+ let all_on = designcraft_render::pdf_hide_layers(&updated, &[]).unwrap();+ assert!(designcraft_render::pdf_layers(&all_on).iter().all(|(_, visible)| *visible));+ }+ }++ #[test]+ fn pdf_layer_update_accepts_xref_streams_and_rejects_unsupported_updates() {+ let original = two_layer_pdf();+ let text = std::str::from_utf8(&original).unwrap();+ let offset: usize = text.rsplit_once("startxref").unwrap().1.split_whitespace().next().unwrap().parse().unwrap();+ let mut stream_pdf = original[..offset].to_vec();+ let mut entries = vec![0, 0, 0, 0, 0, 255, 255];+ for number in 1..=9 {+ let at = if number == 9 { offset } else { text.find(&format!("{number} 0 obj")).unwrap() };+ entries.push(1);+ entries.extend_from_slice(&u32::try_from(at).unwrap().to_be_bytes());+ entries.extend_from_slice(&[0, 0]);+ }+ stream_pdf.extend_from_slice(format!("9 0 obj\n<</Type/XRef/Size 10/Root 1 0 R/W[1 4 2]/Length {}>>\nstream\n", entries.len()).as_bytes());+ stream_pdf.extend_from_slice(&entries);+ stream_pdf.extend_from_slice(format!("\nendstream\nendobj\nstartxref\n{offset}\n%%EOF\n").as_bytes());+ let updated = designcraft_render::pdf_hide_layers(&stream_pdf, &["Red".into()]).unwrap();+ assert_eq!(designcraft_render::pdf_layers(&updated), vec![("Blue".into(), true), ("Red".into(), false)]);+ for unsupported in ["/Encrypt null", "/XRefStm 0"] {+ let altered = text.replace("/Size 9", &format!("{unsupported}/Size 9"));+ assert!(designcraft_render::pdf_hide_layers(altered.as_bytes(), &["Red".into()]).is_none());+ }+ }+#[test]fn placed_pdf_layers_hide() {let mut s = Session::new();diff --git a/crates/render/src/pdf_layers.rs b/crates/render/src/pdf_layers.rsindex bc6d864a7..ccf1198d4 100644--- a/crates/render/src/pdf_layers.rs+++ b/crates/render/src/pdf_layers.rs@@ -6,20 +6,17 @@ use std::collections::HashMap;use std::sync::{Arc, Mutex};use craft_pdf::syntax::Pdf;-use craft_pdf::syntax::object::{Array, Dict, Name, ObjectIdentifier};+use craft_pdf::syntax::object::{Array, Dict, MaybeRef, Name, ObjRef, Object, ObjectIdentifier};-/// (object number, name, on by default) of each layer.-fn ocgs(pdf: &Pdf) -> Vec<(i32, String, bool)> {+/// (object reference, name, on by default) of each layer.+fn ocgs(pdf: &Pdf) -> Vec<(ObjRef, String, bool)> {let xref = pdf.xref();let Some(cat) = xref.get::<Dict<'_>>(xref.root_id()) else { return vec![] };let Some(ocp) = cat.get::<Dict<'_>>(b"OCProperties") else { return vec![] };let Some(list) = ocp.get::<Array<'_>>(b"OCGs") else { return vec![] };let cfg = ocp.get::<Dict<'_>>(b"D");- let ids_in = |key: &[u8]| -> Vec<i32> {- cfg.as_ref()- .and_then(|c| c.get::<Array<'_>>(key))- .map(|a| a.raw_iter().filter_map(|o| o.as_obj_ref()).map(|r| r.obj_number).collect())- .unwrap_or_default()+ let ids_in = |key: &[u8]| -> Vec<ObjRef> {+ cfg.as_ref().and_then(|c| c.get::<Array<'_>>(key)).map(|a| a.raw_iter().filter_map(|o| o.as_obj_ref()).collect()).unwrap_or_default()};let base_off = cfg.as_ref().and_then(|c| c.get::<Name<'_>>(b"BaseState")).is_some_and(|n| n.as_ref() == b"OFF");let (on, off) = (ids_in(b"ON"), ids_in(b"OFF"));@@ -31,8 +28,8 @@ fn ocgs(pdf: &Pdf) -> Vec<(i32, String, bool)> {.get::<craft_pdf::syntax::object::String<'_>>(b"Name").map(|s| String::from_utf8_lossy(s.as_bytes()).to_string()).unwrap_or_default();- let visible = if base_off { on.contains(&r.obj_number) } else { !off.contains(&r.obj_number) };- Some((r.obj_number, name, visible))+ let visible = if base_off { on.contains(&r) } else { !off.contains(&r) };+ Some((r, name, visible))}).collect()}@@ -42,62 +39,179 @@ pub fn pdf_layers(bytes: &[u8]) -> Vec<(String, bool)> {craft_pdf::open_slice(bytes, None).map(|p| ocgs(&p).into_iter().map(|(_, n, v)| (n, v)).collect()).unwrap_or_default()}-/// `bytes` with exactly the layers named in `hidden` off (the others on). `None` when the file-/// has no such layers or can't be read.+// Copy untouched dictionary entries as raw PDF tokens. In particular, do not reinterpret+// strings, numbers or unknown extension keys. The parser bounds container nesting.+fn patch_dict(dict: &Dict<'_>, updates: &[(&[u8], &[u8])]) -> Option<Vec<u8>> {+ use craft_pdf::syntax::reader::{Reader, ReaderExt};+ let data = if dict.is_empty() { b"<<>>".as_slice() } else { dict.data() };+ if data.len() > 4 * 1024 * 1024 {+ return None;+ }+ let mut reader = Reader::new(data);+ reader.forward_tag(b"<<")?;+ let mut out = b"<<".to_vec();+ let mut ended = false;+ for _ in 0..100_000 {+ reader.skip_white_spaces_and_comments();+ if reader.forward_tag(b">>").is_some() {+ ended = true;+ break;+ }+ let start = reader.offset();+ let name = reader.read_without_context::<Name<'_>>()?;+ reader.skip_white_spaces_and_comments();+ reader.skip::<MaybeRef<Object<'_>>>(false)?;+ if !updates.iter().any(|(key, _)| *key == name.as_ref()) {+ out.push(b' ');+ out.extend_from_slice(data.get(start..reader.offset())?);+ }+ }+ if !ended {+ return None;+ }+ for (key, value) in updates {+ if !value.is_empty() {+ out.extend_from_slice(b" /");+ out.extend_from_slice(key);+ out.push(b' ');+ out.extend_from_slice(value);+ }+ }+ out.extend_from_slice(b" >>");+ Some(out)+}++fn trailer_at(bytes: &[u8], offset: usize) -> Option<Dict<'_>> {+ use craft_pdf::syntax::reader::{Reader, ReaderExt};+ let data = bytes.get(offset..)?;+ let mut reader = Reader::new(data);+ if data.starts_with(b"xref") {+ let pos = data.get(..data.len().min(4 * 1024 * 1024))?.windows(7).position(|w| w == b"trailer")?;+ reader.skip_bytes(pos.checked_add(7)?)?;+ } else {+ // An xref stream's dictionary also holds the trailer entries.+ reader.read_without_context::<ObjectIdentifier>()?;+ }+ reader.skip_white_spaces_and_comments();+ reader.read_without_context::<Dict<'_>>()+}++/// `bytes` with exactly the layers named in `hidden` off (the others on).+/// Returns `None` for unreadable, encrypted, hybrid-reference or over-budget updates.+/// Untouched catalog/configuration entries and full object references are preserved.pub fn pdf_hide_layers(bytes: &[u8], hidden: &[String]) -> Option<Vec<u8>> {+ crate::check_pdf_input_size(bytes.len()).ok()?;let pdf = craft_pdf::open_slice(bytes, None).ok()?;let layers = ocgs(&pdf);if layers.is_empty() {return None;}+ let tail = String::from_utf8_lossy(bytes.get(bytes.len().saturating_sub(1024)..)?);+ let prev = tail.rsplit_once("startxref")?.1.split_whitespace().next()?.parse::<usize>().ok()?;+ let trailer = trailer_at(bytes, prev)?;+ // Do not copy decrypted dictionaries into an encrypted file, or ignore a hybrid+ // xref table. Follow bounded Prev links because encryption can be inherited.+ let mut offset = Some(prev);+ for _ in 0..32 {+ let Some(at) = offset else { break };+ let t = trailer_at(bytes, at)?;+ if t.contains_key(b"Encrypt") || t.contains_key(b"XRefStm") {+ return None;+ }+ offset = t.get::<usize>(b"Prev");+ if offset.is_some_and(|n| n >= at) {+ return None;+ }+ }+ if offset.is_some() {+ return None;+ }let xref = pdf.xref();- let cat = xref.get::<Dict<'_>>(xref.root_id())?;- let pages = cat.get_ref(b"Pages")?;- let all: Vec<String> = layers.iter().map(|(n, _, _)| format!("{n} 0 R")).collect();- let off: Vec<String> = layers.iter().filter(|(_, name, _)| hidden.contains(name)).map(|(n, _, _)| format!("{n} 0 R")).collect();- // A new catalog under a fresh object number, with the original's page tree.- let root = 9_999_000;- let mut out = bytes.to_vec();- if !out.ends_with(b"\n") {- out.push(b'\n');+ let root = xref.root_id();+ if root.obj_number <= 0 || !(0..=65535).contains(&root.gen_number) || trailer.get::<usize>(b"Size")? <= usize::try_from(root.obj_number).ok()? {+ return None;+ }+ let cat = xref.get::<Dict<'_>>(root)?;+ let ocp = cat.get::<Dict<'_>>(b"OCProperties")?;+ let cfg = ocp.get::<Dict<'_>>(b"D");+ let mut off = b"[".to_vec();+ for (id, name, _) in &layers {+ if hidden.contains(name) {+ off.extend_from_slice(format!("{} {} R ", id.obj_number, id.gen_number).as_bytes());+ }}+ off.push(b']');+ let empty = Dict::empty();+ let cfg = patch_dict(cfg.as_ref().unwrap_or(&empty), &[(b"BaseState", b"/ON"), (b"ON", b"[]"), (b"OFF", &off)])?;+ let ocp = patch_dict(&ocp, &[(b"D", &cfg)])?;+ let catalog = patch_dict(&cat, &[(b"OCProperties", &ocp)])?;+ let root_ref = format!("{} {} R", root.obj_number, root.gen_number);+ let prev_value = prev.to_string();+ let trailer = patch_dict(+ &trailer,+ &[+ (b"Root", root_ref.as_bytes()),+ (b"Prev", prev_value.as_bytes()),+ (b"Type", b""),+ (b"Length", b""),+ (b"Filter", b""),+ (b"DecodeParms", b""),+ (b"W", b""),+ (b"Index", b""),+ ],+ )?;+ let mut out = bytes.to_vec();+ out.push(b'\n');let at = out.len();- out.extend_from_slice(- format!(- "{root} 0 obj\n<</Type/Catalog/Pages {} {} R/OCProperties<</OCGs[{}]/D<</BaseState/ON/OFF[{}]>>>>>>\nendobj\n",- pages.obj_number,- pages.gen_number,- all.join(" "),- off.join(" ")- )- .as_bytes(),- );+ // Redefine the existing catalog: no arbitrary fresh object number or Size increase.+ out.extend_from_slice(format!("{} {} obj\n", root.obj_number, root.gen_number).as_bytes());+ out.extend_from_slice(&catalog);+ out.extend_from_slice(b"\nendobj\n");let xref_at = out.len();- let prev = {- let tail = String::from_utf8_lossy(&bytes[bytes.len().saturating_sub(1024)..]).to_string();- tail.rsplit_once("startxref").and_then(|(_, t)| t.split_whitespace().next()).and_then(|n| n.parse::<usize>().ok())?- };- out.extend_from_slice(- format!("xref\n{root} 1\n{at:010} 00000 n\r\ntrailer\n<</Size {}/Root {root} 0 R/Prev {prev}>>\nstartxref\n{xref_at}\n%%EOF\n", root + 1)- .as_bytes(),- );+ out.extend_from_slice(format!("xref\n{} 1\n{at:010} {:05} n\r\ntrailer\n", root.obj_number, root.gen_number).as_bytes());+ out.extend_from_slice(&trailer);+ out.extend_from_slice(format!("\nstartxref\n{xref_at}\n%%EOF\n").as_bytes());Some(out)}/// Shared copies of layer variants (by source address and hidden set).pub(crate) fn layered(data: &Arc<Vec<u8>>, hidden: &[String]) -> Arc<Vec<u8>> {type Key = (usize, Vec<String>);- static CACHE: Mutex<Option<HashMap<Key, Arc<Vec<u8>>>>> = Mutex::new(None);+ static CACHE: Mutex<Option<HashMap<Key, (Arc<Vec<u8>>, Arc<Vec<u8>>)>>> = Mutex::new(None);let key = (Arc::as_ptr(data) as usize, hidden.to_vec());let mut c = CACHE.lock().unwrap_or_else(|e| e.into_inner());let map = c.get_or_insert_with(HashMap::new);if let Some(v) = map.get(&key) {- return v.clone();+ return v.1.clone();}if map.len() > 64 {map.clear();}let v = pdf_hide_layers(data, hidden).map(Arc::new).unwrap_or_else(|| data.clone());- map.insert(key, v.clone());+ map.insert(key, (data.clone(), v.clone()));v}++#[cfg(test)]+mod tests {+ use super::*;+ use craft_pdf::syntax::reader::{Reader, ReaderExt};++ #[test]+ fn dictionary_patch_preserves_raw_values_and_bounds_updates() {+ let data = b"<</Unknown[(x) 12 1 R <ff>]/Base#53tate/OFF/Name(a(b)c)>>";+ let dict = Reader::new(data).read_without_context::<Dict<'_>>().unwrap();+ let out = patch_dict(&dict, &[(b"BaseState", b"/ON")]).unwrap();+ let text = std::str::from_utf8(&out).unwrap();+ assert!(text.contains("/Unknown[(x) 12 1 R <ff>]"));+ assert!(text.contains("/Name(a(b)c)"));+ assert!(!text.contains("/OFF"));+ assert!(text.contains("/BaseState /ON"));+ assert_eq!(patch_dict(&Dict::empty(), &[(b"BaseState", b"/ON")]).unwrap(), b"<< /BaseState /ON >>");+ let mut many = b"<< /Big (".to_vec();+ many.resize(4 * 1024 * 1024 + 1, b'x');+ many.extend_from_slice(b") >>");+ let dict = Reader::new(&many).read_without_context::<Dict<'_>>().unwrap();+ assert!(patch_dict(&dict, &[]).is_none());+ }+}diff --git a/docs/gaps.md b/docs/gaps.mdindex 5738d14c4..8591e39bc 100644--- a/docs/gaps.md+++ b/docs/gaps.md@@ -190,6 +190,9 @@ Kind: **F** feature · **U** UI/UX · **T** typography · **FF** file format ·- **Estimate:** 20–35 h.### 19. Placed graphics depth (FF)+- **Safety:** PDF visibility variants preserve catalog/configuration entries and nonzero-generation+ references, redefining the existing catalog rather than choosing an arbitrary object number.+ Encrypted, hybrid-reference and over-budget rewrites are rejected; no print-fidelity claim.- **Missing:** EPS is shown through its preview only (no PostScript interpreter); PSD layercomps beyond visibility; the Clipping Path Options dialog (tracing into a clip that keeps theframe, Threshold/Tolerance/Inset Frame preview, picking an alpha channel or a path saved in a