IDML: Keep Lines Together defaults to start/end of paragraph

Keep Lines Together now defaults to "At Start/End of Paragraph" (2/2):
new paragraphs, and IDML that sets Keep Lines Together without
KeepAllLinesTogether anywhere in the style chain, keep lines at the
start and end instead of moving the whole paragraph.

The native format is now version 2. Loading a version-1 document pins
"all lines" where that document resolved it from the old default (the
start of each paragraph style chain that leaves it unset, and
paragraphs whose style is missing), so saved documents keep their
layout.

ROADMAP.md

@@ -6,13 +6,13 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
 
 **Working today**
 - Document model: facing/non-facing spreads, parent pages with page-number markers, sections, layers, frames (text / graphic / unassigned), threaded stories, paragraph/character/object styles with based-on, swatches (process/spot/tints/gradients), corner options, text wrap, drop shadow, opacity/blend.
-- Text engine: Knuth–Plass paragraph composer and single-line composer, dictionary hyphenation (public-domain Moby list + our own trained Liang patterns), justification with word/letter/glyph-scaling ranges, keep options (keep with next, keep lines together, widows/orphans), balance ragged lines, optical margin alignment, hyphenation zone/limit, columns, threading across frames and spreads, tabs, bullets/numbering, rules, shading, baseline grid, first-baseline options, vertical justification, wrap exclusions, overset detection, caret/hit testing.
+- Text engine: Knuth–Plass paragraph composer and single-line composer, dictionary hyphenation (public-domain Moby list + our own trained Liang patterns), justification with word/letter/glyph-scaling ranges, keep options (keep with next, keep lines together — at start/end of paragraph by default, as in InDesign — widows/orphans), balance ragged lines, optical margin alignment, hyphenation zone/limit, columns, threading across frames and spreads, tabs, bullets/numbering, rules, shading, baseline grid, first-baseline options, vertical justification, wrap exclusions, overset detection, caret/hit testing.
 - Rendering: vello_cpu (SIMD, multithreaded) — pages, items, images with mip levels, gradients, composed text.
 - UI (egui): application bar + menus, Control panel (object and text modes), Tools panel with flyouts, document tabs, rulers, pasteboard, guides (margins, columns, bleed, baseline grid), frame edges, selection handles, text ports and threads, Properties / Pages / Layers dock, Swatches, Styles, Character, Paragraph, Stroke, Text Wrap panels, New Document and Preferences dialogs, Quick Apply (⌘Return), 4 brightness themes.
 - Pen tool, Direct Selection anchor/handle editing, rotate from corners, Rotate/Scale/Shear tools, Eyedropper, snapping & smart guides, Align/Distribute, Find/Change (text + GREP), Story Editor, Paragraph Style Options, Effects panel, hidden characters, native macOS menu bar, measured InDesign 2026 look (Medium Dark): Properties sections per selection state, 21 pt spinner fields with arithmetic, Contextual Task Bar, inverse (black) text selection, Pages panel with drag-and-drop reorder / parent apply, Layers panel with per-object rows.
 - Tools: Selection (click, marquee, move, Alt-duplicate, resize handles), Direct Selection, Type (draw frame, click caret, select, type), Rectangle/Ellipse/Polygon (+ frame variants), Line, Hand, Zoom.
 - PDF export (krilla): real selectable text with embedded font subsets, DeviceCMYK/RGB + spot Separations, bleed boxes, crop/bleed marks + page info, pages or spreads, PDF/A-2b (PDF/X-4 output intent pending) — `file.exportPdf`, File › Export PDF…, `designcraft-cli run --export out.pdf`.
