GitCorner

Code

ossartcraftvectorcraft๐ŸŒ
2bc41aeb8602
//! File โ†’ Package (`file.package`): the document with its linked files and fonts in a folder or a
//! zip, and the Document Info report it shares with Document Info โ€บ Saveโ€ฆ.

use std::collections::BTreeMap;
use std::io::Read;

use serde_json::{Value, json};

use crate::tests_links::{BLUE, Folder, RED, open, place, png, save, session, write};
use crate::*;

fn run(s: &mut Session, id: &str, p: Value) -> Value {
    s.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"))
}

/// A saved document `dir/poster.vectorcraft` with two linked files (in `dir/art`) and a line of
/// type.
fn poster(dir: &Folder) -> Session {
    let (a, b) = (dir.file("art/red.png"), dir.file("art/blue.png"));
    write(&a, &png(600, 300, RED));
    write(&b, &png(300, 300, BLUE));
    let mut s = session();
    place(&mut s, &a);
    place(&mut s, &b);
    run(&mut s, "text.create", json!({"x": 10, "y": 40, "text": "Poster"}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    s
}

/// The files in a zip archive by name (CRC-checked).
fn unzip(bytes: &[u8]) -> BTreeMap<String, Vec<u8>> {
    let le16 = |i: usize| u16::from_le_bytes([bytes[i], bytes[i + 1]]) as usize;
    let le32 = |i: usize| u32::from_le_bytes(bytes[i..i + 4].try_into().unwrap()) as usize;
    let end = bytes.len() - 22;
    assert_eq!(le32(end), 0x0605_4b50, "end of central directory");
    let (count, mut i) = (le16(end + 10), le32(end + 16));
    let mut out = BTreeMap::new();
    for _ in 0..count {
        assert_eq!(le32(i), 0x0201_4b50);
        let (method, crc, packed, name_len, offset) = (le16(i + 10), le32(i + 16), le32(i + 20), le16(i + 28), le32(i + 42));
        let name = String::from_utf8(bytes[i + 46..i + 46 + name_len].to_vec()).unwrap();
        i += 46 + name_len + le16(i + 30) + le16(i + 32);
        assert_eq!(le32(offset), 0x0403_4b50);
        let data = &bytes[offset + 30 + le16(offset + 26) + le16(offset + 28)..][..packed];
        let mut content = vec![];
        match method {
            8 => drop(flate2::read::DeflateDecoder::new(data).read_to_end(&mut content).unwrap()),
            _ => content = data.to_vec(),
        }
        let mut c = flate2::Crc::new();
        c.update(&content);
        assert_eq!(c.sum() as usize, crc, "{name}");
        out.insert(name, content);
    }
    out
}

#[test]
fn two_links_and_a_font_are_collected_and_relinked() {
    let dir = Folder::new("package");
    let mut s = poster(&dir);
    let out = dir.file("out");
    let r = run(&mut s, "file.package", json!({"folder": out}));
    let files: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect();
    assert_eq!(files, ["poster.vectorcraft", "Links/red.png", "Links/blue.png", "Fonts/SourceSans3-Regular.ttf", "poster Report.txt"]);
    assert_eq!((r["links"].as_u64(), r["fonts"].as_u64(), r["missingLinks"].clone()), (Some(2), Some(1), json!([])));
    let root = std::path::Path::new(&out).join("poster Folder");
    assert_eq!(std::path::Path::new(r["folder"].as_str().unwrap()), root);
    for f in &files {
        assert!(root.join(f).is_file(), "{f} written");
    }
    assert_eq!(std::fs::read(root.join("Links/red.png")).unwrap(), png(600, 300, RED));
    let font = std::fs::read(root.join("Fonts/SourceSans3-Regular.ttf")).unwrap();
    assert_eq!(&font[..4], &[0, 1, 0, 0], "a TrueType file");
    // The open document still links to the originals.
    let link = |s: &Session| {
        let mut paths = vec![];
        s.doc().unwrap().doc.visit_images(|_, im| paths.push(im.link.clone().unwrap()));
        paths
    };
    assert!(link(&s).iter().all(|l| l.path.contains("art")));
    // The packaged one opens with the copies, even with the originals gone.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let r = open(&mut s, &root.join("poster.vectorcraft").to_string_lossy());
    assert_eq!(r["missingLinks"], json!([]), "{r}");
    for l in link(&s) {
        assert!(std::path::Path::new(&l.path).starts_with(root.join("Links")), "{l:?}");
        assert!(l.relative.as_deref().is_some_and(|r| r.starts_with("Links/")));
    }
    assert!(s.doc().unwrap().doc.images.values().all(|b| !b.is_proxy()), "the copies' pixels");
}

/// A file linked only from a stored brush's art is copied, and the packaged document's brush
/// links to the copy.
#[test]
fn a_file_linked_from_a_stored_brush_is_collected_and_relinked() {
    let dir = Folder::new("package-brush");
    let file = dir.file("art/leaf.png");
    write(&file, &png(40, 20, RED));
    let mut s = session();
    let id = place(&mut s, &file);
    run(&mut s, "brush.new", json!({"type": "scatter", "name": "Leaves Here", "ids": [id.0]}));
    run(&mut s, "edit.clear", json!({"ids": [id.0]}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    let out = dir.file("out");
    let r = run(&mut s, "file.package", json!({"folder": out, "copyFonts": false}));
    let files: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect();
    assert!(files.contains(&"Links/leaf.png"), "{r}");
    let root = std::path::Path::new(&out).join("poster Folder");
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let r = open(&mut s, &root.join("poster.vectorcraft").to_string_lossy());
    assert_eq!(r["missingLinks"], json!([]), "{r}");
    let brush = vectorcraft_brush::find(&s.doc().unwrap().doc, "Leaves Here").unwrap();
    let mut paths = vec![];
    brush.art()[0].walk(&mut |n| {
        if let vectorcraft_doc::NodeKind::Image(im) = &n.kind {
            paths.push(im.link.as_ref().map(|l| (l.path.clone(), l.relative.clone())));
        }
    });
    let [Some((path, relative))] = paths.as_slice() else { panic!("{paths:?}") };
    assert!(std::path::Path::new(path).starts_with(root.join("Links")), "{path}");
    assert_eq!(relative.as_deref(), Some("Links/leaf.png"));
}

#[test]
fn an_unsaved_document_cant_be_packaged() {
    let mut s = session();
    let e = s.execute("file.package", &json!({"folder": std::env::temp_dir()})).unwrap_err().to_string();
    assert!(e.contains("save the document first"), "{e}");
    assert!(Session::new().execute("file.package", &json!({})).is_err(), "no document");
}

#[test]
fn a_param_of_the_wrong_type_is_refused_and_null_keeps_the_default() {
    let dir = Folder::new("package-types");
    let mut s = poster(&dir);
    let out = dir.file("out");
    for (p, msg) in [
        (json!({"folder": out, "copyLinks": "false"}), "`copyLinks` must be true or false"),
        (json!({"folder": out, "linksFolder": 0}), "`linksFolder` must be true or false"),
        (json!({"folder": out, "relink": "no"}), "`relink` must be true or false"),
        (json!({"folder": out, "copyFonts": "false"}), "`copyFonts` must be true or false"),
        (json!({"folder": out, "report": 1}), "`report` must be true or false"),
        (json!({"folder": out, "name": 5}), "`name` must be a string"),
        (json!({"folder": 5}), "`folder` must be a string"),
    ] {
        let e = match s.execute("file.package", &p) {
            Ok(r) => panic!("{p} gave {r}"),
            Err(e) => e.to_string(),
        };
        assert!(e.contains(msg), "{p}: {e}");
        assert!(!std::path::Path::new(&out).exists(), "{p} wrote nothing");
    }
    let r = run(&mut s, "file.package", json!({"folder": null, "name": null, "copyLinks": null, "copyFonts": null, "report": null}));
    assert_eq!(r["name"], "poster Folder.zip");
    let files: Vec<&str> = r["files"].as_array().unwrap().iter().map(|f| f.as_str().unwrap()).collect();
    assert_eq!(files, ["poster.vectorcraft", "Links/red.png", "Links/blue.png", "Fonts/SourceSans3-Regular.ttf", "poster Report.txt"]);
}

#[test]
fn without_a_folder_the_zip_has_the_same_files() {
    let dir = Folder::new("package-zip");
    let mut s = poster(&dir);
    let r = run(&mut s, "file.package", json!({"name": "Poster Kit"}));
    assert_eq!(r["name"], "Poster Kit.zip");
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let want: Vec<String> = r["files"].as_array().unwrap().iter().map(|f| format!("Poster Kit/{}", f.as_str().unwrap())).collect();
    let mut want_sorted = want.clone();
    want_sorted.sort();
    assert_eq!(zip.keys().cloned().collect::<Vec<_>>(), want_sorted);
    assert_eq!(zip["Poster Kit/Links/blue.png"], png(300, 300, BLUE));
    // The packaged document links to the files beside it.
    let doc = vectorcraft_format::load(&zip["Poster Kit/poster.vectorcraft"]).unwrap();
    let mut rel = vec![];
    doc.visit_images(|_, im| rel.push(im.link.clone().unwrap().relative.unwrap()));
    rel.sort();
    assert_eq!(rel, ["Links/blue.png", "Links/red.png"]);
    let report = String::from_utf8(zip["Poster Kit/poster Report.txt"].clone()).unwrap();
    assert!(report.contains("LINKED FILES") && report.contains("โ†’ Links/red.png"), "{report}");
    // The same entries as a folder package.
    let out = dir.file("out");
    let f = run(&mut s, "file.package", json!({"folder": out, "name": "Poster Kit"}));
    assert_eq!(f["files"], r["files"]);
}

/// The reply of a prepared package's [`cmd::package::Package::write`] and the files it gave the
/// writer, by path.
fn write_prepared(package: cmd::package::Package) -> (Value, BTreeMap<String, Vec<u8>>) {
    let mut files = BTreeMap::new();
    let mut write = |path: &str, bytes: &[u8]| {
        files.insert(path.to_string(), bytes.to_vec());
        Ok(())
    };
    let r = package.write(&mut write).unwrap_or_else(|e| panic!("{e}"));
    (r, files)
}

#[test]
fn a_prepared_package_writes_what_file_package_writes() {
    let dir = Folder::new("package-prepared");
    let mut s = poster(&dir);
    run(&mut s, "text.create", json!({"x": 10, "y": 80, "text": "Gone", "font": "No Such Font Family"}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    std::fs::remove_file(dir.file("art/blue.png")).unwrap();
    open(&mut s, &dir.file("poster.vectorcraft"));
    let p = json!({"folder": dir.file("out")});
    let want = run(&mut s, "file.package", p.clone());
    assert_eq!((want["missingLinks"].clone(), want["skippedFonts"][0]["font"].clone()), (json!(["blue.png"]), json!("No Such Font Family Regular")));
    let root = std::path::Path::new(&dir.file("out")).join("poster Folder");
    let on_disk: BTreeMap<String, Vec<u8>> = want["files"]
        .as_array()
        .unwrap()
        .iter()
        .map(|f| root.join(f.as_str().unwrap()))
        .map(|f| (f.to_string_lossy().into_owned(), std::fs::read(&f).unwrap()))
        .collect();
    assert_eq!(on_disk.len(), 4, "{want}");
    std::fs::remove_dir_all(&root).unwrap();
    // A prepared package is journaled as the command, and nothing is written until `Package::write` runs.
    let journaled = s.journal.len();
    let package = s.prepare_package(&p).unwrap();
    assert_eq!((s.journal.len(), s.journal.last().map(|(id, _)| id.as_str())), (journaled + 1, Some("file.package")));
    assert!(!root.exists());
    let (got, files) = write_prepared(package);
    assert_eq!(got, want);
    assert_eq!(files.keys().collect::<Vec<_>>(), on_disk.keys().collect::<Vec<_>>());
    for (path, bytes) in &on_disk {
        assert!(files[path] == *bytes, "{path} differs");
    }
    // Without a folder, the package is the same zip and no file is written.
    let want = run(&mut s, "file.package", json!({}));
    let (got, files) = write_prepared(s.prepare_package(&json!({})).unwrap());
    assert!(files.is_empty(), "{:?}", files.keys());
    let unzipped = |r: &Value| unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    assert_eq!(unzipped(&got), unzipped(&want));
    for key in ["files", "links", "fonts", "missingLinks", "skippedFonts", "warnings", "name", "bytes"] {
        assert_eq!(got[key], want[key], "{key}");
    }
    // The checks come first, as the command's do.
    let e = s.prepare_package(&json!({"name": "../up"})).err().map(|e| e.to_string()).unwrap_or_default();
    assert!(e.contains("can't name a folder"), "{e}");
}

#[test]
fn a_prepared_package_holds_the_document_as_it_was() {
    let dir = Folder::new("package-snapshot");
    let mut s = poster(&dir);
    let nodes = s.doc().unwrap().doc.node_count();
    let package = s.prepare_package(&json!({})).unwrap();
    run(&mut s, "select.all", json!({}));
    run(&mut s, "edit.clear", json!({}));
    run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 10, "height": 10}));
    let (r, _) = write_prepared(package);
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let doc = vectorcraft_format::load(&zip["poster Folder/poster.vectorcraft"]).unwrap();
    assert_eq!(doc.node_count(), nodes);
    assert_eq!(r["links"], 2, "{r}");
}

#[test]
fn options_leave_out_links_fonts_and_the_report() {
    let dir = Folder::new("package-options");
    let mut s = poster(&dir);
    let r = run(&mut s, "file.package", json!({"linksFolder": false, "copyFonts": false, "report": false}));
    assert_eq!(r["files"], json!(["poster.vectorcraft", "red.png", "blue.png"]));
    let r = run(&mut s, "file.package", json!({"copyLinks": false}));
    assert_eq!(r["files"], json!(["poster.vectorcraft", "Fonts/SourceSans3-Regular.ttf", "poster Report.txt"]));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let doc = vectorcraft_format::load(&zip["poster Folder/poster.vectorcraft"]).unwrap();
    doc.visit_images(|_, im| assert!(im.link.as_ref().unwrap().path.contains("art"), "not relinked: the originals"));
    let r = run(&mut s, "file.package", json!({"relink": false}));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    assert!(zip.contains_key("poster Folder/Links/red.png"), "copied");
    let doc = vectorcraft_format::load(&zip["poster Folder/poster.vectorcraft"]).unwrap();
    doc.visit_images(|_, im| assert!(im.link.as_ref().unwrap().path.contains("art"), "not relinked"));
    assert!(s.execute("file.package", &json!({"name": "../up"})).is_err());
}

#[test]
fn a_package_never_replaces_its_source_or_its_links() {
    let dir = Folder::new("package-overwrite");
    let mut s = poster(&dir);
    let doc = dir.file("poster.vectorcraft");
    let (saved, red) = (std::fs::read(&doc).unwrap(), std::fs::read(dir.file("art/red.png")).unwrap());
    let parent = dir.0.parent().unwrap();
    let name = dir.0.file_name().unwrap().to_string_lossy().into_owned();
    // The document's own folder, named directly and through `..`.
    for folder in [parent.to_path_buf(), dir.0.join("art").join("..").join("..")] {
        let e = s.execute("file.package", &json!({"folder": folder, "name": name})).unwrap_err().to_string();
        assert!(e.contains("would be overwritten"), "{e}");
    }
    // The folder of its linked files, with the links beside the packaged document.
    let e = s.execute("file.package", &json!({"folder": dir.0, "name": "art", "linksFolder": false})).unwrap_err().to_string();
    assert!(e.contains("red.png"), "{e}");
    // Nothing was written.
    assert_eq!(std::fs::read(&doc).unwrap(), saved);
    assert_eq!(std::fs::read(dir.file("art/red.png")).unwrap(), red);
    assert!(!dir.0.join("art/poster.vectorcraft").exists() && !dir.0.join("poster Report.txt").exists());
}

#[test]
fn a_missing_link_is_reported_not_copied() {
    let dir = Folder::new("package-missing");
    let mut s = poster(&dir);
    std::fs::remove_file(dir.file("art/blue.png")).unwrap();
    // Reopened, the missing file's image shows its preview: nothing to copy.
    open(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone()), (Some(1), json!(["blue.png"])));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let report = String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap();
    assert!(report.contains("blue.png: not found"), "{report}");
}

/// Packaged for a client whose read root holds neither the document's file nor its links: the report,
/// its Document Info part included, names them by their file names, and `document.info` gives no
/// link. The person's report names them whole.
#[test]
fn a_confined_package_names_files_outside_the_read_root_by_name() {
    let dir = Folder::new("package-roots");
    let mut s = poster(&dir);
    std::fs::create_dir_all(dir.file("in")).unwrap();
    std::fs::remove_file(dir.file("art/blue.png")).unwrap();
    open(&mut s, &dir.file("poster.vectorcraft"));
    let report = |r: &Value| {
        let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
        String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap()
    };
    // Reopened existing links use native separators; missing links keep their stored path.
    let red = dir.0.join("art").join("red.png").to_string_lossy().into_owned();
    let person = report(&run(&mut s, "file.package", json!({})));
    assert!(person.contains(&format!("From: {}\n", dir.file("poster.vectorcraft"))), "{person}");
    assert!(person.contains(&format!("{red} โ†’ Links/red.png")), "{person}");
    assert!(person.contains(&format!("blue.png: not found ({})", dir.file("art/blue.png"))), "{person}");

    let in_root = dir.0.join("in");
    let roots = crate::file_access::AutomationRoots::new(&[in_root.as_path()], &[]).unwrap();
    let client = crate::file_access::confine(roots.as_ref(), || run(&mut s, "file.package", json!({})));
    let text = report(&client);
    assert!(text.contains("From: poster.vectorcraft\n"), "{text}");
    assert!(text.contains("\nred.png โ†’ Links/red.png\n") && text.contains("\nblue.png: not found (blue.png), not copied\n"), "{text}");
    let base = dir.0.to_string_lossy().into_owned();
    assert!(!text.contains(&base), "{text}");
    // Compare serialized JSON with the path encoded the same way, without its outer quotes.
    let json_base = serde_json::to_string(&base).unwrap();
    let json_base = &json_base[1..json_base.len() - 1];
    for key in ["missingLinks", "warnings", "files"] {
        assert!(!client[key].to_string().contains(json_base), "{key}: {client}");
    }
    // Document Info, whose report the package holds, gives no link either.
    for p in [json!({}), json!({"format": "text"})] {
        let info = crate::file_access::confine(roots.as_ref(), || run(&mut s, "document.info", p.clone()));
        assert!(!info.to_string().contains(json_base), "{p}: {info}");
    }
    let info = run(&mut s, "document.info", json!({"format": "text"}));
    assert!(info["text"].as_str().unwrap().contains(&red), "the person's: {info}");
}

/// A confined request packages no document that links, or places a native document or a PDF with
/// Preserve Editing that links, a JavaScript file outside its read roots: the package is refused
/// before anything is written, with an error that names no file or folder. A JavaScript file inside
/// them is packaged, and so is one outside them when the person packages.
#[test]
fn a_confined_package_refuses_a_linked_javascript_file_outside_the_read_root() {
    let away = Folder::new("package-script-away");
    let home = Folder::new("package-script-home");
    let script = away.file("menu.js");
    let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
    let hidden = [away.0.to_string_lossy().into_owned(), home.0.to_string_lossy().into_owned(), "menu.js".to_string()];
    let refused = |s: &mut Session, p: Value| {
        let e = crate::file_access::confine(Some(&roots), || s.execute("file.package", &p)).expect_err("refused");
        assert!(matches!(e, EngineError::BadParams { .. }), "{p}: {e:?}");
        let e = e.to_string();
        assert!(e.contains("a linked JavaScript file is outside the read roots"), "{p}: {e}");
        for h in &hidden {
            assert!(!e.contains(h.as_str()), "{p} names {h}: {e}");
        }
    };
    let mut part = session();
    run(&mut part, "shape.rectangle", json!({"x": 10, "y": 10, "width": 30, "height": 30}));
    run(&mut part, "svgInteractivity.addFile", json!({"file": script}));
    std::fs::create_dir_all(home.0.join("art")).unwrap();
    let native = home.file("art/part.vectorcraft");
    save(&mut part, &native);
    let r = run(&mut part, "document.serialize", json!({"format": "pdf"}));
    let pdf = home.file("art/part.pdf");
    write(&pdf, &vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let out = home.file("out");
    refused(&mut part, json!({"folder": out}));
    refused(&mut part, json!({}));
    for placed in [&native, &pdf] {
        let mut s = session();
        let r = run(&mut s, "file.place", json!({"path": placed, "link": true}));
        assert_eq!(r["linked"], true, "{r}");
        save(&mut s, &home.file("poster.vectorcraft"));
        refused(&mut s, json!({"folder": out}));
        refused(&mut s, json!({}));
        assert!(!std::path::Path::new(&out).exists(), "{placed}");
        // The person's package copies it.
        assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "{placed}");
    }
    // A JavaScript file inside the read roots.
    run(&mut part, "svgInteractivity.removeFile", json!({"file": script}));
    run(&mut part, "svgInteractivity.addFile", json!({"file": home.file("menu.js")}));
    save(&mut part, &native);
    let mut s = session();
    run(&mut s, "file.place", json!({"path": native, "link": true}));
    save(&mut s, &home.file("poster.vectorcraft"));
    let r = crate::file_access::confine(Some(&roots), || s.execute("file.package", &json!({"folder": out}))).unwrap();
    assert_eq!(r["links"], 1, "{r}");
}

/// A confined request packages no linked file it would copy as it is (a PDF with Preserve Editing,
/// or a native document it does not rewrite) whose native document keeps an Export for Screens
/// folder outside its read roots: the package is refused before anything is written, with an error
/// that names no file or folder. A native document the package rewrites leaves the folder out, a
/// folder inside the roots is packaged, and the person's package copies every file.
#[test]
fn a_confined_package_refuses_a_linked_file_that_keeps_an_export_folder_outside_the_read_root() {
    let away = Folder::new("package-folder-away");
    let home = Folder::new("package-folder-home");
    let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
    let hidden = [away.0.to_string_lossy().into_owned(), home.0.to_string_lossy().into_owned()];
    let out = home.file("out");
    let package = |s: &mut Session, p: Value| crate::file_access::confine(Some(&roots), || s.execute("file.package", &p));
    let refused = |s: &mut Session, p: Value| {
        let e = package(s, p.clone()).expect_err("refused");
        assert!(matches!(e, EngineError::BadParams { .. }), "{p}: {e:?}");
        let e = e.to_string();
        assert!(e.contains("a linked file's export folder is outside the read roots"), "{p}: {e}");
        for h in &hidden {
            assert!(!e.contains(h.as_str()), "{p} names {h}: {e}");
        }
        assert!(!std::path::Path::new(&out).exists(), "{p}");
    };
    let mut part = session();
    run(&mut part, "shape.rectangle", json!({"x": 10, "y": 10, "width": 30, "height": 30}));
    std::fs::create_dir_all(home.0.join("art")).unwrap();
    let native = home.file("art/part.vectorcraft");
    let pdf = home.file("art/part.pdf");
    let keep = |part: &mut Session, folder: &str| {
        std::sync::Arc::make_mut(&mut part.doc_mut().unwrap().doc).export_settings = serde_json::from_value(json!({"folder": folder})).unwrap();
        save(part, &native);
        let r = run(part, "document.serialize", json!({"format": "pdf"}));
        write(&pdf, &vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    };
    keep(&mut part, &away.0.to_string_lossy());
    let poster = |placed: &str| {
        let mut s = session();
        let r = run(&mut s, "file.place", json!({"path": placed, "link": true}));
        assert_eq!(r["linked"], true, "{r}");
        save(&mut s, &home.file("poster.vectorcraft"));
        s
    };
    let mut s = poster(&pdf);
    refused(&mut s, json!({"folder": out}));
    refused(&mut s, json!({"relink": false}));
    assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "the person's package");
    let mut s = poster(&native);
    refused(&mut s, json!({"folder": out, "relink": false}));
    // Rewritten, the copy leaves the folder out.
    let r = package(&mut s, json!({"folder": out})).unwrap();
    assert_eq!(r["links"], 1, "{r}");
    let copied = std::fs::read(std::path::Path::new(&out).join("poster Folder/Links/part.vectorcraft")).unwrap();
    assert_eq!(vectorcraft_format::load_file(&copied).unwrap().doc.export_settings.get("folder"), None);
    std::fs::remove_dir_all(&out).unwrap();
    // A folder inside the read roots.
    keep(&mut part, &home.file("screens"));
    let mut s = poster(&pdf);
    assert_eq!(package(&mut s, json!({"folder": out})).unwrap()["links"], 1);
}

/// A confined request packages no linked file whose native document it can't read to check against
/// its read roots: a PDF that needs a password to open, and a native document that doesn't load,
/// even inside the roots. The package is refused before anything is written, with an error that
/// names no file or folder. A PDF without editing data is copied, and the person's package copies
/// every file.
#[test]
fn a_confined_package_refuses_a_linked_file_whose_editing_data_cannot_be_read() {
    let home = Folder::new("package-unreadable-home");
    let roots = crate::file_access::AutomationRoots::new(&[&home.0], &[&home.0]).unwrap().unwrap();
    let out = home.file("out");
    let package = |s: &mut Session, p: Value| crate::file_access::confine(Some(&roots), || s.execute("file.package", &p));
    let refused = |s: &mut Session, p: Value| {
        let e = package(s, p.clone()).expect_err("refused");
        assert!(matches!(e, EngineError::BadParams { .. }), "{p}: {e:?}");
        let e = e.to_string();
        assert!(e.contains("a linked file's editing data can't be read to check it against the read roots"), "{p}: {e}");
        assert!(!e.contains(home.0.to_string_lossy().as_ref()) && !e.contains("part."), "{p}: {e}");
        assert!(!std::path::Path::new(&out).exists(), "{p}");
    };
    let mut part = session();
    run(&mut part, "shape.rectangle", json!({"x": 10, "y": 10, "width": 30, "height": 30}));
    std::fs::create_dir_all(home.0.join("art")).unwrap();
    let native = home.file("art/part.vectorcraft");
    let pdf = home.file("art/part.pdf");
    save(&mut part, &native);
    let pdf_of =
        |part: &mut Session, p: Value| vectorcraft_format::base64_decode(run(part, "document.serialize", p)["dataBase64"].as_str().unwrap()).unwrap();
    let editable = pdf_of(&mut part, json!({"format": "pdf"}));
    let locked = pdf_of(&mut part, json!({"format": "pdf", "security": {"openPassword": "open sesame"}}));
    assert!(vectorcraft_pdf::editing_with(&locked, Some("open sesame")).is_some(), "the locked PDF carries editing data");
    let plain = pdf_of(&mut part, json!({"format": "pdf", "preserveEditing": false}));
    let poster = |placed: &str| {
        let mut s = session();
        let r = run(&mut s, "file.place", json!({"path": placed, "link": true}));
        assert_eq!(r["linked"], true, "{r}");
        save(&mut s, &home.file("poster.vectorcraft"));
        s
    };
    write(&pdf, &editable);
    let mut s = poster(&pdf);
    write(&pdf, &locked);
    refused(&mut s, json!({"folder": out}));
    refused(&mut s, json!({"relink": false}));
    // A package prepared in the confined request and written on another thread.
    let prepared = crate::file_access::confine(Some(&roots), || s.prepare_package(&json!({"folder": out}))).unwrap();
    let e =
        std::thread::spawn(move || prepared.write(&mut |_, _| Ok(())).map(|_| ()).map_err(|e| e.to_string())).join().unwrap().expect_err("refused");
    assert!(e.contains("a linked file's editing data can't be read to check it against the read roots"), "{e}");
    assert!(!std::path::Path::new(&out).exists());
    assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "the person's package");
    // A PDF listing the editing file without its data (`EF` renamed, the same length).
    let at = editable.windows(4).position(|w| w.starts_with(b"/EF") && !w[3].is_ascii_alphanumeric()).expect("the editing file's EF");
    let mut detached = editable.clone();
    detached[at..at + 3].copy_from_slice(b"/XF");
    assert!(vectorcraft_pdf::editing(&detached).is_none(), "the editing data can't be resolved");
    write(&pdf, &detached);
    refused(&mut s, json!({"folder": out}));
    refused(&mut s, json!({"relink": false}));
    assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "the person's package");
    // A PDF without editing data.
    write(&pdf, &plain);
    assert_eq!(package(&mut s, json!({"folder": out})).unwrap()["links"], 1);
    std::fs::remove_dir_all(&out).unwrap();
    // A PDF whose attachments are too many to search to their end, with a readable editing file
    // listed before the ones left unsearched.
    let cut = attachments_cut_short(&vectorcraft_pdf::editing(&editable).unwrap().data);
    assert!(vectorcraft_pdf::editing(&cut).is_some(), "the editing data is read");
    write(&pdf, &cut);
    refused(&mut s, json!({"folder": out}));
    refused(&mut s, json!({"relink": false}));
    assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "the person's package");
    // A native document that doesn't load, rewritten or copied as it is.
    let mut s = poster(&native);
    write(&native, b"not a document");
    refused(&mut s, json!({"folder": out}));
    refused(&mut s, json!({"folder": out, "relink": false}));
    assert_eq!(run(&mut s, "file.package", json!({}))["links"], 1, "the person's package");
}

