M4.64: File > Package collects the document, its linked files and fonts with a report; Document Info categories and Save

File > Package (saved documents; unsaved changes are saved first) writes
<folder>/<name>/<document>.vectorcraft, the linked files in Links/ (relinked in the
packaged copy), the fonts its type uses in Fonts/ (leaving out fonts whose licence
doesn't allow embedding) and <document> Report.txt, then offers Show Package. Without a
folder (the web, agents) the same files come back as a zip.

Document Info's flyout picks one category (document, objects, styles, spot colours,
patterns, gradients, symbols, fonts, font details, linked and embedded images) and Save…
writes the text report Package shares.

Engine: file.package {folder?, name?, copyLinks?, linksFolder?, relink?, copyFonts?,
report?}; document.info gains category, format: text and sections. Text: FontFace
path, fs_type and embeddable. UI: ui.packageDialog (dialog `package`), file.showPackage,
docInfo.save.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/engine/src/cmd/docinfo.rs

@@ -1,4 +1,5 @@
-//! Document Info panel data and Object → Make Pixel Perfect.
+//! Document Info panel data, its categories and the text report (Document Info › Save…, File →
+//! Package), and Object → Make Pixel Perfect.
 
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -16,7 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Document Info",
             ["Window", "Document Info"],
             None,
-            "{selectionOnly?} → {document, objects: {paths, compoundPaths, groups, …}, fonts, images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), …}",
+            "{selectionOnly?, category?: document|objects|graphicStyles|spotColors|patterns|gradients|symbols|fonts|fontDetails|linkedImages|embeddedImages (only that one in sections and the text), format?: \"text\" (→ {text}: the report Document Info › Save… and Package write)} → {document, objects: {paths, compoundPaths, groups, …}, fonts, images, swatches, graphicStyleNames (with selectionOnly: the styles the selected objects are linked to), …, sections: [{id, title, rows: [[label, value]]}] (the panel's categories; fontDetails: each font's file and whether its licence lets it be embedded)}",
             has_doc,
             info
         ),