-- IDML interchange (`designcraft-idml`): export and import of swatches, styles, fonts, preferences, parent spreads, spreads/pages, frames, groups, images (embedded or linked), formatted threaded stories — opens in InDesign 2026 and round-trips InDesign-exported files (`file.exportIdml`, `file.openIdml`, File → Export IDML…, CLI `--in x.idml` / `--export x.idml`).
+- IDML interchange (`designcraft-idml`): export and import of swatches, styles, fonts, preferences, parent spreads, spreads/pages, frames, groups, images (embedded or linked), formatted threaded stories; attributes a file leaves unset take InDesign's defaults (Keep Lines Together at start/end of paragraph) — opens in InDesign 2026 and round-trips InDesign-exported files (`file.exportIdml`, `file.openIdml`, File → Export IDML…, CLI `--in x.idml` / `--export x.idml`).
 - Tables (M8): tables anchored in stories (header/footer/body rows, merged cells, per-edge strokes, fills + alternating fills, insets, vertical justification, at-least/exact row heights); composed into the text column (columns scale to fit, rows break across columns/frames with repeating headers/footers, overset); rendered, exported to PDF (real text) and IDML (export + import); Table menu, Table panel, Create Table dialog, caret/typing/Tab navigation and cell selection in cells; `table.*` commands.
 - Hyperlinks (text or frames → URL / e-mail / page) and bookmarks, exported as PDF link annotations and outline.
 - EPUB 3 (reflowable) export: stories in reading order, CSS from paragraph/character styles, images, navigation (`file.exportEpub`, CLI `--export x.epub`).

crates/compose/src/tests.rs

@@ -592,7 +592,11 @@ fn keep_lines_together_moves_the_paragraph() {
     let (mut d, sid, _) = keep_doc(n - 3, &[&long], h);
     let cs = compose_story(&d, sid, &ComposeOptions::default());
     assert!(column_of_para(&cs, n - 3).contains(&0));
-    d.story_mut(sid).unwrap().paras[n - 3].para.keep_lines_together = Some(true);
+    {
+        let p = &mut d.story_mut(sid).unwrap().paras[n - 3].para;
+        p.keep_lines_together = Some(true);
+        p.keep_all_lines = Some(true);
+    }
     let cs = compose_story(&d, sid, &ComposeOptions::default());
     assert!(column_of_para(&cs, n - 3).iter().all(|&c| c == 1));
 }

crates/doc/src/attrs.rs