/// A one-page PDF carrying `native` as its editing file, listed first in an attachment name tree
/// whose second subtree has 70,000 nodes, more than are searched.
fn attachments_cut_short(native: &[u8]) -> Vec<u8> {
    let name = vectorcraft_pdf::EDITING_FILE;
    let mut stream = format!("<< /Length {} >>\nstream\n", native.len()).into_bytes();
    stream.extend_from_slice(native);
    stream.extend_from_slice(b"\nendstream");
    let objects = [
        b"<< /Type /Catalog /Pages 2 0 R /Names << /EmbeddedFiles 3 0 R >> >>".to_vec(),
        b"<< /Type /Pages /Kids [6 0 R] /Count 1 >>".to_vec(),
        format!("<< /Kids [4 0 R << /Kids [{}] >>] >>", "<< /Names [] >> ".repeat(70_000)).into_bytes(),
        format!("<< /Names [({name}) << /Type /Filespec /UF ({name}) /EF << /F 5 0 R >> >>] >>").into_bytes(),
        stream,
        b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] >>".to_vec(),
    ];
    let mut out = b"%PDF-1.7\n".to_vec();
    let mut offsets = Vec::new();
    for (i, body) in objects.iter().enumerate() {
        offsets.push(out.len());
        out.extend_from_slice(format!("{} 0 obj\n", i + 1).as_bytes());
        out.extend_from_slice(body);
        out.extend_from_slice(b"\nendobj\n");
    }
    let xref = out.len();
    out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1).as_bytes());
    for at in &offsets {
        out.extend_from_slice(format!("{at:010} 00000 n \n").as_bytes());
    }
    out.extend_from_slice(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", offsets.len() + 1).as_bytes());
    out
}

