* export: write RTF through craft-rtf's full writer, from the word model The pages are mapped onto a craft_wordmodel::Document (as_word.rs, the mapping the DOCX export will share), and craft_rtf::doc::export writes it. Over the small writer this keeps, in RTF: - pictures, inline (the engine no longer leaves them out for RTF); - each page's size, as a section per page (blank pages kept); - Heading 1 and 2 styles; - the title; - hard line breaks inside a paragraph or cell (storytold/pdfcraft#4723). It also fixes two bugs: \cellx was the absolute page x, so every column edge sat one left margin too far right, and tables that touched became one (NIST CSF 2.0 came out with 28 tables instead of 68). craft-rtf, craft-wordmodel, craft-docx and craft-mime are pinned together at one craft-libs commit: doc::export takes its own revision's Document. * export: pin craft-libs main with push_text, the header-row fix and the RTF generator name craft-rtf, craft-wordmodel, craft-docx and craft-mime move to craft-libs b8eaa8e2, which has storytold/craft-libs#1946, #1947 and #1950. The mapping appends through Paragraph::push_text/push_object, tables keep the default look, and the RTF names PdfCraft as its generator. * export: write Word through craft-docx, from the shared word model as_docx.rs no longer writes WordprocessingML itself: as_word::word_doc maps the pages onto a craft_wordmodel::Document and craft_docx::write writes it. The decisions stay the same: a page with rotated text or overlapping text keeps its layout as positioned text boxes and pictures (watermark-sized text behind, pictures over it, other text on top), the other pages flow, each page is a section of its own size, a shared page colour is the document's, the PDF's language goes in the slot Word keeps for its script, and the media limits are unchanged. Over the hand-written package this gains: - a VML fallback for every text box, so Word 2007 opens positioned pages; - rotated text as a turned text box Word draws as a line; - the body font named (Arial), with a font table saying it is a sans; - PdfCraft as the application in docProps/app.xml; - a picture drawn many times stored once. The tests that matched XML read the package back through craft-docx. * parity: the Word export through craft-docx, checked in Word 16, Word 2007 and LibreOffice * chore: update Cargo.lock after rebasing #7592 --------- Co-authored-by: kiwi4boy <kiwi4boy@gmail.com>
pdfcraft-engine
The façade every frontend talks to. It holds the open documents, their edit history and the tool catalogue; frontends never reach past it into the parsing, rendering or editing crates.
word_count::count provides cancellable, page-at-a-time Unicode word and character statistics
with optional semantic exclusions; see word-count behavior and limits.
- Layer: L6. It depends on most of L1–L4 and on nothing above itself. No UI toolkit —
egui,winit,eframeandrfdare forbidden below L7, andxtask layersenforces it. - The crate denies
unwrap/expect/panic!/todo!. Entry points that run untrusted-document code keep a last-resortcatch_unwindguard so an escaped panic becomes an error and the user keeps their document.
Two frontends exist on top of it today: pdfcraft-ui-egui (desktop and web) and
pdfcraft-automation (headless tools, the CLI and MCP). Anything one can do, the other must be
able to do — see AGENTS.md §3.
When dynamic XFA layout is active, JsRunner does not initialize Acrobat JavaScript with
scripts from the PDF container's /Names /JavaScript tree. Those scripts belong to the
fallback PDF view and can otherwise show a misleading viewer-compatibility warning.
They remain in the document and in Document::document_scripts. Requested console scripts,
field actions and XFA events can still show messages; ordinary PDFs, static XFA and shells
without an active layout keep their document scripts. Converting XFA to a static form and
undoing that conversion switches the context with the document state.
The editing model
Each open document holds a pdfcraft_cos::Document: the object graph plus a copy-on-write overlay.
- An edit runs on a clone. On success the previous state is pushed onto the undo stack. Clones share all unchanged data, so a snapshot is cheap — this is what makes 100 levels of undo affordable on a 200 MB file.
- After every edit the working file is produced by an incremental write: the original bytes plus one appended revision.
- The view is refreshed from those bytes, so what you see is exactly what Save will write.
- Saving rebases onto the written bytes, so the next save appends only new edits.
Consequences worth preserving: the original bytes of an opened file are never rewritten in place; a full rewrite happens only where it must (redaction, PDF/A conversion, print imposition, a changed password); and unknown data survives a round trip because nothing is reconstructed that wasn't understood.
API
let mut s = Session::new();
let id = s.open("report.pdf", Some(path), bytes, None)?; // -> DocId
s.apply(id, Edit::RotatePages { pages: vec![0], degrees: 90 })?;
let label = s.undo(id)?; // "Rotate pages"
s.redo(id)?;
let doc = s.get(id).ok_or("gone")?; // &Document: queries, never edits
doc.can_undo(); doc.editable(); doc.allows_printing();
doc.text_blocks(page); doc.page_boxes(page); doc.security_summary();
let bytes = s.save_bytes(id)?; // incremental: keeps signatures over earlier revisions valid
let bytes = s.save_full_bytes(id)?; // full rewrite, garbage-collected
s.mark_saved(id, bytes.clone(), path)?;
Edit is one enum of 75 variants — every undoable change in the product, from
RotatePages to AddAnnotation, SetFieldValue, ApplyRedactions and AddWatermark. Adding a
feature means adding a variant and handling it in apply, which is what keeps undo, the dirty
flag, autosave and the automation tools consistent for free.
Session also owns the operations that produce a new document rather than editing one:
create_blank, create_from_images, create_from_text, combine, extract, split,
split_by_size, reduced_bytes, optimized_bytes, print_pdf, export_data, and the signing
family (sign, sign_with_timestamp, timestamp_document, embed_ltv).
Modules
| Module | What it holds |
|---|---|
commands |
The command registry: id, label, menu, shortcut, and a Needs precondition encoding document security. Menus, the ⌘K palette, shortcuts and the control channel all read it, so every surface agrees on what exists and when it is enabled |
catalog |
Acrobat's "All tools" information architecture as data — groups, sections, icons, hues, and an Availability of Ready, Planned(milestone) or Provider. The UI renders what is not built yet, honestly |
actions |
PDF action dispatch (go-to, URI, named, set-layer-state, JavaScript) |
links |
Link creation, properties, and finding URLs in page text |
open_parameters |
A path's PDF open parameters (manual.pdf#nameddest=Intro, #page=12): the file to open and where to show it. The app and doc_open both read them |
js |
The bridge to pdfcraft-js. forms never depends on js directly; the engine injects it, so a build without JavaScript is possible |
xfa, ocr, compare, export |
Façades over the L3/L4 crates of the same names |
AcroForm Keystroke, Validate, Calculate and Format scripts run automatically. Their Print, ShowPanel and SaveAs requests are ignored with a JavaScript console diagnostic; field values, alerts and other requests are retained. Explicit button and console scripts can still request printing (#4088).
Command shortcuts are resolved with CommandSpec::shortcut_for(mac) before displaying or
matching them. The Comments binding is Ctrl+M on Windows/Linux; macOS leaves Command+M
available for the system Minimize action.
Not done here
- Rendering is still borrowed.
pdfcraft-renderwrapshayroand inspects throughlopdf(ADR-0004). The engine only seesinspect() -> DocInfo,RenderPoolandtext::PageText, and that API stays frozen while M2 replaces what is behind it. - Performance budgets (
misc.performance-budgets) are not set or enforced. - Some shipped features are still reachable only from the UI, not through an
automationtool;cargo xtask paritylists them; closing that gap is tracked in the execution plan (D4).
doc.text_edit_preview(page, block) prepares a read-only page background with the selected
paragraph’s glyphs removed, preserving text positioning, images and colours. It shares the
working document’s render configuration and never enters the undo history.