@@ -32,6 +33,160 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+/// Document Info's categories: (id, title), in the order the panel and the report show them.
+pub const CATEGORIES: [(&str, &str); 11] = [
+    ("document", "Document"),
+    ("objects", "Objects"),
+    ("graphicStyles", "Graphic Styles"),
+    ("spotColors", "Spot Colors"),
+    ("patterns", "Pattern Objects"),
+    ("gradients", "Gradient Swatches"),
+    ("symbols", "Symbols"),
+    ("fonts", "Fonts"),
+    ("fontDetails", "Font Details"),
+    ("linkedImages", "Linked Images"),
+    ("embeddedImages", "Embedded Images"),
+];
+
+/// The object counts of `document.info` and their labels.
+const OBJECT_LABELS: [(&str, &str); 16] = [
+    ("paths", "Paths"),
+    ("compoundPaths", "Compound Paths"),
+    ("groups", "Groups"),
+    ("clipGroups", "Clipping Masks"),
+    ("textObjects", "Text Objects"),
+    ("images", "Images"),
+    ("symbolInstances", "Symbol Instances"),
+    ("gradients", "Gradient Objects"),
+    ("patterns", "Pattern Objects"),
+    ("meshes", "Gradient Meshes"),
+    ("blends", "Blends"),
+    ("envelopes", "Envelopes"),
+    ("repeats", "Repeats"),
+    ("opacityMasks", "Opacity Masks"),
+    ("liveEffects", "Objects with Effects"),
+    ("guides", "Guides"),
+];
+
+/// One category of Document Info: its id, title and `(label, value)` rows (a list item has an
+/// empty value).
+pub struct Section {
+    pub id: &'static str,
+    pub title: &'static str,
+    pub rows: Vec<(String, String)>,
+}
+
+/// What a font's `fsType` lets a copy of it do.
+pub fn embedding_label(fs_type: u16) -> &'static str {
+    match fs_type & 0x000f {
+        0x0002 => "embedding not allowed",
+        0x0004 => "embedding for preview and print",
+        0x0008 => "embedding for editing",
+        _ => "embedding allowed",
+    }
+}
+
+/// An image object as Document Info lists it: (name, width, height, linked file).
+type ImageRow = (String, u32, u32, Option<String>);
+
+/// The Document Info categories of `d` (only `category` when given) from `info` (what
+/// `document.info` reports), its fonts `(family, style)`, image objects and used patterns.
+fn sections(d: &Document, info: &Value, fonts: &BTreeSet<(String, String)>, images: &[ImageRow], category: Option<&str>) -> Vec<Section> {
+    let names = |k: &str| -> Vec<(String, String)> {
+        info[k].as_array().into_iter().flatten().filter_map(Value::as_str).map(|n| (n.to_string(), String::new())).collect()
+    };
+    let u = d.units;
+    CATEGORIES
+        .iter()
+        .filter(|(id, _)| category.is_none_or(|c| c == *id))
+        .map(|&(id, title)| {
+            let rows = match id {
+                "document" => {
+                    let mut rows = vec![
+                        ("Name".to_string(), info["document"]["name"].as_str().unwrap_or_default().to_string()),
+                        ("Color Mode".into(), info["document"]["colorMode"].as_str().unwrap_or_default().into()),
+                        ("Units".into(), u.label().into()),
+                        ("Artboards".into(), d.artboards.len().to_string()),
+                    ];
+                    rows.extend(
+                        d.artboards.iter().map(|a| (a.name.clone(), format!("{} × {}", u.format(a.rect.width()), u.format(a.rect.height())))),
+                    );
+                    rows.push(("Raster Effects".into(), format!("{} ppi", d.raster_effects_ppi)));
+                    let counts = [
+                        ("Swatches", "swatches"),
+                        ("Character Styles", "characterStyles"),
+                        ("Paragraph Styles", "paragraphStyles"),
+                        ("Pattern Swatches", "patterns"),
+                    ];
+                    rows.extend(counts.map(|(label, k)| (label.to_string(), info[k].to_string())));
+                    rows
+                }
+                "objects" => {
+                    OBJECT_LABELS.iter().filter_map(|(k, label)| Some((label.to_string(), info["objects"][k].as_u64()?.to_string()))).collect()
+                }
+                "graphicStyles" => names("graphicStyleNames"),
+                "spotColors" => names("spotColors"),
+                "patterns" => names("patternNames"),
+                "gradients" => d.swatches_iter().filter(|s| matches!(s.paint, Paint::Gradient(_))).map(|s| (s.name.clone(), String::new())).collect(),
+                "symbols" => names("symbols"),
+                "fonts" => fonts.iter().map(|(f, s)| (format!("{f} {s}"), String::new())).collect(),
+                "fontDetails" => {
+                    let db = vectorcraft_text::FontDb::global();
+                    fonts
+                        .iter()
+                        .map(|(family, style)| {
+                            let detail = match db.face(family, style) {
+                                Some(f) if f.family.eq_ignore_ascii_case(family) => {
+                                    let file =
+                                        f.path().and_then(|p| p.file_name()).map_or_else(|| "built in".into(), |n| n.to_string_lossy().into_owned());
+                                    format!("{file}; {}", embedding_label(f.fs_type()))
+                                }
+                                Some(f) => format!("missing: shown in {} {}", f.family, f.style),
+                                None => "missing".into(),
+                            };
+                            (format!("{family} {style}"), detail)
+                        })
+                        .collect()
+                }
+                "linkedImages" => {
+                    images.iter().filter_map(|(name, w, h, link)| Some((name.clone(), format!("{w} × {h} px — {}", link.as_ref()?)))).collect()
+                }
+                _ => images.iter().filter(|i| i.3.is_none()).map(|(name, w, h, _)| (name.clone(), format!("{w} × {h} px"))).collect(),
+            };
+            Section { id, title, rows }
+        })
+        .collect()
+}
+
+/// `sections` as the plain-text report of document `name`: a heading, then each category's title
+/// and rows.
+pub fn report_text(name: &str, selection_only: bool, sections: &[Section]) -> String {
+    let mut out = format!("Document Info: {name}\n");
+    if selection_only {
+        out.push_str("(the selection only)\n");
+    }
+    for sec in sections {
+        out.push_str(&format!("\n{}\n", sec.title.to_uppercase()));
+        if sec.rows.is_empty() {
+            out.push_str("None\n");
+        }
+        for (label, value) in &sec.rows {
+            if value.is_empty() {
+                out.push_str(&format!("{label}\n"));
+            } else {
+                out.push_str(&format!("{label}: {value}\n"));
+            }
+        }
+    }
+    out
+}
+
+/// The text report of the active document (`document.info {format: "text"}` as a string).
+pub fn report(s: &mut Session, selection_only: bool) -> Result<String> {
+    let v = info(s, &json!({ "selectionOnly": selection_only, "format": "text" }))?;
+    Ok(v["text"].as_str().unwrap_or_default().to_string())
+}
+
 fn paint_kind(p: &Paint) -> Option<&'static str> {
     match p {
         Paint::Gradient(_) => Some("gradients"),
@@ -41,6 +196,17 @@ fn paint_kind(p: &Paint) -> Option<&'static str> {
 }
 
 fn info(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "document.info";
+    let category = str_param(p, "category");
+    if let Some(c) = category.filter(|c| !CATEGORIES.iter().any(|(id, _)| id == c)) {
+        let ids: Vec<&str> = CATEGORIES.iter().map(|(id, _)| *id).collect();
+        return Err(bad(C, format!("category `{c}`: one of {}", ids.join(", "))));
+    }
+    let text = match str_param(p, "format") {
+        None | Some("json") => false,
+        Some("text") => true,
+        Some(f) => return Err(bad(C, format!("format `{f}`: text or json"))),
+    };
     let st = s.doc()?;
     let d = &st.doc;
     let selection_only = bool_or(p, "selectionOnly", false);
@@ -49,6 +215,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
     let mut counts: BTreeMap<&str, usize> = BTreeMap::new();
     let mut fonts = BTreeSet::new();
     let mut images: BTreeMap<String, Value> = BTreeMap::new();
+    let mut image_rows: Vec<ImageRow> = vec![];
+    let mut patterns = BTreeSet::new();
     let mut symbols = BTreeSet::new();
     let mut spot = BTreeSet::new();
     let mut styles: Vec<&str> = if selection_only { vec![] } else { d.graphic_styles.iter().map(|g| g.name.as_str()).collect() };
@@ -63,7 +231,7 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
                 NodeKind::Compound { .. } => Some("compoundPaths"),
                 NodeKind::Text(t) => {
                     for run in &t.runs {
-                        fonts.insert(format!("{} {}", run.style.font_family, run.style.font_style));
+                        fonts.insert((run.style.font_family.clone(), run.style.font_style.clone()));
                     }
                     Some("textObjects")
                 }
@@ -72,6 +240,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
                         im.key.clone(),
                         json!({ "width": im.width, "height": im.height, "linked": im.link.is_some(), "link": im.link.as_ref().map(|l| &l.path) }),
                     );