/// A missing link stored as a path relative to the document names a file inside a confined
/// request's read root: the package report and Document Info give its stored path.
#[test]
fn a_relative_link_inside_the_read_root_keeps_its_path() {
    let dir = Folder::new("package-roots-relative");
    write(&dir.file("art/near.png"), &png(8, 8, RED));
    let mut s = session();
    let id = place(&mut s, &dir.file("art/near.png"));
    let mut doc = (*s.doc().unwrap().doc).clone();
    let Some(vectorcraft_doc::NodeKind::Image(im)) = doc.node_mut(id).map(|n| &mut n.kind) else { panic!("not an image") };
    im.link = Some(vectorcraft_doc::LinkInfo::new("art/near.png"));
    write(&dir.file("near.vectorcraft"), &vectorcraft_format::save(&doc, false));
    // Missing, the link keeps its stored path when the document opens (the package copies the
    // image the document holds).
    std::fs::remove_file(dir.file("art/near.png")).unwrap();
    open(&mut s, &dir.file("near.vectorcraft"));
    let roots = crate::file_access::AutomationRoots::new(&[dir.0.as_path()], &[]).unwrap();
    let r = crate::file_access::confine(roots.as_ref(), || run(&mut s, "file.package", json!({})));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let text = String::from_utf8(zip["near Folder/near Report.txt"].clone()).unwrap();
    assert!(text.contains("\nart/near.png โ†’ Links/near.png\n"), "{text}");
    let info = crate::file_access::confine(roots.as_ref(), || run(&mut s, "document.info", json!({})));
    let links: Vec<&Value> = info["images"].as_object().unwrap().values().map(|i| &i["link"]).collect();
    assert_eq!(links, [&json!("art/near.png")], "{info}");
    let text = crate::file_access::confine(roots.as_ref(), || run(&mut s, "document.info", json!({"format": "text"})));
    assert!(text.to_string().contains("art/near.png"), "{text}");
}