@@ -608,7 +608,8 @@ attr_set! {
         // Keeps
         keep_with_next: u32 = 0,
         keep_lines_together: bool = false,
-        keep_all_lines: bool = true,
+        /// All lines in paragraph (true) or at start/end of paragraph (false).
+        keep_all_lines: bool = false,
         keep_first: u32 = 2,
         keep_last: u32 = 2,
         start_paragraph: StartParagraph = StartParagraph::Anywhere,

crates/doc/src/styles.rs

@@ -273,8 +273,8 @@ impl Styles {
         self.object.iter().find(|s| s.name == name)
     }
 
-    /// The paragraph style chain from root to `name` (cycle-safe).
-    fn para_chain(&self, name: &str) -> Vec<&ParagraphStyle> {
+    /// The paragraph style chain from root to `name` (cycle-safe): resolution starts at its first.
+    pub fn para_chain(&self, name: &str) -> Vec<&ParagraphStyle> {
         let mut chain = Vec::new();
         let mut cur = self.para(name);
         while let Some(s) = cur {

crates/engine/src/tests_idml.rs

@@ -91,6 +91,91 @@ fn magazine_round_trips_through_idml() {
     assert_eq!(items(&again.spreads).len(), items(&back.spreads).len());
 }
 
+/// A one-page IDML package: two threaded frames side by side, 19 lines each (10 pt on 12 pt),
+/// paragraphs of `lines` forced-break lines in style `Body`, which carries `body_attrs`.
+fn keep_lines_idml(body_attrs: &str, lines: &[usize]) -> Vec<u8> {
+    use std::io::Write;
+    let paras: String = lines
+        .iter()
+        .enumerate()
+        .map(|(p, &n)| {
+            let text = (0..n).map(|k| format!("P{p} line {k}")).collect::<Vec<_>>().join("\u{2028}");
+            format!(
+                r#"<ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/Body"><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>{text}</Content>{}</CharacterStyleRange></ParagraphStyleRange>"#,
+                if p + 1 < lines.len() { "<Br/>" } else { "" }
+            )
+        })
+        .collect();
+    let frame = |me: &str, x: f64, prev: &str, next: &str| {
+        let pts: String = [(x, 36.0), (x, 276.0), (x + 180.0, 276.0), (x + 180.0, 36.0)]
+            .iter()
+            .map(|(x, y)| format!(r#"<PathPointType Anchor="{x} {y}" LeftDirection="{x} {y}" RightDirection="{x} {y}"/>"#))
+            .collect();
+        format!(
+            r#"<TextFrame Self="{me}" ParentStory="s1" PreviousTextFrame="{prev}" NextTextFrame="{next}" ItemTransform="1 0 0 1 0 0"><Properties><PathGeometry><GeometryPathType PathOpen="false"><PathPointArray>{pts}</PathPointArray></GeometryPathType></PathGeometry></Properties></TextFrame>"#
+        )
+    };
+    let designmap = format!(
+        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Document xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0" Self="d">
+<DocumentPreference PageWidth="450" PageHeight="312" FacingPages="false"/>
+<RootCharacterStyleGroup Self="rc"><CharacterStyle Self="CharacterStyle/$ID/[No character style]" Name="$ID/[No character style]"/></RootCharacterStyleGroup>
+<RootParagraphStyleGroup Self="rp">
+<ParagraphStyle Self="ParagraphStyle/$ID/[No paragraph style]" Name="$ID/[No paragraph style]" PointSize="12"/>
+<ParagraphStyle Self="ParagraphStyle/Body" Name="Body" PointSize="10" {body_attrs}><Properties><BasedOn type="object">ParagraphStyle/$ID/[No paragraph style]</BasedOn><Leading type="unit">12</Leading></Properties></ParagraphStyle>
+</RootParagraphStyleGroup>
+<Story Self="s1">{paras}</Story>
+<Spread Self="sp1" ItemTransform="1 0 0 1 0 0"><Page Self="p1" GeometricBounds="0 0 312 450" ItemTransform="1 0 0 1 0 0"/>{}{}</Spread>
+</Document>"#,
+        frame("t1", 36.0, "n", "t2"),
+        frame("t2", 234.0, "t1", "n")
+    );
+    let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    let stored = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    w.start_file("mimetype", stored).unwrap();
+    w.write_all(b"application/vnd.adobe.indesign-idml-package").unwrap();
+    w.start_file("designmap.xml", zip::write::SimpleFileOptions::default()).unwrap();
+    w.write_all(designmap.as_bytes()).unwrap();
+    w.finish().unwrap().into_inner()
+}
+
+/// Lines of paragraph `para` in each frame of the story.
+fn para_lines_per_frame(d: &Document, para: usize) -> Vec<usize> {
+    let sid = *d.stories.keys().next().unwrap();
+    let cs = designcraft_compose::compose_story(d, sid, &Default::default());
+    cs.frames.iter().map(|f| f.lines.iter().filter(|l| l.para == para).count()).collect()
+}
+
+/// Keep Lines Together without a mode in the IDML: InDesign's default, at start/end of paragraph.
+/// A 10-line paragraph starting 6 lines above the first frame's bottom splits 6/4.
+#[test]
+fn idml_keep_lines_without_mode_split_at_start_and_end() {
+    let keep = r#"KeepLinesTogether="true" KeepFirstLines="2" KeepLastLines="2""#;
+    let d = designcraft_idml::import_idml(&keep_lines_idml(keep, &[13, 10, 2])).unwrap();
+    assert_eq!(para_lines_per_frame(&d, 0), [13, 0]);
+    assert_eq!(para_lines_per_frame(&d, 1), [6, 4]);
+    // All lines in paragraph, written explicitly: the paragraph moves whole.
+    let d = designcraft_idml::import_idml(&keep_lines_idml(&format!(r#"{keep} KeepAllLinesTogether="true""#), &[13, 10, 2])).unwrap();
+    assert_eq!(para_lines_per_frame(&d, 1), [0, 10]);
+}
+
+/// A document saved in format 1 with Keep Lines Together and no mode still keeps all lines
+/// together after loading; saved now, it keeps lines at start/end of paragraph.
+#[test]
+fn format_1_keep_lines_without_mode_lays_out_all_lines() {
+    use std::io::Write;
+    let d = designcraft_idml::import_idml(&keep_lines_idml(r#"KeepLinesTogether="true""#, &[13, 10, 2])).unwrap();
+    let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    w.start_file("meta.json", zip::write::SimpleFileOptions::default()).unwrap();
+    w.write_all(br#"{"format": "designcraft", "version": 1}"#).unwrap();
+    w.start_file("document.json", zip::write::SimpleFileOptions::default()).unwrap();
+    w.write_all(&serde_json::to_vec(&d).unwrap()).unwrap();
+    let v1 = designcraft_format::load(&w.finish().unwrap().into_inner()).unwrap();
+    assert_eq!(para_lines_per_frame(&v1, 1), [0, 10]);
+    let now = designcraft_format::load(&designcraft_format::save(&d).unwrap()).unwrap();
+    assert_eq!(para_lines_per_frame(&now, 1), [6, 4]);
+}
+
 #[test]
 fn idml_commands() {
     let mut s = Session::new();

crates/format/src/lib.rs

@@ -5,18 +5,19 @@
 //! - `assets/<id>.<ext>`: embedded placed files, byte-for-byte
 //! - `meta.json`: format version and generator
 //!
-//! Older single-file JSON documents (assets as base64 in `assetData`) still open.
+//! Older single-file JSON documents (assets as base64 in `assetData`) still open. Documents
+//! from older format versions are upgraded on load so they lay out as they did.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![forbid(unsafe_code)]
 
 use std::io::{Cursor, Read, Write};
 use std::sync::Arc;
 
-use designcraft_doc::{AssetId, Document};
+use designcraft_doc::{AssetId, Document, Story};
 use serde_json::{Value, json};
 
 pub const MIME: &str = "application/vnd.designcraft+zip";
-pub const VERSION: u32 = 1;
+pub const VERSION: u32 = 2;
 
 #[derive(Debug, thiserror::Error)]
 pub enum FormatError {
@@ -87,12 +88,12 @@ fn load_zip(bytes: &[u8]) -> Result<Document, FormatError> {
         f.read_to_end(&mut v).ok()?;
         Some(v)
     };
-    if let Some(meta) = read(&mut z, "meta.json")
-        && let Ok(m) = serde_json::from_slice::<Value>(&meta)
-        && let Some(v) = m.get("version").and_then(Value::as_u64)
-        && v as u32 > VERSION
-    {
-        return Err(FormatError::TooNew(v as u32));
+    let version = read(&mut z, "meta.json")
+        .and_then(|meta| serde_json::from_slice::<Value>(&meta).ok())
+        .and_then(|m| m.get("version").and_then(Value::as_u64))
+        .map_or(1, |v| u32::try_from(v).unwrap_or(u32::MAX));
+    if version > VERSION {
+        return Err(FormatError::TooNew(version));
     }
     let json = read(&mut z, "document.json").ok_or_else(|| FormatError::NotOurs("missing document.json".into()))?;
     let mut doc: Document = serde_json::from_slice(&json).map_err(|e| FormatError::NotOurs(e.to_string()))?;
@@ -104,10 +105,51 @@ fn load_zip(bytes: &[u8]) -> Result<Document, FormatError> {
             Arc::make_mut(a).data = Arc::new(data);
         }
     }
+    upgrade(&mut doc, version);
     doc.check().map_err(|e| FormatError::NotOurs(e.to_string()))?;
     Ok(doc)
 }
 
+/// Bring a document saved in format `from` up to [`VERSION`].
+fn upgrade(doc: &mut Document, from: u32) {
+    if from < 2 {
+        pin_keep_all_lines(doc);
+    }
+}
+
+/// Format 1 laid out an unset Keep Lines Together mode as all lines in paragraph. Pin that where
+/// nothing set it: at the start of each paragraph style chain, and on paragraphs whose style is
+/// missing.
+fn pin_keep_all_lines(doc: &mut Document) {
+    let roots: std::collections::HashSet<String> = doc
+        .styles
+        .paragraph
+        .iter()
+        .filter_map(|s| {
+            let chain = doc.styles.para_chain(&s.name);
+            if chain.iter().any(|c| c.para.keep_all_lines.is_some()) { None } else { chain.first().map(|c| c.name.clone()) }
+        })
+        .collect();
+    if !roots.is_empty() {
+        for s in doc.styles_mut().paragraph.iter_mut().filter(|s| roots.contains(&s.name)) {
+            s.para.keep_all_lines = Some(true);
+        }
+    }
+    let styles = doc.styles.clone();
+    let mut pin = |st: &mut Story| {
+        for p in st.paras.iter_mut().filter(|p| p.para.keep_all_lines.is_none() && styles.para(&p.style).is_none()) {
+            p.para.keep_all_lines = Some(true);
+        }
+    };
+    for st in doc.stories.values_mut() {
+        let st = Arc::make_mut(st);
+        st.for_each_text_mut(&mut pin);
+        for n in &mut st.endnotes {
+            Arc::make_mut(n).text.for_each_text_mut(&mut pin);
+        }
+    }
+}
+
 fn load_legacy_json(bytes: &[u8]) -> Result<Document, FormatError> {
     let v: Value = serde_json::from_slice(bytes).map_err(|e| FormatError::NotOurs(e.to_string()))?;
     let mut doc: Document = serde_json::from_value(v.clone()).map_err(|e| FormatError::NotOurs(e.to_string()))?;
@@ -120,6 +162,7 @@ fn load_legacy_json(bytes: &[u8]) -> Result<Document, FormatError> {
             }
         }
     }
+    upgrade(&mut doc, 1);
     doc.check().map_err(|e| FormatError::NotOurs(e.to_string()))?;
     Ok(doc)
 }
@@ -179,6 +222,72 @@ mod tests {
         assert_eq!(back.stories, d.stories);
     }
 
+    /// `doc` as format 1 wrote it.
+    fn save_v1(doc: &Document) -> Vec<u8> {
+        let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
+        z.start_file("meta.json", zip::write::SimpleFileOptions::default()).unwrap();
+        z.write_all(br#"{"format": "designcraft", "version": 1}"#).unwrap();
+        z.start_file("document.json", zip::write::SimpleFileOptions::default()).unwrap();
+        z.write_all(&serde_json::to_vec(doc).unwrap()).unwrap();
+        z.finish().unwrap().into_inner()
+    }
+
+    fn para_style(name: &str, based_on: Option<&str>, keep_all_lines: Option<bool>) -> designcraft_doc::ParagraphStyle {
+        designcraft_doc::ParagraphStyle {
+            name: name.into(),
+            based_on: based_on.map(str::to_string),
+            next_style: None,
+            para: designcraft_doc::ParaAttrs { keep_lines_together: Some(true), keep_all_lines, ..Default::default() },
+            chars: Default::default(),
+            shortcut: String::new(),
+        }
+    }
+
+    /// Format 1 resolved an unset Keep Lines Together mode as all lines: those documents still
+    /// do after loading, wherever the mode comes from. New documents keep lines at start/end.
+    #[test]
+    fn format_1_keep_lines_without_mode_stays_all_lines() {
+        let mut d = Document::new(&NewDocument::default());
+        let st = d.styles_mut();
+        st.paragraph.push(para_style("Root", None, None));
+        st.paragraph.push(para_style("Child", Some("Root"), None));
+        st.paragraph.push(para_style("Explicit", None, Some(false)));
+        st.paragraph.push(para_style("Under explicit", Some("Explicit"), None));
+        st.paragraph.push(para_style("Loop A", Some("Loop B"), None));
+        st.paragraph.push(para_style("Loop B", Some("Loop A"), None));
+        let lid = d.default_layer();
+        let names = [designcraft_doc::story::BASIC_PARAGRAPH, "Root", "Child", "Explicit", "Under explicit", "Loop A", "Loop B", "Missing"];
+        let text = names.join("\n");
+        let (_, sid) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(10.0, 10.0, 200.0, 200.0), lid, &text, ParaFormat::default()).unwrap();
+        {
+            let s = d.story_mut(sid).unwrap();
+            for (p, name) in s.paras.iter_mut().zip(names) {
+                p.style = name.into();
+                p.para.keep_lines_together = Some(true);
+            }
+            s.insert_note(1, "Note", ParaFormat { style: "Missing".into(), ..Default::default() });
+        }
+        let back = load(&save_v1(&d)).unwrap();
+        let resolve = |f: &ParaFormat| back.styles.resolve_para(f).0;
+        let story = back.story(sid).unwrap();
+        for (p, name) in story.paras.iter().zip(names) {
+            let pp = resolve(p);
+            assert!(pp.keep_lines_together);
+            assert_eq!(pp.keep_all_lines, !name.contains("xplicit"), "{name}");
+        }
+        assert!(resolve(&story.notes[0].text.paras[0]).keep_all_lines, "footnote with a missing style");
+        assert!(back.styles.resolve_para_style("Loop A").0.keep_all_lines && back.styles.resolve_para_style("Loop B").0.keep_all_lines);
+        // Pinned where the chains start; explicit and inheriting styles are left as they were.
+        assert_eq!(back.styles.para("Root").unwrap().para.keep_all_lines, Some(true));
+        assert_eq!(back.styles.para("Child").unwrap().para.keep_all_lines, None);
+        assert_eq!(back.styles.para("Under explicit").unwrap().para.keep_all_lines, None);
+        // The current format keeps the new default: at start/end of paragraph.
+        let now = load(&save(&d).unwrap()).unwrap();
+        let p = &now.story(sid).unwrap().paras[0];
+        assert!(!now.styles.resolve_para(p).0.keep_all_lines);
+        assert!(!designcraft_doc::ParaProps::default().keep_all_lines);
+    }
+
     #[test]
     fn rejects_garbage_and_newer_versions() {
         assert!(load(b"nope").is_err());

crates/idml/src/tests.rs

@@ -194,6 +194,48 @@ fn fixture_with_story(story: &str) -> Vec<u8> {
     ])
 }
 
+fn fixture_with_styles(styles: &str) -> Vec<u8> {
+    zip_files(&[
+        ("designmap.xml", DESIGNMAP),
+        ("Resources/Graphic.xml", GRAPHIC),
+        ("Resources/Styles.xml", styles),
+        ("Resources/Preferences.xml", PREFS),
+        ("MasterSpreads/MasterSpread_m1.xml", MASTER),
+        ("Spreads/Spread_sp1.xml", SPREAD),
+        ("Stories/Story_s1.xml", STORY),
+    ])
+}
+
+/// Paragraph styles `Body` (based on the root) and `Loose` (no BasedOn), both with `attrs`.
+fn keep_styles(attrs: &str) -> String {
+    format!(
+        r#"<?xml version="1.0" encoding="UTF-8"?>
+<idPkg:Styles xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0">
+  <RootParagraphStyleGroup Self="rp">
+    <ParagraphStyle Self="ParagraphStyle/$ID/[No paragraph style]" Name="$ID/[No paragraph style]" PointSize="12"/>
+    <ParagraphStyle Self="ParagraphStyle/Body" Name="Body" {attrs}>
+      <Properties><BasedOn type="object">ParagraphStyle/$ID/[No paragraph style]</BasedOn></Properties>
+    </ParagraphStyle>
+    <ParagraphStyle Self="ParagraphStyle/Loose" Name="Loose" {attrs}/>
+  </RootParagraphStyleGroup>
+</idPkg:Styles>"#
+    )
+}
+
+/// Keep Lines Together whose mode no style sets is InDesign's default: at start/end of paragraph.
+/// An explicit mode still wins.
+#[test]
+fn keep_lines_mode_defaults_to_start_and_end() {
+    let keep = r#"KeepLinesTogether="true" KeepFirstLines="2" KeepLastLines="2""#;
+    for (attrs, all) in [(keep.to_string(), false), (format!(r#"{keep} KeepAllLinesTogether="true""#), true)] {
+        let d = import_idml_with(&fixture_with_styles(&keep_styles(&attrs)), &|_| None).unwrap();
+        for name in ["Body", "Loose"] {
+            let (pp, _) = d.styles.resolve_para_style(name);
+            assert_eq!((pp.keep_lines_together, pp.keep_all_lines, pp.keep_first, pp.keep_last), (true, all, 2, 2), "{name}: {attrs}");
+        }
+    }
+}
+
 #[test]
 fn imports_hand_written_fixture() {
     let d = import_idml_with(&fixture(), &|_| None).unwrap();