+                    let name = im.link.as_ref().map_or_else(|| n.display_name(), |l| l.name().to_string());
+                    image_rows.push((name, im.width, im.height, im.link.as_ref().map(|l| l.path.clone())));
                     Some("images")
                 }
                 NodeKind::SymbolInstance { symbol, .. } => {
@@ -94,6 +264,9 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
                 if let Some(k) = paint_kind(paint) {
                     *counts.entry(k).or_default() += 1;
                 }
+                if let Paint::Pattern { pattern, .. } = paint {
+                    patterns.insert(pattern.clone());
+                }
                 if let Paint::Solid { swatch: Some(name), .. } = paint
                     && d.swatch(name).is_some_and(|s| s.spot)
                 {
@@ -114,10 +287,11 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
             }
         });
     }
-    Ok(json!({
+    let font_names: Vec<String> = fonts.iter().map(|(f, s)| format!("{f} {s}")).collect();
+    let mut out = json!({
         "document": document_summary(d),
         "objects": counts,
-        "fonts": fonts,
+        "fonts": font_names,
         "images": images,
         "symbols": symbols,
         "spotColors": spot,
@@ -127,7 +301,16 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
         "characterStyles": d.char_styles.len(),
         "paragraphStyles": d.para_styles.len(),
         "patterns": d.patterns.len(),
-    }))
+        "patternNames": patterns,
+    });
+    // The document's name: its file's, else its title.
+    out["document"]["name"] = json!(st.title());
+    let sections = sections(d, &out, &fonts, &image_rows, category);
+    if text {
+        return Ok(json!({ "text": report_text(&st.title(), selection_only, &sections) }));
+    }
+    out["sections"] = sections.iter().map(|s| json!({ "id": s.id, "title": s.title, "rows": s.rows })).collect();
+    Ok(out)
 }
 
 fn document_summary(d: &Document) -> Value {
@@ -205,6 +388,14 @@ mod tests {
         assert!(i["objects"]["textObjects"].is_null() && i["objects"]["paths"] == 1);
     }
 
+    #[test]
+    fn embedding_permissions_read_from_fs_type() {
+        assert_eq!(embedding_label(0), "embedding allowed");
+        assert_eq!(embedding_label(0x0002), "embedding not allowed");
+        assert_eq!(embedding_label(0x0004 | 0x0100), "embedding for preview and print");
+        assert_eq!(embedding_label(0x0008), "embedding for editing");
+    }
+
     #[test]
     fn pixel_perfect_snaps_edges_and_strokes() {
         let mut s = Session::new();

crates/engine/src/cmd/links.rs

@@ -254,6 +254,32 @@ fn previewing(d: &Document, key: &str) -> bool {
     d.images.get(key).is_none_or(ImageBlob::is_proxy)
 }
 
+/// A linked file of a document (File → Package): its path, name and bytes.
+pub(crate) struct LinkedFile {
+    pub path: String,
+    pub name: String,
+    /// Read from where the file is found, else the pixels the document holds when they are the
+    /// file's own; `None` when neither.
+    pub bytes: Option<Vec<u8>>,
+}
+
+/// Every file the linked images of `d` (saved at `doc_path`) show, in the layers, symbols and
+/// patterns, once each.
+pub(crate) fn linked_files(d: &Document, doc_path: Option<&str>) -> Vec<LinkedFile> {
+    let mut seen = std::collections::BTreeSet::new();
+    groups(d, None)
+        .into_iter()
+        .filter(|g| seen.insert(g.link.path.clone()))
+        .map(|g| {
+            let own = |b: &&ImageBlob| !b.is_proxy() && fileio::format_for_name(g.link.name()).is_some_and(|f| f.mime == b.mime);
+            let bytes = locate(&g.link, folder(doc_path))
+                .and_then(|mut f| f.read().ok())
+                .or_else(|| d.images.get(&g.key).filter(own).map(|b| b.bytes.to_vec()));
+            LinkedFile { path: g.link.path.clone(), name: g.link.name().to_string(), bytes }
+        })
+        .collect()
+}
+
 // ---------- reading files into the document ----------
 
 /// Keep `full` (a file's pixels) as image `key` of `d`, unless pixels are there already; a

crates/engine/src/cmd/mod.rs

@@ -35,6 +35,7 @@ pub mod newdoc;
 mod object;
 mod opacitymask;
 mod overprint;
+mod package;
 mod paint;
 mod panelcmds;
 mod path;
@@ -223,6 +224,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(links::specs());
         v.extend(pdfcmds::specs());
         v.extend(fileio::dxf::specs());
+        v.extend(package::specs());
         v
     })
 }