/// A link whose stored path names a place outside a confined request's read root, with its file
/// found by name beside the document inside the root: the package report and reply give the file
/// name, not the stored path.
#[test]
fn a_stored_path_outside_the_read_root_is_left_out_when_its_file_is_found_inside() {
    let dir = Folder::new("package-roots-stale");
    write(&dir.file("in/near.png"), &png(8, 8, RED));
    let mut s = session();
    let id = place(&mut s, &dir.file("in/near.png"));
    let mut doc = (*s.doc().unwrap().doc).clone();
    let Some(vectorcraft_doc::NodeKind::Image(im)) = doc.node_mut(id).map(|n| &mut n.kind) else { panic!("not an image") };
    let stale = dir.file("out/near.png");
    im.link = Some(vectorcraft_doc::LinkInfo::new(&stale));
    write(&dir.file("in/near.vectorcraft"), &vectorcraft_format::save(&doc, false));
    // Missing when the document opens, the link keeps its stored path; the file then appears beside it.
    std::fs::remove_file(dir.file("in/near.png")).unwrap();
    open(&mut s, &dir.file("in/near.vectorcraft"));
    write(&dir.file("in/near.png"), &png(8, 8, RED));
    let in_root = dir.0.join("in");
    let roots = crate::file_access::AutomationRoots::new(&[in_root.as_path()], &[]).unwrap();
    let r = crate::file_access::confine(roots.as_ref(), || run(&mut s, "file.package", json!({})));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let text = String::from_utf8(zip["near Folder/near Report.txt"].clone()).unwrap();
    assert!(text.contains("\nnear.png โ†’ Links/near.png\n"), "{text}");
    assert!(!text.contains(&stale), "{text}");
    for key in ["missingLinks", "warnings", "files"] {
        assert!(!r[key].to_string().contains(&stale), "{key}: {r}");
    }
}

/// A file missing from a document that moved keeps the place its relative path names from the
/// document's folder: the packaged document writes its relative path from there.
#[test]
fn a_missing_link_of_a_moved_document_keeps_its_relative_place() {
    let a = Folder::new("package-moved-a");
    let b = Folder::new("package-moved-b");
    let mut s = poster(&a);
    std::fs::remove_dir_all(&b.0).unwrap();
    std::fs::rename(&a.0, &b.0).unwrap();
    std::fs::remove_file(b.file("art/blue.png")).unwrap();
    open(&mut s, &b.file("poster.vectorcraft"));
    // Saved in another folder first: the relative path still names the folder the file was read from.
    std::fs::create_dir_all(b.0.join("saved")).unwrap();
    save(&mut s, &b.file("saved/poster.vectorcraft"));
    let out = b.file("out");
    let r = run(&mut s, "file.package", json!({"folder": out}));
    assert_eq!(r["missingLinks"], json!(["blue.png"]), "{r}");
    let packaged = std::path::Path::new(&out).join("poster Folder/poster.vectorcraft");
    let doc = vectorcraft_format::load(&std::fs::read(packaged).unwrap()).unwrap();
    let mut rel = vec![];
    doc.visit_images(|_, im| rel.push(im.link.clone().unwrap().relative));
    rel.sort();
    assert_eq!(rel, [Some("../../art/blue.png".to_string()), Some("Links/red.png".to_string())]);
}

/// A missing link stays missing when another file sits where its relative path, written for the
/// package folder, would name from the folder the document was last saved in.
#[test]
fn a_missing_link_is_not_collected_from_another_place() {
    let a = Folder::new("package-other-a");
    let b = Folder::new("package-other-b");
    let mut s = poster(&a);
    std::fs::remove_dir_all(&b.0).unwrap();
    std::fs::rename(&a.0, &b.0).unwrap();
    std::fs::remove_file(b.file("art/blue.png")).unwrap();
    open(&mut s, &b.file("poster.vectorcraft"));
    std::fs::create_dir_all(b.0.join("s1/s2/s3")).unwrap();
    save(&mut s, &b.file("s1/s2/s3/poster.vectorcraft"));
    // `../../art/blue.png` from the package folder, read from `s1/s2/s3`.
    write(&b.file("s1/art/blue.png"), &png(10, 10, RED));
    let r = run(&mut s, "file.package", json!({"folder": b.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone()), (Some(1), json!(["blue.png"])), "{r}");
}

/// Without copying, a packaged document links a file found by name beside the document it was read
/// from, after a save in another folder, where it was found.
#[test]
fn a_link_found_by_name_is_kept_where_it_was_found_without_copying() {
    let a = Folder::new("package-name-a");
    let b = Folder::new("package-name-b");
    let mut s = poster(&a);
    std::fs::remove_dir_all(&b.0).unwrap();
    std::fs::rename(&a.0, &b.0).unwrap();
    let away = b.file("away.png");
    std::fs::rename(b.file("art/blue.png"), &away).unwrap();
    open(&mut s, &b.file("poster.vectorcraft"));
    std::fs::create_dir_all(b.0.join("saved")).unwrap();
    save(&mut s, &b.file("saved/poster.vectorcraft"));
    std::fs::rename(&away, b.file("blue.png")).unwrap();
    let out = b.file("out");
    run(&mut s, "file.package", json!({"folder": out, "copyLinks": false}));
    let packaged = std::path::Path::new(&out).join("poster Folder/poster.vectorcraft");
    let r = open(&mut s, &packaged.to_string_lossy());
    assert_eq!(&r["missingLinks"], &json!([]), "{r}");
}

/// A file that comes back beside the document it was read from, after the document was saved in
/// another folder, is collected from there.
#[test]
fn a_link_that_comes_back_after_a_save_elsewhere_is_collected() {
    let a = Folder::new("package-back-a");
    let b = Folder::new("package-back-b");
    let away = Folder::new("package-back-away");
    let mut s = poster(&a);
    std::fs::remove_dir_all(&b.0).unwrap();
    std::fs::rename(&a.0, &b.0).unwrap();
    std::fs::rename(b.file("art/blue.png"), away.file("blue.png")).unwrap();
    open(&mut s, &b.file("poster.vectorcraft"));
    std::fs::create_dir_all(b.0.join("saved")).unwrap();
    save(&mut s, &b.file("saved/poster.vectorcraft"));
    std::fs::rename(away.file("blue.png"), b.file("art/blue.png")).unwrap();
    let out = b.file("out");
    let r = run(&mut s, "file.package", json!({"folder": out}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone()), (Some(2), json!([])), "{r}");
    let packaged = std::path::Path::new(&out).join("poster Folder/poster.vectorcraft");
    let doc = vectorcraft_format::load(&std::fs::read(packaged).unwrap()).unwrap();
    let mut rel = vec![];
    doc.visit_images(|_, im| rel.push(im.link.clone().unwrap().relative));
    rel.sort();
    assert_eq!(rel, [Some("Links/blue.png".to_string()), Some("Links/red.png".to_string())]);
    // A file beside the folder the document was last saved in is collected too.
    std::fs::create_dir_all(b.0.join("saved/art")).unwrap();
    std::fs::rename(b.file("art/blue.png"), b.file("saved/art/blue.png")).unwrap();
    let r = run(&mut s, "file.package", json!({"folder": b.file("out2")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone()), (Some(2), json!([])), "{r}");
}

#[test]
fn a_font_named_by_another_of_its_names_is_copied() {
    let dir = Folder::new("package-alias");
    let mut s = poster(&dir);
    // The bundled Semibold by its PostScript name, as an SVG or a PDF can name it.
    run(&mut s, "text.create", json!({"x": 10, "y": 80, "text": "Alias", "font": "SourceSans3-Semibold"}));
    let r = run(&mut s, "file.package", json!({}));
    assert_eq!((r["fonts"].as_u64(), r["skippedFonts"].clone()), (Some(2), json!([])), "{}", r["skippedFonts"]);
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let report = String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap();
    assert!(report.contains("SourceSans3-Semibold Regular โ†’ Fonts/"), "{report}");
    // The Font Details row: the Fonts rows above it start with the same label.
    let font_details = report.split("\nFONT DETAILS\n").nth(1).unwrap_or_default();
    let details = font_details.lines().find(|l| l.starts_with("SourceSans3-Semibold Regular: ")).unwrap_or_default();
    assert!(details.contains("embedding allowed") && !details.contains("missing"), "{report}");
}

#[test]
fn a_substituted_style_names_the_style_shown() {
    let dir = Folder::new("package-style");
    let mut s = poster(&dir);
    // No Source Sans 3 has a Black Wide, bundled or installed: its closest style stands in, and
    // that style's file is copied.
    run(&mut s, "text.create", json!({"x": 10, "y": 80, "text": "Heavy", "font": "Source Sans 3", "style": "Black Wide"}));
    let r = run(&mut s, "file.package", json!({}));
    assert_eq!(r["skippedFonts"], json!([]));
    let zip = unzip(&vectorcraft_format::base64_decode(r["dataBase64"].as_str().unwrap()).unwrap());
    let report = String::from_utf8(zip["poster Folder/poster Report.txt"].clone()).unwrap();
    assert!(report.contains("Source Sans 3 Black Wide (shown in Source Sans 3 "), "{report}");
    assert!(report.contains("Source Sans 3 Black Wide: substituted: shown in Source Sans 3 "), "{report}");
}

#[test]
fn the_document_info_report_has_every_category() {
    let dir = Folder::new("docinfo-report");
    let mut s = poster(&dir);
    s.execute("file.place", &json!({"path": dir.file("art/red.png"), "link": false})).unwrap();
    let text = run(&mut s, "document.info", json!({"format": "text"}))["text"].as_str().unwrap().to_string();
    for h in [
        "DOCUMENT",
        "OBJECTS",
        "GRAPHIC STYLES",
        "BRUSHES",
        "SPOT COLOR OBJECTS",
        "PATTERN OBJECTS",
        "GRADIENT OBJECTS",
        "SYMBOLS",
        "FONTS",
        "FONT DETAILS",
        "LINKED IMAGES",
        "EMBEDDED IMAGES",
        "REPEAT OBJECTS",
    ] {
        assert!(text.contains(&format!("\n{h}\n")), "{h}: {text}");
    }
    assert!(text.contains("Images: 3") && text.contains("Source Sans 3 Regular: built in; embedding allowed"), "{text}");
    assert!(text.contains("red.png: 600 ร— 300 px โ€” ") && text.contains("Color Mode: RGB") && text.contains("\nSwatches: "), "{text}");
    let fonts = run(&mut s, "document.info", json!({"format": "text", "category": "fonts"}))["text"].as_str().unwrap().to_string();
    assert!(fonts.contains("FONTS") && !fonts.contains("OBJECTS"), "{fonts}");
    let i = run(&mut s, "document.info", json!({"category": "linkedImages"}));
    assert_eq!((i["sections"].as_array().unwrap().len(), i["sections"][0]["id"].as_str()), (1, Some("linkedImages")));
    assert_eq!(i["sections"][0]["rows"].as_array().unwrap().len(), 2);
    // `imageObjects` lists the linked images in the rows' order with the files they show, and the
    // embedded one with no file.
    let linked: Vec<Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == true).cloned().collect();
    for (o, r) in linked.iter().zip(i["sections"][0]["rows"].as_array().unwrap()) {
        let shown = format!("{} ร— {} px โ€” {}", o["width"], o["height"], o["file"].as_str().unwrap());
        assert_eq!((&o["name"], shown.as_str()), (&r[0], r[1].as_str().unwrap()));
    }
    assert_eq!(linked.len(), 2);
    let embedded: Vec<&Value> = i["imageObjects"].as_array().unwrap().iter().filter(|o| o["linked"] == false).collect();
    assert_eq!((embedded.len(), &embedded[0]["file"], &embedded[0]["width"]), (1, &Value::Null, &json!(600)));
    let all = run(&mut s, "document.info", json!({}));
    assert_eq!(all["sections"].as_array().unwrap().len(), 13);
    let i = run(&mut s, "document.info", json!({"category": "brushes"}));
    assert_eq!((i["sections"].as_array().unwrap().len(), i["sections"][0]["id"].as_str()), (1, Some("brushes")));
    let i = run(&mut s, "document.info", json!({"category": "repeats"}));
    assert_eq!((i["sections"].as_array().unwrap().len(), i["sections"][0]["id"].as_str()), (1, Some("repeats")));
    assert!(text.contains("\nREPEAT OBJECTS\nNone\n"), "{text}");
    assert!(s.execute("document.info", &json!({"category": "strokes"})).is_err());
    assert!(s.execute("document.info", &json!({"format": "xml"})).is_err());
    // The bundled fonts allow embedding.
    let face = vectorcraft_text::FontDb::global().face("Source Sans 3", "Regular").unwrap();
    assert!(face.embeddable() && face.path().is_none());
}

/// A professional handoff: the poster links to a reusable illustration, whose
/// own artwork links to a raster asset. Both dependency levels must travel.
fn poster_with_placed_document(dir: &Folder) -> Session {
    let image = dir.file("art/photo.png");
    write(&image, &png(600, 300, RED));
    let mut part = session();
    place(&mut part, &image);
    let part_path = dir.file("art/part.vectorcraft");
    save(&mut part, &part_path);

    let mut poster = session();
    let placed = run(&mut poster, "file.place", json!({ "path": part_path, "link": true }));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut poster, &dir.file("poster.vectorcraft"));
    poster
}

/// Every link must point to a packaged copy, including links inside a linked
/// VectorCraft file. Validate after original assets have been removed.
fn verify_portable_nested_package(folder: &std::path::Path) {
    let main = folder.join("poster.vectorcraft");
    let part = folder.join("Links/part.vectorcraft");
    let image = folder.join("Links/photo.png");
    assert!(main.is_file() && part.is_file() && image.is_file());

    let mut parent = session();
    let opened = open(&mut parent, &main.to_string_lossy());
    assert_eq!(opened["missingLinks"], json!([]), "main package has broken links: {opened}");
    let mut targets = Vec::new();
    parent.doc().unwrap().doc.visit_placed(|_, p| targets.push(p.link.clone()));
    assert_eq!(targets.len(), 1);
    let link = &targets[0];
    assert_eq!(link.relative.as_deref(), Some("Links/part.vectorcraft"));
    let packaged_part = std::fs::read(&part).unwrap();
    let expected_hash = vectorcraft_doc::links::hash_bytes(&packaged_part);
    assert_eq!(link.hash.as_deref(), Some(expected_hash.as_str()));
    let mut nested = session();
    let opened = open(&mut nested, &part.to_string_lossy());
    assert_eq!(opened["missingLinks"], json!([]), "nested document has broken links: {opened}");
    let mut img_links = Vec::new();
    nested.doc().unwrap().doc.visit_images(|_, im| img_links.extend(im.link.clone()));
    assert_eq!(img_links.len(), 1);
    assert_eq!(img_links[0].relative.as_deref(), Some("photo.png"));
    assert_eq!(std::fs::read(&image).unwrap(), png(600, 300, RED));
}

#[test]
fn package_recursively_relinks_placed_documents_and_their_images() {
    let dir = Folder::new("package-placed");
    let mut s = poster_with_placed_document(&dir);
    let out = dir.file("delivery");
    let result = run(&mut s, "file.package", json!({ "folder": out }));
    assert_eq!((result["links"].as_u64(), result["missingLinks"].clone()), (Some(2), json!([])), "{result}");
    let folder = dir.0.join("delivery/poster Folder");
    // The package must work on a second computer without the source tree.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    verify_portable_nested_package(&folder);
}

#[test]
fn zipped_package_recursively_relinks_without_absolute_creator_paths() {
    let dir = Folder::new("package-placed-zip");
    let mut s = poster_with_placed_document(&dir);
    let result = run(&mut s, "file.package", json!({}));
    assert_eq!(result["links"], 2, "{result}");
    let bytes = vectorcraft_format::base64_decode(result["dataBase64"].as_str().unwrap()).unwrap();
    let archive = unzip(&bytes);
    let extraction = dir.file("extracted");
    for (name, bytes) in archive {
        write(&format!("{extraction}/{name}"), &bytes);
    }
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    verify_portable_nested_package(&dir.0.join("extracted/poster Folder"));
}