crates/engine/src/cmd/package.rs

@@ -0,0 +1,265 @@
+//! File → Package: a saved document copied into a folder of its own with the files its linked
+//! images show (`Links/`), the fonts its type uses (`Fonts/`, leaving out fonts whose licence
+//! doesn't allow embedding) and a text report (the package's contents, then the Document Info
+//! report). The packaged document links to the copies (Relink); the open document doesn't change.
+//! Without a folder (the web, agents) the same files come back as a zip archive.
+
+use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::io::Write;
+use std::path::Path;
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{Document, Node, NodeKind};
+
+use super::fileio::{create_dir, write_file};
+use super::*;
+
+const C: &str = "file.package";
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![cmd!(
+        "file.package",
+        "Package",
+        [],
+        None,
+        "{folder?, name?: (default: \"<document> Folder\"), copyLinks?: true, linksFolder?: true (the linked files go in Links/, else next to the document), relink?: true (the packaged document links to the copies), copyFonts?: true (the fonts its type uses go in Fonts/; fonts whose licence doesn't allow embedding are left out), report?: true (<document> Report.txt)} copy the saved document as it is now into folder/name as <document>.vectorcraft with its linked files and fonts; the open document doesn't change → {folder, files: [paths relative to folder/name], links, fonts (counts copied), missingLinks: [file names not found], skippedFonts: [{font, reason}]}; no folder → the same with {name: \"<name>.zip\", dataBase64} (a zip of the files in <name>/) instead of folder",
+        has_doc,
+        package
+    )]
+}
+
+/// A file of the package: its path in the package folder (`/` separators) and bytes.
+type Entry = (String, Vec<u8>);
+
+/// `name`, else the first free `stem 2.ext`, `stem 3.ext`… (compared without case, as most
+/// desktop file systems do); the name is taken.
+fn free_name(name: &str, taken: &mut HashSet<String>) -> String {
+    let p = Path::new(name);
+    let stem = p.file_stem().map_or_else(|| name.to_string(), |s| s.to_string_lossy().into_owned());
+    let ext = p.extension().map(|e| format!(".{}", e.to_string_lossy())).unwrap_or_default();
+    let out = unique_name(&stem, |s| taken.contains(&format!("{s}{ext}").to_lowercase())) + &ext;
+    taken.insert(out.to_lowercase());
+    out
+}
+
+/// A font file's extension from its first bytes.
+fn font_ext(bytes: &[u8]) -> &'static str {
+    match bytes.get(..4) {
+        Some(b"OTTO") => "otf",
+        Some(b"ttcf") => "ttc",
+        _ => "ttf",
+    }
+}
+
+/// The fonts (family, style) of the type in the layers and symbols of `d`.
+fn used_fonts(d: &Document) -> BTreeSet<(String, String)> {
+    let mut fonts = BTreeSet::new();
+    let mut add = |n: &Node| {
+        if let NodeKind::Text(t) = &n.kind {
+            fonts.extend(t.runs.iter().map(|r| (r.style.font_family.clone(), r.style.font_style.clone())));
+        }
+    };
+    d.walk(&mut add);
+    for s in &d.symbols {
+        s.art.walk(&mut add);
+    }
+    fonts
+}
+
+/// The options of a package.
+struct Options {
+    copy_links: bool,
+    links_folder: bool,
+    relink: bool,
+    copy_fonts: bool,
+    report: bool,
+}
+
+fn package(s: &mut Session, p: &Value) -> Result<Value> {
+    let o = Options {
+        copy_links: bool_or(p, "copyLinks", true),
+        links_folder: bool_or(p, "linksFolder", true),
+        relink: bool_or(p, "relink", true),
+        copy_fonts: bool_or(p, "copyFonts", true),
+        report: bool_or(p, "report", true),
+    };
+    let doc_path = s.doc()?.path.clone().ok_or_else(|| bad(C, "save the document first: Package collects a saved document"))?;
+    let stem = Path::new(&doc_path).file_stem().map_or_else(|| "Untitled".into(), |s| s.to_string_lossy().into_owned());
+    let name = str_param(p, "name").map_or_else(|| format!("{stem} Folder"), str::to_string);
+    if name.trim().is_empty() || name == "." || name == ".." || name.contains(['/', '\\', ':', '*', '?', '"', '<', '>', '|']) {
+        return Err(bad(C, format!("`{name}` can't name a folder")));
+    }
+    let folder = str_param(p, "folder");
+    let root = folder.map(|f| Path::new(f).join(&name));
+    let info = if o.report { Some(super::docinfo::report(s, false)?) } else { None };
+    let st = s.doc()?;
+    let mut entries: Vec<Entry> = vec![];
+    let mut taken = HashSet::new();
+    let mut lines = vec![];
+
+    // The linked files.
+    let (mut copies, mut missing) = (BTreeMap::new(), vec![]);
+    if o.copy_links {
+        let dir = if o.links_folder { "Links/" } else { "" };
+        let mut names = HashSet::new();
+        lines.push("LINKED FILES".to_string());
+        for f in super::links::linked_files(&st.doc, Some(&doc_path)) {
+            let Some(bytes) = f.bytes else {
+                lines.push(format!("{}: not found ({}), not copied", f.name, f.path));
+                missing.push(f.name);
+                continue;
+            };
+            let rel = format!("{dir}{}", free_name(&f.name, if o.links_folder { &mut names } else { &mut taken }));
+            lines.push(format!("{} → {rel}", f.path));
+            copies.insert(f.path, rel.clone());
+            entries.push((rel, bytes));
+        }
+        lines.push(String::new());
+    }
+
+    // The fonts.
+    let (mut fonts, mut skipped) = (0, vec![]);
+    if o.copy_fonts {
+        let db = vectorcraft_text::FontDb::global();
+        let mut files = HashSet::new();
+        lines.push("FONTS".to_string());
+        for (family, style) in used_fonts(&st.doc) {
+            let font = format!("{family} {style}");
+            let reason = match db.face(&family, &style) {
+                Some(f) if f.family.eq_ignore_ascii_case(&family) && f.embeddable() => {
+                    let data = f.file_data();
+                    let file = f.path().and_then(Path::file_name).map_or_else(
+                        || format!("{}-{}.{}", f.family, f.style, font_ext(data)).replace(|c: char| !(c.is_alphanumeric() || "-_.".contains(c)), ""),
+                        |n| n.to_string_lossy().into_owned(),
+                    );
+                    // A collection, or a style shown in another face's file, is copied once.
+                    if files.insert(file.to_lowercase()) {
+                        entries.push((format!("Fonts/{file}"), data.to_vec()));
+                        fonts += 1;
+                    }
+                    lines.push(format!("{font} → Fonts/{file}"));
+                    continue;
+                }
+                Some(f) if f.family.eq_ignore_ascii_case(&family) => "its licence doesn't allow embedding",
+                _ => "not available on this computer",
+            };
+            lines.push(format!("{font}: {reason}, not copied"));
+            skipped.push(json!({ "font": font, "reason": reason }));
+        }
+        lines.push(String::new());
+    }
+
+    // The document, linking to the copies.
+    let mut doc = (*st.doc).clone();
+    let doc_name = format!("{stem}.{}", vectorcraft_format::EXTENSION);
+    if let Some(root) = &root
+        && let Some(d) = super::links::with_relative_paths(&doc, &root.join(&doc_name).to_string_lossy())
+    {
+        doc = d;
+    }
+    if o.relink && !copies.is_empty() {
+        let copied = |im: &vectorcraft_doc::ImageObject| im.link.as_ref().is_some_and(|l| copies.contains_key(&l.path));
+        doc.update_images(copied, |im| {
+            if let Some(l) = &mut im.link
+                && let Some(rel) = copies.get(&l.path)
+            {
+                l.path = root.as_ref().map_or_else(|| rel.clone(), |r| r.join(rel).to_string_lossy().into_owned());
+                (l.relative, l.modified) = (Some(rel.clone()), None);
+            }
+        });
+    }
+    entries.insert(0, (doc_name.clone(), vectorcraft_format::save_file(&doc)));
+    taken.insert(doc_name.to_lowercase());
+
+    // The report.
+    if let Some(info) = info {
+        let report_name = free_name(&format!("{stem} Report.txt"), &mut taken);
+        let mut text = format!("Package: {doc_name}\nFrom: {doc_path}\n\n");
+        lines.iter().for_each(|l| text.push_str(&format!("{l}\n")));
+        text.push_str(&info);
+        entries.push((report_name, text.into_bytes()));
+    }
+
+    let files: Vec<&str> = entries.iter().map(|(p, _)| p.as_str()).collect();
+    let mut out = json!({ "files": files, "links": copies.len(), "fonts": fonts, "missingLinks": missing, "skippedFonts": skipped });
+    match root {
+        Some(root) => {
+            for (rel, bytes) in &entries {
+                let path = root.join(rel);
+                if let Some(dir) = path.parent() {
+                    create_dir(&dir.to_string_lossy())?;
+                }
+                write_file(&path.to_string_lossy(), bytes)?;
+            }
+            out["folder"] = json!(root.to_string_lossy());
+        }
+        None => {
+            let named: Vec<(String, &[u8])> = entries.iter().map(|(rel, b)| (format!("{name}/{rel}"), b.as_slice())).collect();
+            let zip = zip(&named)?;
+            out["name"] = json!(format!("{name}.zip"));
+            out["bytes"] = json!(zip.len());
+            out["dataBase64"] = json!(vectorcraft_format::base64_encode(&zip));
+        }
+    }
+    Ok(out)
+}
+
+// ---------- zip archives ----------
+
+/// The MS-DOS time and date a zip entry records: now (UTC), else 1980-01-01.
+fn dos_time() -> (u16, u16) {
+    let Some(t) = vectorcraft_doc::metadata::now_unix() else { return (0, 0x21) };
+    let [y, mo, d, h, mi, s] = vectorcraft_doc::metadata::civil(t);
+    let date = (((y - 1980).clamp(0, 127) << 9) | (mo << 5) | d) as u16;
+    (((h << 11) | (mi << 5) | (s / 2)) as u16, date)
+}
+
+/// A zip archive of `files` ((path with `/` separators, bytes)), each deflated, or stored when
+/// that isn't smaller.
+pub(crate) fn zip(files: &[(String, &[u8])]) -> Result<Vec<u8>> {
+    let too_big = || bad(C, "too large for a zip archive: package to a folder");
+    let io = |e: std::io::Error| EngineError::Other(e.to_string());
+    let (time, date) = dos_time();
+    let (mut out, mut central) = (Vec::new(), Vec::new());
+    for (name, bytes) in files {
+        let mut crc = flate2::Crc::new();
+        crc.update(bytes);
+        let mut enc = flate2::write::DeflateEncoder::new(Vec::new(), flate2::Compression::default());
+        enc.write_all(bytes).map_err(io)?;
+        let deflated = enc.finish().map_err(io)?;
+        let (method, data): (u16, &[u8]) = if deflated.len() < bytes.len() { (8, &deflated) } else { (0, bytes) };
+        let offset = u32::try_from(out.len()).map_err(|_| too_big())?;
+        let (packed, size) = (u32::try_from(data.len()).map_err(|_| too_big())?, u32::try_from(bytes.len()).map_err(|_| too_big())?);
+        let name_len = u16::try_from(name.len()).map_err(|_| too_big())?;
+        // Version 2.0, UTF-8 names, method, time, date, CRC-32, sizes, name length, no extra field.
+        let common = [&20u16.to_le_bytes()[..], &0x0800u16.to_le_bytes(), &method.to_le_bytes(), &time.to_le_bytes(), &date.to_le_bytes()].concat();
+        let sums = [crc.sum().to_le_bytes(), packed.to_le_bytes(), size.to_le_bytes()].concat();
+        out.extend_from_slice(&0x0403_4b50u32.to_le_bytes());
+        out.extend_from_slice(&common);
+        out.extend_from_slice(&sums);
+        out.extend_from_slice(&name_len.to_le_bytes());
+        out.extend_from_slice(&0u16.to_le_bytes());
+        out.extend_from_slice(name.as_bytes());
+        out.extend_from_slice(data);
+        central.extend_from_slice(&0x0201_4b50u32.to_le_bytes());
+        central.extend_from_slice(&20u16.to_le_bytes());
+        central.extend_from_slice(&common);
+        central.extend_from_slice(&sums);
+        central.extend_from_slice(&name_len.to_le_bytes());
+        // No extra field or comment, disk 0, no attributes.
+        central.extend_from_slice(&[0; 12]);
+        central.extend_from_slice(&offset.to_le_bytes());
+        central.extend_from_slice(name.as_bytes());
+    }
+    let count = u16::try_from(files.len()).map_err(|_| too_big())?;
+    let (start, len) = (u32::try_from(out.len()).map_err(|_| too_big())?, u32::try_from(central.len()).map_err(|_| too_big())?);
+    out.extend_from_slice(&central);
+    out.extend_from_slice(&0x0605_4b50u32.to_le_bytes());
+    out.extend_from_slice(&[0; 4]);
+    out.extend_from_slice(&count.to_le_bytes());
+    out.extend_from_slice(&count.to_le_bytes());
+    out.extend_from_slice(&len.to_le_bytes());
+    out.extend_from_slice(&start.to_le_bytes());
+    out.extend_from_slice(&0u16.to_le_bytes());
+    Ok(out)
+}