#[test]
fn package_copies_a_linked_pdf_page_as_it_is() {
    let dir = Folder::new("package-placed-pdf");
    let mut d = vectorcraft_doc::Document::new(100.0, 50.0);
    let (layer, id) = (d.layers[0].id, d.alloc_id());
    let red = vectorcraft_color::Paint::solid(vectorcraft_color::Color::rgb8(RED[0], RED[1], RED[2]));
    let look = vectorcraft_doc::Appearance::basic(red, vectorcraft_color::Paint::None, 0.0);
    let page = vectorcraft_geom::shapes::rectangle(vectorcraft_geom::Rect::new(0.0, 0.0, 100.0, 50.0));
    d.insert(Some(layer), 0, vectorcraft_doc::Node::path(id, page, look)).unwrap();
    let pdf = cmd::fileio::encode_all(&d, "pdf", &json!({"preserveEditing": false})).unwrap().files.remove(0).1;
    let src = dir.file("art/flyer.pdf");
    write(&src, &pdf);
    let mut s = session();
    let placed = run(&mut s, "file.place", json!({"path": src}));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone(), r["warnings"].clone()), (Some(1), json!([]), json!([])), "{r}");
    let root = dir.0.join("out/poster Folder");
    assert_eq!(std::fs::read(root.join("Links/flyer.pdf")).unwrap(), pdf, "copied as it is");
    // The packaged document shows the copy.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let opened = open(&mut s, &root.join("poster.vectorcraft").to_string_lossy());
    assert_eq!(opened["missingLinks"], json!([]), "{opened}");
    assert!(s.doc().unwrap().doc.has_placed());
}

#[test]
fn package_copies_a_linked_eps_file_as_it_is() {
    let dir = Folder::new("package-placed-eps");
    let eps = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 50\n%%EndComments\n1 0 0 setrgbcolor\nnewpath 0 0 moveto 100 0 lineto 100 50 lineto 0 50 lineto closepath fill\nshowpage\n%%EOF\n";
    let src = dir.file("art/seal.eps");
    write(&src, eps);
    let mut s = session();
    let placed = run(&mut s, "file.place", json!({"path": src}));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone(), r["warnings"].clone()), (Some(1), json!([]), json!([])), "{r}");
    let root = dir.0.join("out/poster Folder");
    assert_eq!(std::fs::read(root.join("Links/seal.eps")).unwrap(), eps, "copied as it is");
    // The packaged document shows the copy.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let opened = open(&mut s, &root.join("poster.vectorcraft").to_string_lossy());
    assert_eq!(opened["missingLinks"], json!([]), "{opened}");
    assert!(s.doc().unwrap().doc.has_placed());
}

#[test]
fn package_copies_the_files_a_linked_eps_files_native_document_places_beside_it() {
    let dir = Folder::new("package-placed-eps-links");
    let pic = dir.file("pics/photo.png");
    write(&pic, &png(600, 300, RED));
    let mut art = session();
    place(&mut art, &pic);
    std::fs::create_dir_all(dir.0.join("art")).unwrap();
    let src = dir.file("art/seal.eps");
    run(&mut art, "document.export", json!({"path": src, "format": "eps"}));
    let mut s = session();
    let placed = run(&mut s, "file.place", json!({"path": src}));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone(), r["warnings"].clone()), (Some(2), json!([]), json!([])), "{r}");
    let root = dir.0.join("out/poster Folder");
    assert_eq!(std::fs::read(root.join("Links/photo.png")).unwrap(), png(600, 300, RED));
    // The copy of the EPS file finds the picture beside it, not its preview.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    std::fs::remove_dir_all(dir.0.join("pics")).unwrap();
    let copy = root.join("Links/seal.eps").to_string_lossy().into_owned();
    let shows_the_file = || {
        let bytes = std::fs::read(&copy).unwrap();
        let a = cmd::place::document::document_art("seal.eps", &bytes, Some(&copy), 1, false, vectorcraft_doc::PageBox::Crop, "t").unwrap();
        a.doc.images.values().any(|b| !b.is_proxy())
    };
    assert!(shows_the_file());
    std::fs::remove_file(root.join("Links/photo.png")).unwrap();
    assert!(!shows_the_file(), "the preview only");
}

#[test]
fn package_copies_a_linked_postscript_ai_file_the_document_holds_after_it_is_gone() {
    let dir = Folder::new("package-placed-ps-ai");
    let ai = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 50\n%%EndComments\n0 0 1 setrgbcolor\nnewpath 0 0 moveto 100 0 lineto 100 50 lineto 0 50 lineto closepath fill\nshowpage\n%%EOF\n";
    let src = dir.file("art/badge.ai");
    write(&src, ai);
    let mut s = session();
    let placed = run(&mut s, "file.place", json!({"path": src}));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut s, &dir.file("poster.vectorcraft"));
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone()), (Some(1), json!([])), "{r}");
    let root = dir.0.join("out/poster Folder");
    assert_eq!(std::fs::read(root.join("Links/badge.ai")).unwrap(), ai, "the bytes the document holds");
}

/// The PostScript bytes a document holds are copied for a placed document whose file name is one
/// PostScript is read from, and not under any other name or for a linked image.
#[test]
fn package_copies_held_postscript_only_for_a_placed_document_with_a_postscript_name() {
    let dir = Folder::new("package-placed-ps-names");
    let eps = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 50\n%%EndComments\n1 0 0 setrgbcolor\nnewpath 0 0 moveto 100 0 lineto 100 50 lineto 0 50 lineto closepath fill\nshowpage\n%%EOF\n";
    let ai = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 100 50\n%%EndComments\n0 0 1 setrgbcolor\nnewpath 0 0 moveto 100 0 lineto 100 50 lineto 0 50 lineto closepath fill\nshowpage\n%%EOF\n";
    write(&dir.file("art/seal.eps"), eps);
    write(&dir.file("art/badge.ai"), ai);
    write(&dir.file("art/logo.png"), &png(8, 8, RED));
    let mut s = session();
    let seal = run(&mut s, "file.place", json!({"path": dir.file("art/seal.eps")}));
    assert_eq!(seal["linked"], true, "{seal}");
    let seal = vectorcraft_doc::NodeId(seal["ids"][0].as_u64().unwrap());
    run(&mut s, "file.place", json!({"path": dir.file("art/badge.ai")}));
    let logo = place(&mut s, &dir.file("art/logo.png"));
    let (tool, logo_ai) = (dir.file("art/tool.exe"), dir.file("art/logo.ai"));
    s.edit("names", |d, _| {
        let vectorcraft_doc::NodeKind::PlacedDocument(p) = &mut d.node_mut(seal).unwrap().kind else { panic!("not a placed document") };
        p.link.path = tool.clone();
        p.link.relative = None;
        let vectorcraft_doc::NodeKind::Image(im) = &mut d.node_mut(logo).unwrap().kind else { panic!("not an image") };
        im.link.as_mut().unwrap().path = logo_ai.clone();
        im.link.as_mut().unwrap().relative = None;
        let key = im.key.clone();
        d.images
            .insert(key, vectorcraft_doc::ImageBlob { mime: "application/postscript".into(), bytes: std::sync::Arc::new(eps.to_vec()), proxy: None });
        Ok(())
    })
    .unwrap();
    save(&mut s, &dir.file("poster.vectorcraft"));
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!(r["links"].as_u64(), Some(1), "{r}");
    let mut missing: Vec<&str> = r["missingLinks"].as_array().unwrap().iter().filter_map(Value::as_str).collect();
    missing.sort_unstable();
    assert_eq!(missing, ["logo.ai", "tool.exe"], "{r}");
    let links = dir.0.join("out/poster Folder/Links");
    assert_eq!(std::fs::read(links.join("badge.ai")).unwrap(), ai, "a PostScript .ai under its own name");
    assert!(!links.join("tool.exe").exists(), "PostScript under a name it isn't read from");
    assert!(!links.join("logo.ai").exists(), "PostScript held for a linked image");
}

#[test]
fn package_copies_the_fonts_of_the_type_on_a_linked_pdf_page() {
    let dir = Folder::new("package-placed-pdf-type");
    let mut src = session();
    run(&mut src, "text.create", json!({"x": 10, "y": 40, "text": "Flyer"}));
    let pdf = run(&mut src, "document.serialize", json!({"format": "pdf", "preserveEditing": false}));
    let path = dir.file("art/flyer.pdf");
    write(&path, &vectorcraft_format::base64_decode(pdf["dataBase64"].as_str().unwrap()).unwrap());
    for (link, copy_links, out) in [(false, true, "embedded"), (true, true, "linked"), (true, false, "fonts only")] {
        let mut s = session();
        let placed = run(&mut s, "file.place", json!({"path": path, "link": link}));
        assert_eq!(placed["linked"], link, "{placed}");
        save(&mut s, &dir.file("poster.vectorcraft"));
        let r = run(&mut s, "file.package", json!({"folder": dir.file(out), "copyLinks": copy_links}));
        assert_eq!((r["fonts"].as_u64(), r["skippedFonts"].clone()), (Some(1), json!([])), "{out}: {r}");
        assert!(dir.0.join(out).join("poster Folder/Fonts/SourceSans3-Regular.ttf").is_file(), "{out}");
    }
}

#[test]
fn package_copies_the_fonts_of_each_page_of_a_pdf_that_two_documents_place() {
    let dir = Folder::new("package-placed-pdf-pages");
    let mut src = session();
    run(&mut src, "text.create", json!({"x": 10, "y": 40, "text": "One"}));
    run(&mut src, "artboard.new", json!({"x": 500, "y": 0, "width": 400, "height": 300}));
    run(&mut src, "text.create", json!({"x": 510, "y": 40, "text": "Two", "font": "SourceSans3-Semibold"}));
    let pdf = run(&mut src, "document.serialize", json!({"format": "pdf", "preserveEditing": false}));
    let path = dir.file("art/flyer.pdf");
    write(&path, &vectorcraft_format::base64_decode(pdf["dataBase64"].as_str().unwrap()).unwrap());
    // The poster places page 1, and a document it places shows page 2.
    let mut part = session();
    run(&mut part, "file.place", json!({"path": path, "page": 2}));
    let part_path = dir.file("art/part.vectorcraft");
    save(&mut part, &part_path);
    let mut s = session();
    run(&mut s, "file.place", json!({"path": path, "page": 1}));
    run(&mut s, "file.place", json!({"path": part_path}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({}));
    assert_eq!((r["links"].as_u64(), r["fonts"].as_u64(), r["skippedFonts"].clone()), (Some(2), Some(2), json!([])), "{r}");
}

/// With Copy Fonts off, Package reads no placed PDF page for its type: neither a page of a PDF it
/// copies nor a page of one another document placed and it copied already.
#[test]
fn package_reads_no_placed_pdf_page_without_copy_fonts() {
    use cmd::package::PAGES_READ;
    let dir = Folder::new("package-placed-pdf-no-fonts");
    let mut src = session();
    run(&mut src, "text.create", json!({"x": 10, "y": 40, "text": "One"}));
    run(&mut src, "artboard.new", json!({"x": 500, "y": 0, "width": 400, "height": 300}));
    run(&mut src, "text.create", json!({"x": 510, "y": 40, "text": "Two"}));
    let pdf = run(&mut src, "document.serialize", json!({"format": "pdf", "preserveEditing": false}));
    let path = dir.file("art/flyer.pdf");
    write(&path, &vectorcraft_format::base64_decode(pdf["dataBase64"].as_str().unwrap()).unwrap());
    let mut part = session();
    run(&mut part, "file.place", json!({"path": path, "page": 2}));
    let part_path = dir.file("art/part.vectorcraft");
    save(&mut part, &part_path);
    let mut s = session();
    run(&mut s, "file.place", json!({"path": path, "page": 1}));
    run(&mut s, "file.place", json!({"path": part_path}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    for (copy_links, copy_fonts, fonts, reads, out) in [(true, false, 0, 0, "links"), (false, false, 0, 0, "neither"), (true, true, 1, 2, "both")] {
        let before = PAGES_READ.with(std::cell::Cell::get);
        let r = run(&mut s, "file.package", json!({"folder": dir.file(out), "copyLinks": copy_links, "copyFonts": copy_fonts}));
        let read = PAGES_READ.with(std::cell::Cell::get) - before;
        assert_eq!((r["fonts"].as_u64(), read), (Some(fonts), reads), "{out}: {r}");
    }
}

/// `dir/art/badge.ai`, saved without its PDF part, its art placing each of `pics` (600 ร— 300 px,
/// with a 2ร—1 preview) โ†’ its path.
fn ai_placing(dir: &Folder, pics: &[&str]) -> String {
    use vectorcraft_testkit::ai;
    let place = |pic: &str| {
        let pic = pic.replace('\\', "/");
        format!(
            "%AI5_BeginPlace\n[0.1 0 0 -0.1 20 80] 0 0 600 300 4 4 0\n({pic})`\n%AI26_BeginPlacedObjectPreview\n2 1 8 32 17 \x7f\x10\x10\x60\x7f\x10\x10\x60\n%AI26_EndPlacedObjectPreview\n~\n%AI5_EndPlace\n"
        )
    };
    let data = ai::editing_data(200.0, 100.0, &ai::layer("Art", &pics.iter().map(|p| place(p)).collect::<String>()));
    let src = dir.file("art/badge.ai");
    write(&src, &ai::ai(data.as_bytes(), "BT /F1 12 Tf 10 50 Td (Saved without its PDF part) Tj ET"));
    src
}

#[test]
fn package_copies_the_files_a_linked_ai_files_editing_data_places_beside_it() {
    let dir = Folder::new("package-placed-ai");
    let pic = dir.file("art/photo.png");
    write(&pic, &png(600, 300, RED));
    let src = ai_placing(&dir, &[&pic]);
    let mut s = session();
    let placed = run(&mut s, "file.place", json!({"path": src}));
    assert_eq!(placed["linked"], true, "{placed}");
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    assert_eq!((r["links"].as_u64(), r["missingLinks"].clone(), r["warnings"].clone()), (Some(2), json!([]), json!([])), "{r}");
    let root = dir.0.join("out/poster Folder");
    assert_eq!(std::fs::read(root.join("Links/photo.png")).unwrap(), png(600, 300, RED));
    // The copy of the .ai finds the picture beside it, not its preview.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let copy = root.join("Links/badge.ai").to_string_lossy().into_owned();
    let shows_the_file = || {
        let bytes = std::fs::read(&copy).unwrap();
        let a = cmd::place::document::document_art("badge.ai", &bytes, Some(&copy), 1, false, vectorcraft_doc::PageBox::Crop, "t").unwrap();
        a.doc.images.values().any(|b| !b.is_proxy())
    };
    assert!(shows_the_file());
    std::fs::remove_file(root.join("Links/photo.png")).unwrap();
    assert!(!shows_the_file(), "the preview only");
}

#[test]
fn package_warns_when_a_file_a_linked_ai_file_places_is_copied_under_another_name() {
    let dir = Folder::new("package-placed-ai-names");
    let (one, two) = (dir.file("art/a/photo.png"), dir.file("art/b/photo.png"));
    write(&one, &png(600, 300, RED));
    write(&two, &png(600, 300, BLUE));
    let src = ai_placing(&dir, &[&one, &two]);
    let mut s = session();
    run(&mut s, "file.place", json!({"path": src}));
    save(&mut s, &dir.file("poster.vectorcraft"));
    let r = run(&mut s, "file.package", json!({"folder": dir.file("out")}));
    let warnings = r["warnings"].as_array().unwrap();
    assert_eq!(r["links"].as_u64(), Some(3), "{r}");
    assert!(warnings.len() == 1 && warnings[0].as_str().unwrap().contains("looks for it as photo.png and shows the file of that name"), "{r}");
    // Moved, the copy of the .ai shows Links/photo.png for both, as the warning says.
    std::fs::remove_dir_all(dir.0.join("art")).unwrap();
    let copy = dir.0.join("out/poster Folder/Links/badge.ai").to_string_lossy().into_owned();
    let bytes = std::fs::read(&copy).unwrap();
    let a = cmd::place::document::document_art("badge.ai", &bytes, Some(&copy), 1, false, vectorcraft_doc::PageBox::Crop, "t").unwrap();
    assert_eq!(a.doc.images.values().filter(|b| !b.is_proxy()).count(), 1);
}

#[test]
fn package_keeps_distinct_linked_documents_with_colliding_file_names() {
    let dir = Folder::new("package-collisions");
    let mut poster = session();
    for (number, color) in [(1, RED), (2, BLUE)] {
        let image = dir.file(&format!("art{number}/picture.png"));
        write(&image, &png(300, 300, color));
        let mut part = session();
        place(&mut part, &image);
        let name = dir.file(&format!("art{number}/part.vectorcraft"));
        save(&mut part, &name);
        run(&mut poster, "file.place", json!({ "path": name, "link": true }));
    }
    save(&mut poster, &dir.file("poster.vectorcraft"));
    let result = run(&mut poster, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["links"], 4, "{result}");
    assert_eq!(result["missingLinks"], json!([]));
    let folder = dir.0.join("delivery/poster Folder");
    let packaged: Vec<_> =
        result["files"].as_array().unwrap().iter().filter_map(Value::as_str).filter(|name| name.ends_with(".vectorcraft")).collect();
    assert_eq!(packaged.len(), 3, "both nested documents must be retained: {packaged:?}");
    std::fs::remove_dir_all(dir.0.join("art1")).unwrap();
    std::fs::remove_dir_all(dir.0.join("art2")).unwrap();
    let mut check = session();
    assert_eq!(open(&mut check, &folder.join("poster.vectorcraft").to_string_lossy())["missingLinks"], json!([]));
    for name in packaged.into_iter().filter(|n| n.starts_with("Links/")) {
        let mut inner = session();
        let result = open(&mut inner, &folder.join(name).to_string_lossy());
        assert_eq!(result["missingLinks"], json!([]), "{name}: {result}");
    }
}

#[test]
fn package_finds_nested_assets_after_the_source_tree_moves() {
    let dir = Folder::new("package-moved-nested");
    let _original = poster_with_placed_document(&dir);
    let moved = dir.0.join("moved");
    std::fs::create_dir_all(&moved).unwrap();
    std::fs::rename(dir.0.join("art"), moved.join("art")).unwrap();
    std::fs::rename(dir.0.join("poster.vectorcraft"), moved.join("poster.vectorcraft")).unwrap();
    // The file paths embedded in both documents still point to the old location.
    // Opening the parent repairs its direct link, but the child must resolve
    // the image from the folder where it was actually found.
    let mut opened = session();
    open(&mut opened, &moved.join("poster.vectorcraft").to_string_lossy());
    let result = run(&mut opened, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["missingLinks"], json!([]), "moved file's nested link wasn't found: {result}");
    std::fs::remove_dir_all(moved.join("art")).unwrap();
    verify_portable_nested_package(&dir.0.join("delivery/poster Folder"));
}

#[test]
fn identical_stale_paths_in_different_nested_documents_keep_separate_assets() {
    let dir = Folder::new("package-stale-paths");
    let mut poster = session();
    for (number, color) in [(1, RED), (2, BLUE)] {
        let image = dir.file(&format!("art{number}/photo.png"));
        write(&image, &png(300, 300, color));
        let mut part = session();
        place(&mut part, &image);
        let name = dir.file(&format!("art{number}/part.vectorcraft"));
        save(&mut part, &name);

        // Two otherwise independent linked documents have the *same* obsolete
        // absolute image path. Their relative paths identify different files.
        let mut saved = vectorcraft_format::load(&std::fs::read(&name).unwrap()).unwrap();
        saved.update_links(|link| {
            link.path = "/old-computer/illustrations/photo.png".into();
            link.relative = Some("photo.png".into());
        });
        write(&name, &vectorcraft_format::save_file(&saved));
        run(&mut poster, "file.place", json!({ "path": name, "link": true }));
    }
    save(&mut poster, &dir.file("poster.vectorcraft"));
    let result = run(&mut poster, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["links"], 4, "both images and both documents must be copied: {result}");
    assert_eq!(result["missingLinks"], json!([]), "{result}");
    let folder = dir.0.join("delivery/poster Folder");
    std::fs::remove_dir_all(dir.0.join("art1")).unwrap();
    std::fs::remove_dir_all(dir.0.join("art2")).unwrap();

    let mut actual = Vec::new();
    for filename in result["files"].as_array().unwrap().iter().filter_map(Value::as_str).filter(|name| name.ends_with(".png")) {
        actual.push(std::fs::read(folder.join(filename)).unwrap());
    }
    assert_eq!(actual.len(), 2, "stale source paths must not cause asset deduplication");
    assert_ne!(actual[0], actual[1], "different original illustrations must keep different pixels");
    for filename in result["files"]
        .as_array()
        .unwrap()
        .iter()
        .filter_map(Value::as_str)
        .filter(|name| name.starts_with("Links/") && name.ends_with(".vectorcraft"))
    {
        let mut nested = session();
        let opened = open(&mut nested, &folder.join(filename).to_string_lossy());
        assert_eq!(opened["missingLinks"], json!([]), "{filename}: {opened}");
    }
}

#[test]
fn packaging_nested_files_preserves_embedded_preview_pdf_and_compression() {
    let dir = Folder::new("package-native-extras");
    let mut parent = poster_with_placed_document(&dir);
    let source = dir.file("art/part.vectorcraft");
    let original = std::fs::read(&source).unwrap();
    let doc = vectorcraft_format::load(&original).unwrap();
    let preview = png(8, 8, BLUE);
    let pdf = b"%PDF-1.7\n%Embedded client preview\n".to_vec();
    let mut opts = vectorcraft_format::SaveOptions::for_doc(&doc);
    opts.preview = Some(preview.clone());
    opts.pdf = Some(pdf.clone());
    opts.compress = true;
    write(&source, &vectorcraft_format::save_with(&doc, &opts).unwrap());

    let result = run(&mut parent, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["missingLinks"], json!([]), "{result}");
    let packaged = std::fs::read(dir.0.join("delivery/poster Folder/Links/part.vectorcraft")).unwrap();
    assert!(packaged.starts_with(&[0x1f, 0x8b]), "compression must be preserved");
    assert_eq!(vectorcraft_format::preview(&packaged), Some(preview));
    assert_eq!(vectorcraft_format::pdf_content(&packaged), Some(pdf));
    let nested = vectorcraft_format::load(&packaged).unwrap();
    let mut images = Vec::new();
    nested.visit_images(|_, image| images.push(image.link.clone()));
    assert_eq!(images.len(), 1);
    assert_eq!(images[0].as_ref().unwrap().relative.as_deref(), Some("photo.png"));
}

/// Without Relink, Package copies a placed document as it is and reads no preview or PDF from it.
#[test]
fn package_reads_no_preview_or_pdf_of_a_placed_document_without_relink() {
    use cmd::package::PARTS_READ;
    let dir = Folder::new("package-native-no-relink");
    let mut parent = poster_with_placed_document(&dir);
    let original = std::fs::read(dir.file("art/part.vectorcraft")).unwrap();
    for (relink, reads, out) in [(false, 0, "as is"), (true, 1, "relinked")] {
        let before = PARTS_READ.with(std::cell::Cell::get);
        let r = run(&mut parent, "file.package", json!({"folder": dir.file(out), "relink": relink}));
        assert_eq!((r["links"].as_u64(), PARTS_READ.with(std::cell::Cell::get) - before), (Some(2), reads), "{out}: {r}");
    }
    assert_eq!(std::fs::read(dir.0.join("as is/poster Folder/Links/part.vectorcraft")).unwrap(), original);
}

/// The report keeps the packaged document's sections as they were, then gives each placed
/// document's own, headed by its file, instead of nesting them inside the parent's list.
#[test]
fn the_report_lists_a_placed_documents_links_in_a_section_of_its_own() {
    let dir = Folder::new("package-report-sections");
    let mut parent = poster_with_placed_document(&dir);
    run(&mut parent, "file.package", json!({ "folder": dir.file("delivery"), "copyFonts": false }));
    let report = std::fs::read_to_string(dir.0.join("delivery/poster Folder/poster Report.txt")).unwrap();
    let lines: Vec<&str> = report.lines().collect();
    let sections: Vec<usize> = lines.iter().enumerate().filter(|(_, l)| **l == "LINKED FILES").map(|(i, _)| i).collect();
    let [poster, part] = sections[..] else { panic!("two link sections: {report}") };
    assert!(lines[poster + 1].ends_with("โ†’ Links/part.vectorcraft"), "the packaged document's section as before: {report}");
    assert!(lines[part + 1].starts_with("Document: ") && lines[part + 1].ends_with("part.vectorcraft"), "{report}");
    assert!(lines[part + 2].ends_with("โ†’ Links/photo.png"), "{report}");
}

/// A damaged or newer-format linked native file is still an asset worth delivering.
/// Package must preserve the exact bytes instead of failing the entire handoff.
#[test]
fn unreadable_placed_document_is_copied_unchanged_with_warning() {
    let dir = Folder::new("package-unreadable-placed");
    let mut parent = poster_with_placed_document(&dir);
    let damaged = dir.file("art/part.vectorcraft");
    let bytes = b"not a parseable VectorCraft file".to_vec();
    write(&damaged, &bytes);

    let result = run(&mut parent, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["links"], 1, "{result}");
    assert_eq!(result["missingLinks"], json!([]), "{result}");
    let warnings = result["warnings"].as_array().unwrap();
    assert_eq!(warnings.len(), 1, "{result}");
    assert!(warnings[0].as_str().unwrap().contains("unreadable linked document"), "{result}");

    let packaged = dir.0.join("delivery/poster Folder");
    assert_eq!(std::fs::read(packaged.join("Links/part.vectorcraft")).unwrap(), bytes);
    let report = std::fs::read_to_string(packaged.join("poster Report.txt")).unwrap();
    assert!(report.lines().any(|line| line == "LINKED FILES"), "{report}");
    assert!(report.contains("copied unchanged") && report.contains("its own links were not collected"), "{report}");
}

#[test]
fn circular_placed_links_copy_each_document_once_and_warn() {
    let dir = Folder::new("package-placed-cycle");
    let source = dir.file("root.vectorcraft");
    let child_path = dir.file("child.vectorcraft");

    let mut root = session();
    save(&mut root, &source);
    let mut child = session();
    run(&mut child, "file.place", json!({ "path": source, "link": true }));
    save(&mut child, &child_path);
    run(&mut root, "file.place", json!({ "path": child_path, "link": true }));
    save(&mut root, &source);

    let result = run(&mut root, "file.package", json!({ "folder": dir.file("delivery") }));
    assert_eq!(result["links"], 1, "the root must not be copied a second time: {result}");
    assert_eq!(result["missingLinks"], json!([]), "{result}");
    assert!(result["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("circular placed-document link")), "{result}");
    let packaged = dir.0.join("delivery/root Folder");
    let root_doc = vectorcraft_format::load(&std::fs::read(packaged.join("root.vectorcraft")).unwrap()).unwrap();
    let child_doc = vectorcraft_format::load(&std::fs::read(packaged.join("Links/child.vectorcraft")).unwrap()).unwrap();
    let mut direct = Vec::new();
    root_doc.visit_placed(|_, p| direct.push(p.link.relative.clone()));
    assert_eq!(direct, [Some("Links/child.vectorcraft".into())]);
    let mut back = Vec::new();
    child_doc.visit_placed(|_, p| {
        back.push((p.link.relative.clone(), p.link.hash.clone(), p.link.size));
    });
    assert_eq!(back, [(Some("../root.vectorcraft".into()), None, None)]);
    let report = std::fs::read_to_string(packaged.join("root Report.txt")).unwrap();
    assert!(report.lines().any(|line| line == "LINKED FILES"), "{report}");
    assert!(report.contains("stopped following the cycle"), "{report}");
}

#[test]
fn nesting_limit_copies_boundary_file_and_reports_uncollected_links() {
    let dir = Folder::new("package-placed-depth-limit");
    let mut deepest = session();
    let mut next = dir.file("leaf.vectorcraft");
    save(&mut deepest, &next);

    let mut root = None;
    for depth in (0..=vectorcraft_doc::placed_document::MAX_DEPTH).rev() {
        let mut current = session();
        run(&mut current, "file.place", json!({ "path": next, "link": true }));
        let name = dir.file(&format!("level{depth}.vectorcraft"));
        save(&mut current, &name);
        next = name;
        if depth == 0 {
            root = Some(current);
        }
    }

    let mut root = root.unwrap();
    let result = run(&mut root, "file.package", json!({ "folder": dir.file("delivery") }));
    let expected_links = vectorcraft_doc::placed_document::MAX_DEPTH + 1;
    assert_eq!(result["links"].as_u64(), Some(expected_links as u64), "{result}");
    assert!(result["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("nesting limit reached")), "{result}");
    let folder = dir.0.join("delivery/level0 Folder");
    let packaged = std::fs::read(folder.join("Links/leaf.vectorcraft")).unwrap();
    assert_eq!(packaged, std::fs::read(dir.file("leaf.vectorcraft")).unwrap());
    let report = std::fs::read_to_string(folder.join("level0 Report.txt")).unwrap();
    assert!(report.contains("nesting limit reached"), "{report}");
}