diff --git a/crates/color/src/cms/generic.rs b/crates/color/src/cms/generic.rs
index 95abdf2f3..3d532ac02 100644
--- a/crates/color/src/cms/generic.rs
+++ b/crates/color/src/cms/generic.rs
@@ -1,19 +1,26 @@
 //! "VectorCraft Generic CMYK (SWOP-like)": our own parametric press model.
 //!
 //! We can't redistribute Adobe's or ECI's characterisation profiles, so the built-in CMYK space is
-//! a small physical model instead of an ICC LUT. It is *ours* and only SWOP-*like*: the numbers
-//! are rounded, typical values for coated web offset, not a measured dataset.
+//! a small physical model instead of an ICC LUT. It is *ours* and only SWOP-*like*. Two of its
+//! figures are published values for SWOP printing: the tone value increase of each ink at 40% and
+//! 50% from CGATS TR 001 (<https://registry.color.org/cmyk-registry/cgats_tr_001>), and the 300%
+//! total ink limit (<https://en.wikipedia.org/wiki/Specifications_for_Web_Offset_Publications>).
+//! The paper, solid and overprint colors and the black-generation curve are VectorCraft's own values.
 //!
-//! * **Forward (CMYK → XYZ):** each ink's nominal dot area is widened by a parabolic dot-gain
-//!   curve (`a + 4·g·a·(1−a)`, i.e. `g` gain at 50%); the effective areas mix the eight CMY
-//!   Neugebauer primaries with Demichel weights; black is mixed in the same way against
-//!   "primary + K" colours whose optical densities add but saturate towards a maximum density
-//!   (normalised so K on paper is exact), so rich blacks don't multiply to an unrealistic depth.
+//! * **Forward (CMYK → XYZ):** each ink's nominal dot area `a` is widened by a tone curve
+//!   `a + 4·g·a·(1−a)·(1 + s·(2a−1))` that passes through the TR 001 tone value increase at 50%
+//!   (`g`) and 40% (which sets `s`). The effective areas mix the 16 Neugebauer primaries (paper and
+//!   every solid and overprint of C, M, Y and K, media-relative) with Demichel weights, linearly in
+//!   XYZ, so a single ink's colorimetric tone value increase (Murray–Davies) is the TR 001 value.
 //! * **Inverse (Lab → CMYK):** damped, bounded Gauss–Newton on the forward model solves CMY for a
-//!   fixed K. Black generation is GCR: solve CMY with K = 0, take the grey component
-//!   `min(C, M, Y)`, map it through the black-generation curve to K, re-solve CMY. Under-colour
+//!   fixed K. Black generation is GCR: solve CMY with K = 0, take the gray component
+//!   `min(C, M, Y)`, add [`BlackGeneration::shortfall`] for each L* point by which that solve stays
+//!   lighter than the target, map the sum through the black curve to K, re-solve CMY. Under-color
 //!   removal enforces the total area coverage (TAC) limit by adding K and re-solving, then scaling
-//!   CMY as a last resort.
+//!   CMY as a last resort. The black point, which source black separates to and which displays as
+//!   black with black-point compensation, is [`BlackGeneration::black_point_k`] black with neutral
+//!   CMY filling the TAC. With compensation, a build darker than it in every XYZ channel also
+//!   displays as black (see [`GenericCmyk::display_xyz`]).
 //! * **Rendering intents:** colorimetric intents map the source white to paper (relative) or not
 //!   (absolute) and clip; perceptual applies black-point compensation plus soft chroma compression
 //!   against a gamut boundary descriptor (segment maxima of the forward model); saturation keeps
@@ -24,50 +31,82 @@ use std::sync::OnceLock;
 use super::Intent;
 use super::lab::{D50, Lab, delta_e2000, lab_to_xyz, srgb_to_lab, xyz_to_lab, xyz_to_srgb};
 
-/// Black generation strength.
+/// Black generation.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct BlackGeneration {
-    /// Grey component below which no black is generated.
-    pub start: f32,
-    /// Maximum black.
-    pub max_k: f32,
-    /// Curve exponent (>1 = lighter black in the midtones).
-    pub gamma: f32,
+    /// The black curve as `(x, K)` knots with rising `x`, read by linear interpolation. `x` is the
+    /// gray component of the solve without black plus [`Self::shortfall`] per L* point by which
+    /// that solve stays lighter than the target.
+    pub curve: [(f32, f32); 13],
+    /// Added to the gray component for each L* point the black-free solve stays too light.
+    pub shortfall: f32,
+    /// Black of the black point, whose CMY is neutral and fills the TAC.
+    pub black_point_k: f32,
 }
 
 /// Parameters of the parametric press model.
 #[derive(Clone, Debug)]
 pub struct GenericCmykParams {
     pub name: &'static str,
+    /// Paper color (absolute Lab, D50).
     pub paper: Lab,
-    /// Solid overprints, Demichel order: C, M, CM, Y, CY, MY, CMY.
-    pub solids: [Lab; 7],
-    pub black: Lab,
-    /// Dot gain at 50% per ink (C, M, Y, K).
-    pub dot_gain: [f32; 4],
+    /// Media-relative Lab of the solids and overprints, Demichel order (index `c | m<<1 | y<<2 |
+    /// k<<3`, paper left out): C, M, CM, Y, CY, MY, CMY, then K, CK, MK, CMK, YK, CYK, MYK, CMYK.
+    pub primaries: [Lab; 15],
+    /// Tone value increase at 50% per ink (C, M, Y, K).
+    pub tvi50: [f32; 4],
+    /// Tone value increase at 40% per ink (C, M, Y, K).
+    pub tvi40: [f32; 4],
     /// Total area coverage limit (sum of inks, 1.0 = 100%).
     pub tac: f32,
     pub bg: BlackGeneration,
 }
 
-/// Rounded, typical SWOP-like values (not measured data).
+/// The built-in SWOP-like press: TR 001 tone value increase, a 300% ink limit, and VectorCraft's
+/// own paper, primaries and black curve.
 pub fn swop_like() -> GenericCmykParams {
     GenericCmykParams {
         name: super::GENERIC_CMYK,
         paper: Lab::new(93.0, -0.5, 2.5),
-        solids: [
-            Lab::new(55.0, -37.0, -50.0), // C
-            Lab::new(48.0, 74.0, -3.0),   // M
-            Lab::new(24.0, 22.0, -46.0),  // CM (blue)
-            Lab::new(89.0, -5.0, 93.0),   // Y
-            Lab::new(50.0, -65.0, 27.0),  // CY (green)
-            Lab::new(47.0, 68.0, 48.0),   // MY (red)
-            Lab::new(24.0, 1.0, 0.0),     // CMY
+        primaries: [
+            Lab::new(65.7, -42.6, -47.2), // C
+            Lab::new(55.5, 76.2, -9.4),   // M
+            Lab::new(31.1, 20.3, -49.7),  // CM (blue)
+            Lab::new(96.2, -7.0, 90.1),   // Y
+            Lab::new(61.0, -68.4, 30.1),  // CY (green)
+            Lab::new(55.0, 69.8, 45.0),   // MY (red)
+            Lab::new(28.3, 0.7, -0.5),    // CMY
+            Lab::new(21.5, 0.8, -0.9),    // K
+            Lab::new(15.9, -8.4, -10.0),  // CK
+            Lab::new(14.7, 15.4, -1.0),   // MK
+            Lab::new(11.2, 8.9, -6.6),    // CMK
+            Lab::new(20.2, -2.4, 12.0),   // YK
+            Lab::new(15.7, -14.6, 4.6),   // CYK
+            Lab::new(14.5, 11.2, 5.7),    // MYK
+            Lab::new(11.0, -0.7, 0.1),    // CMYK
         ],
-        black: Lab::new(19.0, 0.5, 0.5),
-        dot_gain: [0.20, 0.20, 0.20, 0.22],
+        tvi50: [0.200, 0.176, 0.168, 0.216],
+        tvi40: [0.200, 0.173, 0.167, 0.219],
         tac: 3.0,
-        bg: BlackGeneration { start: 0.1, max_k: 0.95, gamma: 1.25 },
+        bg: BlackGeneration {
+            curve: [
+                (0.0, 0.0),
+                (0.25, 0.0),
+                (0.35, 0.006),
+                (0.45, 0.059),
+                (0.55, 0.139),
+                (0.65, 0.23),
+                (0.75, 0.322),
+                (0.85, 0.41),
+                (0.95, 0.511),
+                (1.05, 0.6),
+                (1.2, 0.733),
+                (1.35, 0.858),
+                (1.5, 1.0),
+            ],
+            shortfall: 0.03,
+            black_point_k: 0.9,
+        },
     }
 }
 
@@ -83,11 +122,12 @@ const GBD_H: usize = 72; // 5° bins
 
 pub struct GenericCmyk {
     pub params: GenericCmykParams,
-    /// XYZ of the 8 CMY primaries (index = c | m<<1 | y<<2), without and with K.
-    prim: [[f32; 3]; 8],
-    prim_k: [[f32; 3]; 8],
+    /// Media-relative XYZ of the 16 primaries (index = c | m<<1 | y<<2 | k<<3; 0 is paper).
+    prim: [[f32; 3]; 16],
+    /// Shape `s` of each ink's tone curve, from its 40% and 50% tone value increase.
+    skew: [f32; 4],
     paper_xyz: [f32; 3],
-    /// Media-relative XYZ of the darkest printable black (for black-point compensation).
+    /// Media-relative XYZ of the black point (for black-point compensation).
     black_rel: [f32; 3],
     gbd: OnceLock<Gbd>,
 }
@@ -95,37 +135,17 @@ pub struct GenericCmyk {
 impl GenericCmyk {
     pub fn new(params: GenericCmykParams) -> Self {
         let paper_xyz = lab_to_xyz(params.paper);
-        let mut prim = [[0.0f32; 3]; 8];
-        prim[0] = paper_xyz;
-        for (p, lab) in prim[1..].iter_mut().zip(params.solids.iter()) {
-            *p = lab_to_xyz(*lab);
+        let mut prim = [D50; 16];
+        for (p, lab) in prim[1..].iter_mut().zip(params.primaries.iter()) {
+            *p = lab_to_xyz(*lab).map(|v| v.max(1e-6));
         }
-        let k_xyz = lab_to_xyz(params.black);
-        // Black over other inks: optical densities add, but saturate towards a maximum density
-        // (ink trapping / surface reflection), normalised so that K on paper is exact.
-        const D_MAX: f32 = 2.0;
-        let sat = |d: f32| D_MAX * (1.0 - (-d / D_MAX).exp());
-        let mut prim_k = [[0.0f32; 3]; 8];
-        for i in 0..8 {
-            for ch in 0..3 {
-                let di = -(prim[i][ch] / paper_xyz[ch]).max(1e-6).log10();
-                let dk = -(k_xyz[ch] / paper_xyz[ch]).max(1e-6).log10();
-                let d = sat(di + dk) * dk / sat(dk).max(1e-6);
-                prim_k[i][ch] = paper_xyz[ch] * 10f32.powf(-d.max(di));
-            }
-        }
-        let mut g = Self { params, prim, prim_k, paper_xyz, black_rel: [0.0; 3], gbd: OnceLock::new() };
-        // Darkest black within TAC: search a few rich blacks.
-        let mut best = [1.0f32; 3];
-        for k in [0.8f32, 0.9, 1.0] {
-            let rest = (g.params.tac - k).max(0.0) / 3.0;
-            let cmy = rest.min(1.0);
-            let x = g.to_xyz_rel([cmy, cmy, cmy, k]);
-            if x[1] < best[1] {
-                best = x;
-            }
-        }
-        g.black_rel = best;
+        // The curve's increase at 40% is 0.96·g·(1 − 0.2·s), so `s` follows from the 40% value.
+        let skew = [0, 1, 2, 3].map(|i| {
+            let g = params.tvi50[i];
+            if g > 1e-6 { (1.0 - params.tvi40[i] / (0.96 * g)) / 0.2 } else { 0.0 }
+        });
+        let mut g = Self { params, prim, skew, paper_xyz, black_rel: [0.0; 3], gbd: OnceLock::new() };
+        g.black_rel = g.to_xyz_rel(g.black_point_build());
         g
     }
 
@@ -133,35 +153,81 @@ impl GenericCmyk {
         self.params.name
     }
 
-    fn gain(a: f32, g: f32) -> f32 {
-        let a = a.clamp(0.0, 1.0);
-        (a + 4.0 * g * a * (1.0 - a)).clamp(0.0, 1.0)
+    /// The black point: [`BlackGeneration::black_point_k`] black, with C, M and Y
+    /// chosen so that they fill the TAC and the color is neutral (a* = b* = 0).
+    pub fn black_point_build(&self) -> [f32; 4] {
+        let k = self.params.bg.black_point_k.clamp(0.0, 1.0);
+        let rest = (self.params.tac - k).clamp(0.0, 3.0);
+        let build = |c: f32, m: f32| [c, m, (rest - c - m).clamp(0.0, 1.0), k];
+        let ab = |c: f32, m: f32| {
+            let l = self.to_lab_rel(build(c, m));
+            [l.a, l.b]
+        };
+        let lo = (rest - 2.0).max(0.0);
+        let hi = rest.min(1.0);
+        let (mut c, mut m) = ((rest / 3.0).clamp(lo, hi), (rest / 3.0).clamp(lo, hi));
+        for _ in 0..30 {
+            let r = ab(c, m);
+            if r[0].abs() + r[1].abs() < 1e-4 {
+                break;
+            }
+            let h = 1e-3;
+            let rc = ab(c - h, m);
+            let rm = ab(c, m - h);
+            let j = [[(r[0] - rc[0]) / h, (r[0] - rm[0]) / h], [(r[1] - rc[1]) / h, (r[1] - rm[1]) / h]];
+            let det = j[0][0] * j[1][1] - j[0][1] * j[1][0];
+            if det.abs() < 1e-9 {
+                break;
+            }
+            let dc = (-r[0] * j[1][1] + r[1] * j[0][1]) / det;
+            let dm = (-r[1] * j[0][0] + r[0] * j[1][0]) / det;
+            c = (c + dc.clamp(-0.1, 0.1)).clamp(lo, hi);
+            m = (m + dm.clamp(-0.1, 0.1)).clamp(lo, hi);
+            // Yellow takes the rest, so keep it within 0..1 as well.
+            let y = rest - c - m;
+            if y > 1.0 {
+                c += (y - 1.0) / 2.0;
+                m += (y - 1.0) / 2.0;
+            } else if y < 0.0 {
+                c += y / 2.0;
+                m += y / 2.0;
+            }
+            c = c.clamp(lo, hi);
+            m = m.clamp(lo, hi);
+        }
+        build(c.clamp(lo, hi), m.clamp(lo, hi))
+    }
+
+    /// Effective dot area of ink `i` at nominal area `a`: the TR 001-style tone curve.
+    fn gain(&self, i: usize, a: f32) -> f32 {
+        let a = if a.is_finite() { a.clamp(0.0, 1.0) } else { 0.0 };
+        let g = self.params.tvi50[i];
+        (a + 4.0 * g * a * (1.0 - a) * (1.0 + self.skew[i] * (2.0 * a - 1.0))).clamp(0.0, 1.0)
     }
 
     /// CMYK (0..1) → absolute XYZ (D50).
     pub fn to_xyz(&self, cmyk: [f32; 4]) -> [f32; 3] {
-        let dg = self.params.dot_gain;
-        let c = Self::gain(cmyk[0], dg[0]);
-        let m = Self::gain(cmyk[1], dg[1]);
-        let y = Self::gain(cmyk[2], dg[2]);
-        let k = Self::gain(cmyk[3], dg[3]);
-        let mut out = [0.0f32; 3];
-        for i in 0..8 {
-            let w = (if i & 1 != 0 { c } else { 1.0 - c }) * (if i & 2 != 0 { m } else { 1.0 - m }) * (if i & 4 != 0 { y } else { 1.0 - y });
-            if w == 0.0 {
-                continue;
-            }
-            for (ch, o) in out.iter_mut().enumerate() {
-                *o += w * ((1.0 - k) * self.prim[i][ch] + k * self.prim_k[i][ch]);
-            }
-        }
-        out
+        let x = self.to_xyz_rel(cmyk);
+        [x[0] * self.paper_xyz[0] / D50[0], x[1] * self.paper_xyz[1] / D50[1], x[2] * self.paper_xyz[2] / D50[2]]
     }
 
     /// Media-relative XYZ (paper = D50 white).
     pub fn to_xyz_rel(&self, cmyk: [f32; 4]) -> [f32; 3] {
-        let x = self.to_xyz(cmyk);
-        [x[0] * D50[0] / self.paper_xyz[0], x[1] * D50[1] / self.paper_xyz[1], x[2] * D50[2] / self.paper_xyz[2]]
+        let e = [0, 1, 2, 3].map(|i| self.gain(i, cmyk[i]));
+        let mut out = [0.0f32; 3];
+        for (i, p) in self.prim.iter().enumerate() {
+            let mut w = 1.0;
+            for (bit, a) in e.iter().enumerate() {
+                w *= if i & (1 << bit) != 0 { *a } else { 1.0 - a };
+            }
+            if w == 0.0 {
+                continue;
+            }
+            for (o, v) in out.iter_mut().zip(p) {
+                *o += w * v;
+            }
+        }
+        out
     }
 
     pub fn to_lab_rel(&self, cmyk: [f32; 4]) -> Lab {
@@ -174,7 +240,9 @@ impl GenericCmyk {
     /// Display XYZ: media-relative (paper shows as white) or absolute (simulate paper colour).
     /// With `bpc` (media-relative only) the press black displays as black, undoing the
     /// compensation [`Self::gamut_map`] applies on the way in, so sRGB black separated to the
-    /// darkest rich black shows as black again.
+    /// black point shows as black again. Each XYZ channel is clamped at 0 on its own, so a build
+    /// darker than the black point in every channel shows as black, and one darker in only some
+    /// channels shows as a colored near-black.
     pub fn display_xyz(&self, cmyk: [f32; 4], absolute: bool, bpc: bool) -> [f32; 3] {
         if absolute {
             return self.to_xyz(cmyk);
@@ -192,7 +260,7 @@ impl GenericCmyk {
         xyz_to_srgb(self.display_xyz(cmyk, absolute, bpc))
     }
 
-    /// Lab of the darkest printable black (media-relative).
+    /// Lab of the black point (media-relative), see [`Self::black_point_build`].
     pub fn black_point(&self) -> Lab {
         xyz_to_lab(self.black_rel)
     }
@@ -283,12 +351,21 @@ impl GenericCmyk {
         rgb.map(|v| ((1.0 - v - k) / d).clamp(0.0, 1.0))
     }
 
-    fn black_for_grey(&self, grey: f32) -> f32 {
-        let bg = self.params.bg;
-        if grey <= bg.start {
-            return 0.0;
+    /// Black for `x` on the black curve (see [`BlackGeneration::curve`]).
+    fn black_for(&self, x: f32) -> f32 {
+        let curve = &self.params.bg.curve;
+        let mut prev = curve[0];
+        if x <= prev.0 {
+            return prev.1.clamp(0.0, 1.0);
         }
-        (((grey - bg.start) / (1.0 - bg.start)).clamp(0.0, 1.0).powf(bg.gamma) * bg.max_k).clamp(0.0, 1.0)
+        for &(kx, kk) in &curve[1..] {
+            if x <= kx {
+                let t = if kx > prev.0 { (x - prev.0) / (kx - prev.0) } else { 1.0 };
+                return (prev.1 + (kk - prev.1) * t).clamp(0.0, 1.0);
+            }
+            prev = (kx, kk);
+        }
+        prev.1.clamp(0.0, 1.0)
     }
 
     /// Separate a media-relative Lab (already gamut-mapped) into CMYK with GCR/UCR and the TAC limit.
@@ -297,13 +374,10 @@ impl GenericCmyk {
             return [0.0; 4];
         }
         let cmy0 = self.solve_cmy(target, 0.0, Self::initial_cmy(target, 0.0));
-        let grey = cmy0[0].min(cmy0[1]).min(cmy0[2]);
-        let mut k = self.black_for_grey(grey);
-        // If CMY alone can't get dark enough, black must carry the rest.
+        let gray = cmy0[0].min(cmy0[1]).min(cmy0[2]);
+        // When CMY alone can't get dark enough, black carries the rest.
         let l0 = self.to_lab_rel([cmy0[0], cmy0[1], cmy0[2], 0.0]).l;
-        if l0 > target.l + 1.0 {
-            k = k.max(((l0 - target.l) / l0.max(1.0)).clamp(0.0, 1.0));
-        }
+        let mut k = self.black_for(gray + self.params.bg.shortfall * (l0 - target.l).max(0.0));
         let mut cmy = if k > 0.0 { self.solve_cmy(target, k, Self::initial_cmy(target, k)) } else { cmy0 };
         // UCR: trade CMY for K until within the TAC limit.
         for _ in 0..6 {
diff --git a/crates/color/src/cms/tests.rs b/crates/color/src/cms/tests.rs
index ecb4c1c59..57709abe6 100644
--- a/crates/color/src/cms/tests.rs
+++ b/crates/color/src/cms/tests.rs
@@ -245,8 +245,8 @@ fn loads_system_cmyk_icc() {
     assert_eq!(c.cmyk_to_srgb([0.0; 4], false).map(|v| (v * 255.0).round() as u8), [255, 255, 255]);
 }
 
-/// With black-point compensation, sRGB black separates to the press's darkest black and that black
-/// displays as black again (hex 000000 -> C67 M67 Y67 K100 -> 000000, not a dark grey).
+/// With black-point compensation, sRGB black separates to the press's black point and that black
+/// displays as black again (hex 000000 -> C75 M68 Y67 K90 -> 000000, not a dark gray).
 #[test]
 fn generic_cmyk_black_round_trips_with_bpc() {
     let c = cms();
@@ -259,25 +259,104 @@ fn generic_cmyk_black_round_trips_with_bpc() {
     assert!(raw.iter().all(|v| *v > 0.05), "{raw:?}");
 }
 
-/// A color whose solve holds cyan at 0 separates to the same inks when its values change by a few
-/// float steps: hex ed1e79 with its red stepped one `f32` at a time over 4,001 values (about 0.00024
-/// in all) stays within 0.001 on every ink.
+/// Each ink's 40% and 50% tints gain like CGATS TR 001 (SWOP): the colorimetric tone value increase
+/// (Murray–Davies on X for cyan, Y for magenta and black, Z for yellow) is C 20.0, M 17.6, Y 16.8 and
+/// K 21.6 points at 50%, and C 20.0, M 17.3, Y 16.7 and K 21.9 points at 40%.
+#[test]
+fn generic_cmyk_tints_gain_like_tr001() {
+    let g = generic();
+    let tvi = |ink: usize, a: f32| {
+        let ch = [0, 1, 2, 1][ink];
+        let mut cmyk = [0.0f32; 4];
+        cmyk[ink] = a;
+        let tint = g.to_xyz_rel(cmyk)[ch];
+        cmyk[ink] = 1.0;
+        let solid = g.to_xyz_rel(cmyk)[ch];
+        let paper = g.to_xyz_rel([0.0; 4])[ch];
+        (paper - tint) / (paper - solid) - a
+    };
+    for (ink, (at50, at40)) in [(0.200, 0.200), (0.176, 0.173), (0.168, 0.167), (0.216, 0.219)].into_iter().enumerate() {
+        assert!((tvi(ink, 0.5) - at50).abs() < 0.002, "ink {ink} at 50%: {}", tvi(ink, 0.5));
+        assert!((tvi(ink, 0.4) - at40).abs() < 0.002, "ink {ink} at 40%: {}", tvi(ink, 0.4));
+    }
+}
+
+/// More of any ink never makes a Generic CMYK color lighter, in any XYZ channel: on a 10% grid of
+/// builds within the 300% ink limit, adding 10% of one ink keeps X, Y and Z or lowers them.
+#[test]
+fn generic_cmyk_more_ink_is_never_lighter() {
+    let g = generic();
+    let steps = (0..=10).map(|i| i as f32 / 10.0);
+    for c in steps.clone() {
+        for m in steps.clone() {
+            for y in steps.clone() {
+                for k in steps.clone() {
+                    let base = [c, m, y, k];
+                    if base.iter().sum::<f32>() > 3.0 - 0.1 + 1e-4 {
+                        continue;
+                    }
+                    let x0 = g.to_xyz_rel(base);
+                    for ink in 0..4 {
+                        if base[ink] >= 1.0 {
+                            continue;
+                        }
+                        let mut more = base;
+                        more[ink] += 0.1;
+                        let x1 = g.to_xyz_rel(more);
+                        assert!((0..3).all(|ch| x1[ch] <= x0[ch] + 1e-5), "{base:?} plus ink {ink}: {x0:?} to {x1:?}");
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// sRGB black separates to 90% black under neutral CMY that fills the 300% ink limit, light grays
+/// carry no black, and black rises steadily from the light end of the gray ramp to the dark end.
+#[test]
+fn generic_cmyk_black_generation_follows_the_black_curve() {
+    let c = cms();
+    let black = c.srgb_to_cmyk([0.0; 3], Intent::RelativeColorimetric);
+    assert!((black[3] - 0.9).abs() < 0.005, "{black:?}");
+    assert!((black.iter().sum::<f32>() - 3.0).abs() < 0.01, "{black:?}");
+    let lab = c.cmyk_to_lab(black);
+    assert!(lab.a.abs() < 0.05 && lab.b.abs() < 0.05, "neutral: {lab:?}");
+    let light = c.srgb_to_cmyk([0.7; 3], Intent::RelativeColorimetric);
+    assert_eq!(light[3], 0.0, "{light:?}");
+    let mut prev = 0.0;
+    for v in (0..=50).rev().map(|i| i as f32 / 50.0) {
+        let k = c.srgb_to_cmyk([v; 3], Intent::RelativeColorimetric)[3];
+        assert!(k >= prev - 1e-4, "gray {v}: K {k} after {prev}");
+        prev = k;
+    }
+}
+
+/// A color whose solve holds an ink at a bound separates to the same inks when its values change by
+/// a few float steps: hex f01482 (cyan held at 0) and hex ed1e79 (magenta held at 100%), each with
+/// its red stepped one `f32` at a time over 4,001 values (about 0.00024 in all), stay within 0.001
+/// on every ink.
 #[test]
 fn generic_cmyk_separates_nearby_colors_at_the_gamut_edge_alike() {
     let c = cms();
-    let pink = [237.0f32 / 255.0, 30.0 / 255.0, 121.0 / 255.0];
-    let (mut lo, mut hi) = ([f32::MAX; 4], [f32::MIN; 4]);
-    for step in -2000i32..=2000 {
-        let mut rgb = pink;
-        rgb[0] = f32::from_bits(pink[0].to_bits().wrapping_add_signed(step));
-        let ink = c.srgb_to_cmyk(rgb, Intent::RelativeColorimetric);
-        for i in 0..4 {
-            lo[i] = lo[i].min(ink[i]);
-            hi[i] = hi[i].max(ink[i]);
+    let spread = |pink: [f32; 3]| {
+        let (mut lo, mut hi) = ([f32::MAX; 4], [f32::MIN; 4]);
+        for step in -2000i32..=2000 {
+            let mut rgb = pink;
+            rgb[0] = f32::from_bits(pink[0].to_bits().wrapping_add_signed(step));
+            let ink = c.srgb_to_cmyk(rgb, Intent::RelativeColorimetric);
+            for i in 0..4 {
+                lo[i] = lo[i].min(ink[i]);
+                hi[i] = hi[i].max(ink[i]);
+            }
         }
-    }
+        (lo, hi)
+    };
+    let (lo, hi) = spread([240.0f32 / 255.0, 20.0 / 255.0, 130.0 / 255.0]);
     assert!((0..4).all(|i| hi[i] - lo[i] < 1e-3), "{lo:?} to {hi:?}");
     assert_eq!(lo[0], 0.0, "{lo:?}");
+    let (lo, hi) = spread([237.0f32 / 255.0, 30.0 / 255.0, 121.0 / 255.0]);
+    assert!((0..4).all(|i| hi[i] - lo[i] < 1e-3), "{lo:?} to {hi:?}");
+    assert_eq!(hi[1], 1.0, "{hi:?}");
 }
 
 /// A color whose solve holds cyan and magenta at 1 separates to the same inks when its values change
diff --git a/crates/doc/src/appearance.rs b/crates/doc/src/appearance.rs
index 09e8154c9..3ac145fd2 100644
--- a/crates/doc/src/appearance.rs
+++ b/crates/doc/src/appearance.rs
@@ -376,6 +376,11 @@ impl Appearance {
     pub fn has_placed_gradient(&self) -> bool {
         self.has_gradient(true)
     }
+    /// Does a fill or stroke carry a gradient that is drawn at a place in document space: a placed
+    /// one, or a freeform gradient with points of its own whose vector is fitted to the bounds?
+    pub fn has_positioned_gradient(&self) -> bool {
+        self.gradients().any(|g| g.is_placed() || g.has_freeform_points())
+    }
     /// Fix unplaced gradients to their fit on `bounds` (the object's geometric bounds; strokes fit
     /// the stroke-inflated box), so they can follow transforms that refitting wouldn't reproduce.
     pub fn pin_gradients(&mut self, bounds: vectorcraft_geom::Rect) {
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs
index 287a6b2aa..ebd27fd87 100644
--- a/crates/doc/src/document.rs
+++ b/crates/doc/src/document.rs
@@ -34,6 +34,7 @@ impl Document {
             graphic_styles,
             char_styles,
             para_styles,
+            composite_fonts,
             text_threads,
             symbols,
             graph_designs,
@@ -90,6 +91,7 @@ impl Document {
             && *graphic_styles == other.graphic_styles
             && *char_styles == other.char_styles
             && *para_styles == other.para_styles
+            && *composite_fonts == other.composite_fonts
             && *text_threads == other.text_threads
             && symbols.len() == other.symbols.len()
             && symbols.iter().zip(&other.symbols).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
@@ -213,6 +215,7 @@ impl Document {
             graphic_styles: default_graphic_styles().into(),
             char_styles: Default::default(),
             para_styles: Default::default(),
+            composite_fonts: Default::default(),
             text_threads: vec![],
             symbols: vec![],
             graph_designs: vec![],
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 8a866256e..5ab3b8bdf 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -121,6 +121,7 @@ pub use text::{
     RubySpan, ScriptMetrics, SingleWordJustify, TabAlign, TabStop, TextFlow, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, VerticalAlign,
     WrapShape,
 };
+pub use text::{CharClass, CompositeFont, CompositePart, CompositeParts};
 pub use trace::TraceView;
 pub use variables::{DataSet, DataValue, Variable, VariableKind, Variables};
 pub use vectorcraft_color as color;
@@ -195,6 +196,9 @@ pub struct Document {
     /// Paragraph styles (besides the built-in [Normal Paragraph Style]).
     #[serde(default, skip_serializing_if = "skip::is_empty_vec")]
     pub para_styles: Shared<Vec<TextStyleDef>>,
+    /// Type › Composite Fonts…: the composite fonts defined in the document, by name.
+    #[serde(default, skip_serializing_if = "skip::is_empty_vec")]
+    pub composite_fonts: Shared<Vec<CompositeFont>>,
     /// Threaded text: area-type frames one story flows through, in order.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub text_threads: Vec<Vec<NodeId>>,
diff --git a/crates/doc/src/mem.rs b/crates/doc/src/mem.rs
index a93830822..e431fc9d1 100644
--- a/crates/doc/src/mem.rs
+++ b/crates/doc/src/mem.rs
@@ -103,6 +103,11 @@ impl Document {
         let styles = |s: &Vec<TextStyleDef>| vec_bytes(s) + s.iter().map(|s| s.name.capacity() + map_bytes(&s.attrs)).sum::<usize>();
         n += shared(&self.char_styles, &newer.char_styles, styles);
         n += shared(&self.para_styles, &newer.para_styles, styles);
+        n += shared(&self.composite_fonts, &newer.composite_fonts, |c| {
+            let part = |p: &crate::CompositePart| p.font.capacity() + p.style.capacity();
+            vec_bytes(c)
+                + c.iter().map(|f| f.name.capacity() + crate::CharClass::ALL.into_iter().map(|k| part(f.parts.get(k))).sum::<usize>()).sum::<usize>()
+        });
         n += shared(&self.saved_selections, &newer.saved_selections, |s| {
             vec_bytes(s) + s.iter().map(|s: &SavedSelection| s.name.capacity() + vec_bytes(&s.objects)).sum::<usize>()
         });
diff --git a/crates/doc/src/text.rs b/crates/doc/src/text.rs
index a2f21e856..11be20ee2 100644
--- a/crates/doc/src/text.rs
+++ b/crates/doc/src/text.rs
@@ -8,6 +8,7 @@ use crate::appearance::{Appearance, AppearanceItem, Dash, FillLayer, LineCap, Li
 
 mod area;
 mod char_style;
+mod composite;
 mod object;
 mod para_style;
 mod runs;
@@ -17,6 +18,10 @@ mod wrap;
 pub use area::{AreaFit, AreaOptions, PathAlign, PathEffect, TextFlow, TextWrap, VerticalAlign, WrapShape};
 use char_style::yes;
 pub use char_style::{CharAlign, CharPosition, CharStyle, Digits, FontHeightReference, GlyphChoice, ScriptMetrics};
+pub use composite::{
+    COMPOSITE_BASELINE, COMPOSITE_FONTS_MAX, COMPOSITE_NAME_MAX, COMPOSITE_SCALE, COMPOSITE_SIZE, CharClass, CompositeFont, CompositePart,
+    CompositeParts,
+};
 pub use para_style::{
     Burasagari, Composer, FirstBaseline, HyphenationOptions, JustificationOptions, Justify, Kashida, Kinsoku, LeadingModel, Mojikumi, ParaDirection,
     ParaStyle, SingleWordJustify,
diff --git a/crates/doc/src/text/area.rs b/crates/doc/src/text/area.rs
index 515f52627..7bb742f48 100644
--- a/crates/doc/src/text/area.rs
+++ b/crates/doc/src/text/area.rs
@@ -101,15 +101,24 @@ impl PathEffect {
     }
 }
 
-/// Type on a Path Options › Align to Path: which height of the type runs along the path.
+/// Type on a Path Options › Align to Path: which height of the type runs along the path. Each
+/// character is measured by its own font, size and vertical scale, and in vertical type by its own
+/// size and horizontal scale. An inline graphic moves as a character of its run would, by its
+/// run's vertical scale in vertical type too. These distances are VectorCraft's own values.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum PathAlign {
-    /// The font's top edge: the type hangs below the path.
+    /// The top of the font's em box: the type hangs below the path. The em box is the font's
+    /// ideographic em box (from its `BASE` table, its typographic or `hhea` box, or its
+    /// ideographs), else an em box centered on the cap height, else a box whose top is 0.88 em
+    /// above the baseline. In vertical type the characters move half an em.
     Ascender,
-    /// The font's bottom edge: the type stands above the path.
+    /// The bottom of the font's bounding box, else the font's descent: the type stands above the
+    /// path. In vertical type the characters move half an em the other way.
     Descender,
-    /// Halfway between the ascender and the descender.
+    /// A line at half the height of the top of the font's H above the baseline, else at half its
+    /// cap height, else at the middle of its em box. In vertical type the characters stay on the
+    /// path.
     Center,
     /// The baseline (the default).
     #[default]
diff --git a/crates/doc/src/text/composite.rs b/crates/doc/src/text/composite.rs
new file mode 100644
index 000000000..e95428c2f
--- /dev/null
+++ b/crates/doc/src/text/composite.rs
@@ -0,0 +1,344 @@
+//! Type › Composite Fonts…: a font made of other fonts, one for each class of character (the
+//! Kanji font is the base; kana, punctuation, symbols, Roman letters and numerals each take a font
+//! of their own, sized, raised and scaled against it). Type set in a composite font names it as its
+//! family; the layout sets each character in its class's font.
+//!
+//! Behavior reference (public documentation):
+//! <https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347>.
+//! Which characters fall in which class, the ranges and the defaults are VectorCraft's own.
+
+use serde::{Deserialize, Serialize};
+
+/// A class of characters a composite font gives a font of its own.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum CharClass {
+    /// The base font: ideographs, full-width letters and digits, and every character no other
+    /// class takes.
+    Kanji,
+    /// Hiragana and katakana, full-width and half-width.
+    Kana,
+    /// East Asian and full-width punctuation, and typographic quotes and dashes.
+    Punctuation,
+    /// Arrows, math, shapes, enclosed and other symbols.
+    Symbols,
+    /// Half-width Roman letters, their punctuation and spaces.
+    Roman,
+    /// The half-width digits 0 to 9.
+    Numerals,
+}
+
+impl CharClass {
+    /// Every class, in the order the Composite Fonts dialog lists them.
+    pub const ALL: [CharClass; 6] = [Self::Kanji, Self::Kana, Self::Punctuation, Self::Symbols, Self::Roman, Self::Numerals];
+
+    /// The name commands and files use (`kanji`, `kana`, …).
+    pub fn key(self) -> &'static str {
+        match self {
+            Self::Kanji => "kanji",
+            Self::Kana => "kana",
+            Self::Punctuation => "punctuation",
+            Self::Symbols => "symbols",
+            Self::Roman => "roman",
+            Self::Numerals => "numerals",
+        }
+    }
+
+    /// The class named `key` ([`Self::key`], any case).
+    pub fn named(key: &str) -> Option<Self> {
+        Self::ALL.into_iter().find(|c| c.key().eq_ignore_ascii_case(key))
+    }
+
+    /// Whether the class's characters can be scaled across and up (Kana, Roman and Numerals).
+    pub fn scales(self) -> bool {
+        matches!(self, Self::Kana | Self::Roman | Self::Numerals)
+    }
+
+    /// The class of character `c`.
+    pub fn of(c: char) -> Self {
+        let u = c as u32;
+        match u {
+            0x30..=0x39 => Self::Numerals,
+            // Basic Latin, Latin-1, Latin Extended, IPA, spacing and combining marks, and Latin
+            // Extended Additional.
+            0x00..=0x036F | 0x1E00..=0x1EFF => Self::Roman,
+            // The other Latin blocks: combining marks extended, phonetic extensions and their
+            // supplement, combining marks supplement, Latin Extended-C, -D, -E, -F and -G, and the
+            // Latin ligatures of the alphabetic presentation forms.
+            0x1AB0..=0x1AFF
+            | 0x1D00..=0x1DFF
+            | 0x2C60..=0x2C7F
+            | 0xA720..=0xA7FF
+            | 0xAB30..=0xAB6F
+            | 0xFB00..=0xFB06
+            | 0x10780..=0x107BF
+            | 0x1DF00..=0x1DFFF => Self::Roman,
+            // ・ and ゠ sit in the katakana block but are punctuation.
+            0x30A0 | 0x30FB => Self::Punctuation,
+            // Hiragana, katakana, katakana phonetic extensions, half-width katakana (with its
+            // prolonged sound and voicing marks) and the kana supplements.
+            0x3041..=0x309F | 0x30A1..=0x30FF | 0x31F0..=0x31FF | 0xFF66..=0xFF9F | 0x1B000..=0x1B16F => Self::Kana,
+            // CJK symbols: 〄 〒 〓 〠 〶; ideographic space, 々 〆 〇 and the like stay with the base.
+            0x3004 | 0x3012 | 0x3013 | 0x3020 | 0x3036 => Self::Symbols,
+            0x3000 | 0x3005..=0x3007 | 0x3021..=0x302F | 0x3031..=0x3035 | 0x3038..=0x303C => Self::Kanji,
+            0x3001..=0x303F => Self::Punctuation,
+            // ※ is a symbol; the rest of General Punctuation (dashes, quotes, leaders) punctuation.
+            0x203B => Self::Symbols,
+            0x2010..=0x205E => Self::Punctuation,
+            // Letterlike symbols, number forms, arrows, math, technical, enclosed alphanumerics, box
+            // drawing, shapes, miscellaneous symbols and dingbats; enclosed CJK and CJK
+            // compatibility; full-width signs.
+            0x2100..=0x2BFF | 0x3200..=0x33FF | 0xFFE0..=0xFFEE => Self::Symbols,
+            // Full-width forms of the ASCII signs.
+            0xFF03..=0xFF06 | 0xFF0A | 0xFF0B | 0xFF1C..=0xFF1E | 0xFF20 | 0xFF3C | 0xFF3E | 0xFF5C | 0xFF5E => Self::Symbols,
+            // Full-width forms of the other ASCII punctuation, and the half-width CJK punctuation.
+            0xFF01..=0xFF0F | 0xFF1A..=0xFF1F | 0xFF3B..=0xFF40 | 0xFF5B..=0xFF65 => Self::Punctuation,
+            _ => Self::Kanji,
+        }
+    }
+}
+
+/// The font a composite font sets one class of characters in, and how.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompositePart {
+    /// The font family and style.
+    pub font: String,
+    #[serde(default = "regular")]
+    pub style: String,
+    /// The size, in percent of the type's size.
+    #[serde(default = "hundred")]
+    pub size: f64,
+    /// How far the characters are raised from the baseline, in percent of the type's size
+    /// (negative lowers them).
+    #[serde(default)]
+    pub baseline: f64,
+    /// Horizontal and vertical scale, in percent (Kana, Roman and Numerals only).
+    #[serde(default = "hundred")]
+    pub h_scale: f64,
+    #[serde(default = "hundred")]
+    pub v_scale: f64,
+    /// Kana only: the characters are scaled from the center of the em box rather than from the
+    /// baseline.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub scale_at_center: bool,
+}
+
+fn hundred() -> f64 {
+    100.0
+}
+
+fn regular() -> String {
+    "Regular".into()
+}
+
+impl CompositePart {
+    /// The part a new composite font gives every class: `font` in `style` at full size, on the
+    /// baseline, unscaled.
+    pub fn new(font: impl Into<String>, style: impl Into<String>) -> Self {
+        Self { font: font.into(), style: style.into(), size: 100.0, baseline: 0.0, h_scale: 100.0, v_scale: 100.0, scale_at_center: false }
+    }
+}
+
+/// The six parts of a composite font, one per [`CharClass`].
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompositeParts {
+    pub kanji: CompositePart,
+    pub kana: CompositePart,
+    pub punctuation: CompositePart,
+    pub symbols: CompositePart,
+    pub roman: CompositePart,
+    pub numerals: CompositePart,
+}
+
+impl CompositeParts {
+    /// Every class set in `part`.
+    pub fn all(part: CompositePart) -> Self {
+        Self { kanji: part.clone(), kana: part.clone(), punctuation: part.clone(), symbols: part.clone(), roman: part.clone(), numerals: part }
+    }
+
+    pub fn get(&self, class: CharClass) -> &CompositePart {
+        match class {
+            CharClass::Kanji => &self.kanji,
+            CharClass::Kana => &self.kana,
+            CharClass::Punctuation => &self.punctuation,
+            CharClass::Symbols => &self.symbols,
+            CharClass::Roman => &self.roman,
+            CharClass::Numerals => &self.numerals,
+        }
+    }
+
+    pub fn get_mut(&mut self, class: CharClass) -> &mut CompositePart {
+        match class {
+            CharClass::Kanji => &mut self.kanji,
+            CharClass::Kana => &mut self.kana,
+            CharClass::Punctuation => &mut self.punctuation,
+            CharClass::Symbols => &mut self.symbols,
+            CharClass::Roman => &mut self.roman,
+            CharClass::Numerals => &mut self.numerals,
+        }
+    }
+}
+
+/// A composite font (Type › Composite Fonts…), saved with the document. Its name is the family
+/// that type set in it names.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompositeFont {
+    pub name: String,
+    pub parts: CompositeParts,
+}
+
+/// The size a part can take, in percent of the type's size.
+pub const COMPOSITE_SIZE: std::ops::RangeInclusive<f64> = 10.0..=400.0;
+/// How far a part can raise or lower its characters, in percent of the type's size.
+pub const COMPOSITE_BASELINE: std::ops::RangeInclusive<f64> = -100.0..=100.0;
+/// The horizontal and vertical scale a part can take, in percent.
+pub const COMPOSITE_SCALE: std::ops::RangeInclusive<f64> = 10.0..=400.0;
+/// The longest composite font name, in characters.
+pub const COMPOSITE_NAME_MAX: usize = 255;
+/// The most composite fonts a document or a file keeps.
+pub const COMPOSITE_FONTS_MAX: usize = 256;
+
+impl CompositeFont {
+    /// A composite font named `name` setting every class in `font` and `style`.
+    pub fn new(name: impl Into<String>, font: impl Into<String>, style: impl Into<String>) -> Self {
+        Self { name: name.into(), parts: CompositeParts::all(CompositePart::new(font, style)) }
+    }
+
+    /// Do `a` and `b` name the same composite font: equal in any case?
+    pub fn same_name(a: &str, b: &str) -> bool {
+        a == b || a.to_lowercase() == b.to_lowercase()
+    }
+
+    /// The font of `fonts` (a document's composite fonts) named `name`, in any case.
+    pub fn named<'a>(fonts: &'a [CompositeFont], name: &str) -> Option<&'a CompositeFont> {
+        fonts.iter().find(|f| Self::same_name(&f.name, name))
+    }
+
+    /// `name` trimmed, when it can name a composite font: not empty, at most
+    /// [`COMPOSITE_NAME_MAX`] characters and without control characters.
+    pub fn clean_name(name: &str) -> Option<String> {
+        let name = name.trim();
+        let ok = !name.is_empty() && name.chars().count() <= COMPOSITE_NAME_MAX && !name.chars().any(char::is_control);
+        ok.then(|| name.to_string())
+    }
+
+    /// Why this composite font can't be used, if it can't: a name [`Self::clean_name`] refuses, a
+    /// part without a font, a value out of its range, or a scale or Scale at Center on a class
+    /// that has none.
+    pub fn check(&self) -> Result<(), String> {
+        if Self::clean_name(&self.name).as_deref() != Some(self.name.as_str()) {
+            return Err(format!("`{}` can't name a composite font", self.name));
+        }
+        for class in CharClass::ALL {
+            let p = self.parts.get(class);
+            let k = class.key();
+            if p.font.trim().is_empty() {
+                return Err(format!("{k}: give a font"));
+            }
+            let within = |v: f64, r: &std::ops::RangeInclusive<f64>| v.is_finite() && r.contains(&v);
+            if !within(p.size, &COMPOSITE_SIZE) {
+                return Err(format!("{k}: size must be {} to {}%", COMPOSITE_SIZE.start(), COMPOSITE_SIZE.end()));
+            }
+            if !within(p.baseline, &COMPOSITE_BASELINE) {
+                return Err(format!("{k}: baseline must be {} to {}%", COMPOSITE_BASELINE.start(), COMPOSITE_BASELINE.end()));
+            }
+            for v in [p.h_scale, p.v_scale] {
+                if !within(v, &COMPOSITE_SCALE) {
+                    return Err(format!("{k}: scale must be {} to {}%", COMPOSITE_SCALE.start(), COMPOSITE_SCALE.end()));
+                }
+                if v != 100.0 && !class.scales() {
+                    return Err(format!("{k}: only kana, roman and numerals can be scaled"));
+                }
+            }
+            if p.scale_at_center && class != CharClass::Kana {
+                return Err(format!("{k}: only kana can be scaled at the center"));
+            }
+        }
+        Ok(())
+    }
+
+    /// `fonts` without the ones that can't be used: those [`Self::check`] refuses, a later font
+    /// sharing an earlier one's name (in any case), a part set in one of the fonts, and those past
+    /// [`COMPOSITE_FONTS_MAX`]. `None` when every font can be used.
+    pub fn usable(fonts: &[CompositeFont]) -> Option<Vec<CompositeFont>> {
+        let mut names = std::collections::HashSet::new();
+        let mut kept: Vec<CompositeFont> =
+            fonts.iter().filter(|f| f.check().is_ok() && names.insert(f.name.to_lowercase())).take(COMPOSITE_FONTS_MAX).cloned().collect();
+        kept.retain(|f| CharClass::ALL.iter().all(|&c| !names.contains(&f.parts.get(c).font.to_lowercase())));
+        (kept.len() != fonts.len()).then_some(kept)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Each class takes its characters: digits and Latin letters are half-width numerals and
+    /// Roman, kana both widths, and the punctuation, symbols and full-width forms their own.
+    #[test]
+    fn characters_fall_in_their_classes() {
+        for (s, class) in [
+            ("漢字国一龍〇々", CharClass::Kanji),
+            ("ＡＺａ０９　", CharClass::Kanji),
+            ("あをアンーｱﾝｰ", CharClass::Kana),
+            ("、。「」『』【】〜・！？（）：", CharClass::Punctuation),
+            ("“”‘’—…", CharClass::Punctuation),
+            ("※→★○〒＋＝＄％①㈱", CharClass::Symbols),
+            ("AZaz é!? ()", CharClass::Roman),
+            // Latin Extended-C, -D and -E, phonetic extensions and a ligature.
+            ("\u{2C60}\u{A7A0}\u{AB30}\u{1D00}\u{FB01}", CharClass::Roman),
+            ("0123456789", CharClass::Numerals),
+        ] {
+            for c in s.chars() {
+                assert_eq!(CharClass::of(c), class, "{c:?} (U+{:04X})", c as u32);
+            }
+        }
+    }
+
+    /// A composite font is read and written by its fields' names, and a part's omitted values
+    /// take the defaults.
+    #[test]
+    fn composite_fonts_read_back_with_defaults() {
+        let mut f = CompositeFont::new("Mixed", "Source Sans 3", "Regular");
+        f.parts.kana.v_scale = 90.0;
+        f.parts.kana.scale_at_center = true;
+        f.parts.roman.baseline = -5.0;
+        let json = serde_json::to_value(&f).unwrap();
+        assert_eq!(json["parts"]["kana"]["vScale"], 90.0);
+        assert_eq!(json["parts"]["kana"]["scaleAtCenter"], true);
+        assert!(json["parts"]["roman"].get("scaleAtCenter").is_none());
+        assert_eq!(serde_json::from_value::<CompositeFont>(json).unwrap(), f);
+        let part: CompositePart = serde_json::from_value(serde_json::json!({"font": "Inter"})).unwrap();
+        assert_eq!(part, CompositePart::new("Inter", "Regular"));
+    }
+
+    /// Names are trimmed; values out of their ranges, and scales on classes that don't scale, are
+    /// refused.
+    #[test]
+    fn composite_fonts_check_their_values() {
+        assert_eq!(CompositeFont::clean_name("  Mixed  ").as_deref(), Some("Mixed"));
+        for bad in ["", "   ", "a\tb", &"x".repeat(COMPOSITE_NAME_MAX + 1)] {
+            assert_eq!(CompositeFont::clean_name(bad), None, "{bad:?}");
+        }
+        let ok = CompositeFont::new("Mixed", "Inter", "Regular");
+        assert_eq!(ok.check(), Ok(()));
+        let with = |f: fn(&mut CompositeParts)| {
+            let mut c = ok.clone();
+            f(&mut c.parts);
+            c.check()
+        };
+        assert!(with(|p| p.roman.size = 9.0).is_err());
+        assert!(with(|p| p.roman.size = f64::NAN).is_err());
+        assert!(with(|p| p.kana.baseline = 101.0).is_err());
+        assert!(with(|p| p.kana.h_scale = 401.0).is_err());
+        assert!(with(|p| p.kanji.v_scale = 90.0).is_err());
+        assert!(with(|p| p.symbols.h_scale = 90.0).is_err());
+        assert!(with(|p| p.roman.scale_at_center = true).is_err());
+        assert!(with(|p| p.numerals.font = " ".into()).is_err());
+        assert_eq!(with(|p| p.kana.scale_at_center = true), Ok(()));
+        assert_eq!(with(|p| p.numerals.h_scale = 50.0), Ok(()));
+        let mut spaced = ok.clone();
+        spaced.name = " Mixed".into();
+        assert!(spaced.check().is_err());
+    }
+}
diff --git a/crates/effects/src/geometry.rs b/crates/effects/src/geometry.rs
index 715143e1a..57a10f66e 100644
--- a/crates/effects/src/geometry.rs
+++ b/crates/effects/src/geometry.rs
@@ -236,10 +236,11 @@ impl Carry {
         self.0.is_empty()
     }
 
-    /// Does it move any of the gradients of `ap`? Callers check first, so an appearance shared
-    /// with other objects is not copied for nothing.
+    /// Does it move any of the gradients of `ap` (those drawn at a place in document space, a
+    /// freeform gradient's own points included)? Callers check first, so an appearance shared with
+    /// other objects is not copied for nothing.
     pub fn moves(&self, ap: &Appearance) -> bool {
-        !self.0.is_empty() && ap.has_placed_gradient()
+        !self.0.is_empty() && ap.has_positioned_gradient()
     }
 
     /// Move the placed gradients of `ap` along, through each step in turn.
diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rs
index e4ca42a4e..7bba3e8dd 100644
--- a/crates/effects/src/lib.rs
+++ b/crates/effects/src/lib.rs
@@ -86,7 +86,7 @@ pub use reshape::{
 pub use revolve::{REVOLVE, has_revolve, revolve_art, revolve_options, validate_revolve};
 pub use solids::{
     EXTRUDE, INFLATE, ROTATE, ROTATION_PRESETS, SOLIDS, SolidMesh, THREE_D_TYPES, extrude_options, has_solid, inflate_options, is_three_d, solid_art,
-    three_d_meshes, three_d_params_as, validate_solid, validate_three_d, view_options,
+    three_d_meshes, three_d_meshes_of, three_d_params_as, validate_solid, validate_three_d, view_options,
 };
 pub use stylize::{ScribbleSetting, scribble_setting_id, scribble_settings};
 pub use svg_filter::SVG_FILTER;
diff --git a/crates/effects/src/reshape.rs b/crates/effects/src/reshape.rs
index 4ea3e4610..85f2849d9 100644
--- a/crates/effects/src/reshape.rs
+++ b/crates/effects/src/reshape.rs
@@ -670,8 +670,7 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], budget: Budget, apart: b
         if follows {
             group_marks(art, &mut vec![], &HashSet::new(), &mut groups);
         }
-        // Whether a path kept its shape (past the budget), and the ids of those that did.
-        let mut kept = false;
+        // The ids of the paths that kept their shape (past the budget).
         let mut kept_ids = HashSet::new();
         let transform = (e.id == "distort.transform").then(|| {
             let (m, copies) = crate::distort::transform_map(bounds, &params, seed);
@@ -697,7 +696,6 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], budget: Budget, apart: b
                     let (made, moved) = transform_leaf(leaf, &path, map, copies, options, room);
                     used = used.minus(before).plus(made);
                     if !moved {
-                        kept = true;
                         kept_ids.insert(leaf.id);
                     }
                     return;
@@ -709,12 +707,11 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], budget: Budget, apart: b
                 }
             }
             let Some(out) = apply_one(&e.id, &params, &path, bounds, &GeomContext { seed, ..GeomContext::of(leaf) }, room) else {
-                kept = true;
                 kept_ids.insert(leaf.id);
                 return;
             };
             used = used.minus(before).plus(Budget::of(&out));
-            if follows && !boxes && leaf.appearance.has_placed_gradient() {
+            if follows && !boxes && leaf.appearance.has_positioned_gradient() {
                 crate::Carry::of(&e.id, &params, bounds, None, None, seed).apply(&mut leaf.appearance);
             }
             set_geometry(leaf, out, rule);
@@ -732,13 +729,13 @@ fn reshape_leaves_apart(art: &mut Node, fx: &[&Effect], budget: Budget, apart: b
         }
         // What paints the art as a whole, and the own fills and strokes of the groups inside it,
         // follow their bounds under Free Distort (they stay when no path changed them). Each stays
-        // when a path under it kept its shape (past the budget).
+        // when a path under it that its bounds measure kept its shape (past the budget).
+        let mut after = vec![];
+        let held = (!groups.is_empty() || !kept_ids.is_empty()) && group_marks(art, &mut vec![], &kept_ids, &mut after).1;
         if !groups.is_empty() {
-            let mut after = vec![];
-            group_marks(art, &mut vec![], &kept_ids, &mut after);
             carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, &params, bounds, from, to, seed));
         }
-        if follows && !kept {
+        if follows && !held {
             whole.push(crate::Carry::of(&e.id, &params, bounds, Some(bounds), art.geometric_bounds(), seed));
         }
     }
@@ -1020,7 +1017,7 @@ fn rebase_type_outlines(n: &mut Node, before: &mut std::vec::IntoIter<Option<Rec
         && from != to
     {
         for_each_leaf(n, &mut |leaf| {
-            if leaf.appearance.has_placed_gradient() {
+            if leaf.appearance.has_positioned_gradient() {
                 follow_boxes(&mut leaf.appearance, from, to);
             }
         });
@@ -1049,11 +1046,11 @@ fn is_member_group(n: &Node) -> bool {
 
 /// A group below the art that [`is_member_group`] takes and whose own fills or strokes hold a
 /// placed gradient: the child indices that lead to it from the art, its geometric bounds, and
-/// whether a path below it kept its shape.
+/// whether a path below it that its bounds measure kept its shape.
 type GroupMark = (Vec<usize>, Option<Rect>, bool);
 
 /// The geometric bounds of `n` (as [`Node::geometric_bounds`] gives them) and whether a path or
-/// compound path below it is in `kept`, measured in one walk. Each group below `n` that
+/// compound path below it that those bounds measure is in `kept`, measured in one walk. Each group below `n` that
 /// [`GroupMark`] describes goes into `out`, reached from `n` through `at`.
 fn group_marks(n: &Node, at: &mut Vec<usize>, kept: &HashSet<NodeId>, out: &mut Vec<GroupMark>) -> (Option<Rect>, bool) {
     match &n.kind {
@@ -1065,14 +1062,15 @@ fn group_marks(n: &Node, at: &mut Vec<usize>, kept: &HashSet<NodeId>, out: &mut
             for (i, c) in children.iter().enumerate() {
                 at.push(i);
                 let (b, h) = group_marks(c, at, kept, out);
-                if is_member_group(c) && c.appearance.has_placed_gradient() {
+                if is_member_group(c) && c.appearance.has_positioned_gradient() {
                     out.push((at.clone(), b, h));
                 }
                 at.pop();
-                held |= h;
+                // Only members measured in the bounds hold the group's gradients in place.
                 let counts = if *clip { i == 0 } else { i >= skip && (c.visible || !layer) };
                 if counts {
                     bounds = vectorcraft_geom::union_opt(bounds, b);
+                    held |= h;
                 }
             }
             (bounds, held)
@@ -1126,7 +1124,7 @@ fn rebase_leaves(n: &mut Node, before: &mut std::vec::IntoIter<Option<Rect>>) {
         if let Some(Some(from)) = before.next()
             && let Some(to) = n.geometric_bounds()
             && from != to
-            && n.appearance.has_placed_gradient()
+            && n.appearance.has_positioned_gradient()
         {
             follow_boxes(&mut n.appearance, from, to);
         }
@@ -1224,7 +1222,7 @@ fn copy_placed(n: &mut Node, m: Affine, copies: usize, room: &mut usize) {
                 _ => {}
             }
             // The placed gradients of its own fills and strokes move with it, as a path's do.
-            if xf != Affine::IDENTITY && one.appearance.has_placed_gradient() {
+            if xf != Affine::IDENTITY && one.appearance.has_positioned_gradient() {
                 one.appearance.transform_gradients(xf);
             }
             one
diff --git a/crates/effects/src/revolve.rs b/crates/effects/src/revolve.rs
index ba4b0e657..946c6532b 100644
--- a/crates/effects/src/revolve.rs
+++ b/crates/effects/src/revolve.rs
@@ -228,8 +228,9 @@ pub(crate) fn expand_revolve_art(n: &Node) -> Option<Node> {
 
 /// The surfaces [`revolve_art`] draws, as meshes ([`crate::three_d_meshes`]): with the effect on
 /// the object, one in its top visible fill (else its stroke); with it on fills and strokes, one for
-/// each of them.
-pub(crate) fn revolve_meshes(n: &Node) -> Result<Vec<crate::SolidMesh>, String> {
+/// each of them. Each mesh adds its triangles to `total` as it is built, and the first that takes
+/// `total` past `limit` stops with an error before the next is built.
+pub(crate) fn revolve_meshes(n: &Node, total: &mut usize, limit: usize) -> Result<Vec<crate::SolidMesh>, String> {
     let path = profile(n).ok_or("Revolve currently requires a path or compound path")?;
     let ctx = GeomContext::of(n);
     let mesh = |path: &PathData, fx: &Effect, item: &AppearanceItem| -> Result<crate::SolidMesh, String> {
@@ -250,7 +251,9 @@ pub(crate) fn revolve_meshes(n: &Node) -> Result<Vec<crate::SolidMesh>, String>
             .find(|i| matches!(i, AppearanceItem::Fill(_)) && crate::paints(i))
             .or_else(|| n.appearance.items.iter().rev().find(|i| crate::paints(i)))
             .ok_or("the revolved object has no fill or stroke")?;
-        return Ok(vec![mesh(&path, fx, item)?]);
+        let mut out = vec![];
+        crate::solids::keep_mesh(&mut out, total, mesh(&path, fx, item)?, limit)?;
+        return Ok(out);
     }
     let path = geometry(&path, &n.appearance.effects, &ctx);
     let mut out = vec![];
@@ -259,7 +262,7 @@ pub(crate) fn revolve_meshes(n: &Node) -> Result<Vec<crate::SolidMesh>, String>
             && let Some(fx) = item.effects().get(index)
         {
             let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(item));
-            out.push(mesh(&p, fx, item)?);
+            crate::solids::keep_mesh(&mut out, total, mesh(&p, fx, item)?, limit)?;
         }
     }
     Ok(out)
diff --git a/crates/effects/src/solids.rs b/crates/effects/src/solids.rs
index 09a2fc8ec..6f8eac9be 100644
--- a/crates/effects/src/solids.rs
+++ b/crates/effects/src/solids.rs
@@ -566,14 +566,15 @@ pub(crate) fn keep_mesh(out: &mut Vec<SolidMesh>, total: &mut usize, mesh: Solid
 
 /// The solids effect `fx` builds from `shapes`, as [`art_for`] draws them, as meshes: Rotate turns
 /// every fill and stroke; Extrude & Bevel and Inflate build one from each shape's top fill and one
-/// from the outline of each stroke. A stroke whose solid is past the limits is left out.
-fn meshes_for(fx: &Effect, shapes: &[Profile], total: &mut usize) -> Result<Vec<SolidMesh>, String> {
+/// from the outline of each stroke. A stroke whose solid is past the limits is left out. Each mesh
+/// is counted against `limit` ([`keep_mesh`]) before the next is built.
+fn meshes_for(fx: &Effect, shapes: &[Profile], total: &mut usize, limit: usize) -> Result<Vec<SolidMesh>, String> {
     let label = crate::effect_info(&fx.id).map_or("This effect", |e| e.label.trim_end_matches('…'));
     let b = union_bounds(shapes).ok_or_else(|| format!("{label} requires a shape with at least two anchors"))?;
     let p = crate::merged_params(&fx.id, &fx.params);
     let view = view_options(&p);
     let mut out = vec![];
-    let mut keep = |out: &mut Vec<SolidMesh>, mesh: Mesh, color: [f32; 4]| keep_mesh(out, total, SolidMesh { mesh, color }, MAX_MESH_TRIANGLES);
+    let mut keep = |out: &mut Vec<SolidMesh>, mesh: Mesh, color: [f32; 4]| keep_mesh(out, total, SolidMesh { mesh, color }, limit);
     if fx.id == ROTATE {
         for s in shapes {
             for item in &s.items {
@@ -585,8 +586,8 @@ fn meshes_for(fx: &Effect, shapes: &[Profile], total: &mut usize) -> Result<Vec<
         return Ok(out);
     }
     let (parts, bounds) = solid_parts(shapes, b);
-    // Inflate lays out every puff at once (they share one eye); each mesh, and each Extrude &
-    // Bevel solid, is built as it is reached.
+    // Inflate lays out every puff at once (they share one eye); each Inflate and Extrude & Bevel
+    // solid and its mesh are built as the loop reaches them.
     let mut inflated = (fx.id == INFLATE).then(|| {
         let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, _, area, rule)| (area, *rule)).collect();
         vectorcraft_three_d::inflate_meshes(&shapes, bounds, inflate_options(&p), view)
@@ -614,16 +615,33 @@ fn meshes_for(fx: &Effect, shapes: &[Profile], total: &mut usize) -> Result<Vec<
 /// colors they are painted ([`SolidMesh`]), faces turned away from the viewer included; meshes
 /// with no triangles are left out. On a group or layer, the effect's solids of its members
 /// ([`members`]). The object's opacity multiplies every color's. An error when `n` carries no
-/// such effect, its solids can't be built, or none has a triangle.
+/// such effect, its solids can't be built, none has a triangle, or together they have more than
+/// [`MAX_MESH_TRIANGLES`].
 pub fn three_d_meshes(n: &Node) -> Result<Vec<SolidMesh>, String> {
-    // Triangles of every solid together, against [`MAX_MESH_TRIANGLES`].
+    meshes_within(n, &mut 0, MAX_MESH_TRIANGLES)
+}
+
+/// The meshes of every object in `nodes` ([`three_d_meshes`]), in order, as one 3D asset exports
+/// them: the objects share one budget of [`MAX_MESH_TRIANGLES`].
+pub fn three_d_meshes_of<'a>(nodes: impl IntoIterator<Item = &'a Node>) -> Result<Vec<SolidMesh>, String> {
+    meshes_of_within(nodes, MAX_MESH_TRIANGLES)
+}
+
+/// [`three_d_meshes_of`] with a budget of `limit` triangles.
+fn meshes_of_within<'a>(nodes: impl IntoIterator<Item = &'a Node>, limit: usize) -> Result<Vec<SolidMesh>, String> {
     let mut total = 0usize;
+    let mut out = vec![];
+    for n in nodes {
+        out.extend(meshes_within(n, &mut total, limit)?);
+    }
+    Ok(out)
+}
+
+/// [`three_d_meshes`], with the triangles of every solid added to `total` as it is built and an
+/// error as soon as `total` passes `limit`.
+fn meshes_within(n: &Node, total: &mut usize, limit: usize) -> Result<Vec<SolidMesh>, String> {
     let meshes = if crate::has_revolve(n) {
-        let mut out = vec![];
-        for m in crate::revolve::revolve_meshes(n)? {
-            keep_mesh(&mut out, &mut total, m, MAX_MESH_TRIANGLES)?;
-        }
-        out
+        crate::revolve::revolve_meshes(n, total, limit)?
     } else if !has_solid(n) {
         return Err("the object has no 3D effect (Extrude & Bevel, Revolve, Inflate or Rotate)".into());
     } else if is_container(n) {
@@ -631,21 +649,21 @@ pub fn three_d_meshes(n: &Node) -> Result<Vec<SolidMesh>, String> {
         let label = crate::effect_info(&fx.id).map_or("This effect", |e| e.label.trim_end_matches('…'));
         let mut shapes = members(n, label)?;
         reshape_members(n, n.appearance.effects.get(..index).unwrap_or_default(), &mut shapes);
-        meshes_for(fx, &shapes, &mut total)?
+        meshes_for(fx, &shapes, total, limit)?
     } else {
         let (path, rule) = profile(n).ok_or("3D export needs a path, compound path, type or group")?;
         let ctx = GeomContext::of(n);
         let paints = solid_paints(n);
         if let Some((index, fx)) = solid(&n.appearance.effects) {
             let path = geometry(&path, n.appearance.effects.get(..index).unwrap_or_default(), &ctx);
-            meshes_for(fx, &[Profile { path, rule, items: paints, opacity: 1.0 }], &mut total)?
+            meshes_for(fx, &[Profile { path, rule, items: paints, opacity: 1.0 }], total, limit)?
         } else {
             let path = geometry(&path, &n.appearance.effects, &ctx);
             let mut out = vec![];
             for item in &paints {
                 if let Some((index, fx)) = solid(item.effects()) {
                     let p = geometry(&path, item.effects().get(..index).unwrap_or_default(), &ctx.item(item));
-                    out.extend(meshes_for(fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0 }], &mut total)?);
+                    out.extend(meshes_for(fx, &[Profile { path: p, rule, items: vec![item.clone()], opacity: 1.0 }], total, limit)?);
                 }
             }
             out
diff --git a/crates/effects/src/solids/tests_mesh.rs b/crates/effects/src/solids/tests_mesh.rs
index 9aca2ab8c..70706e068 100644
--- a/crates/effects/src/solids/tests_mesh.rs
+++ b/crates/effects/src/solids/tests_mesh.rs
@@ -54,9 +54,49 @@ fn the_meshes_of_one_object_share_one_triangle_budget() {
     let shapes = [Profile { path: profile(&n).unwrap().0, rule: FillRule::NonZero, items: solid_paints(&n), opacity: 1.0 }];
     let Some(effect) = n.appearance.effects.first() else { panic!("no effect") };
     let mut total = 0;
-    assert!(meshes_for(effect, &shapes, &mut total).is_ok());
+    assert!(meshes_for(effect, &shapes, &mut total, MAX_MESH_TRIANGLES).is_ok());
     let mut total = MAX_MESH_TRIANGLES - first + 1;
-    assert!(meshes_for(effect, &shapes, &mut total).is_err_and(|e| e.contains("too complex")));
+    assert!(meshes_for(effect, &shapes, &mut total, MAX_MESH_TRIANGLES).is_err_and(|e| e.contains("too complex")));
+}
+
+#[test]
+fn revolve_stops_at_the_first_mesh_past_the_budget() {
+    // The fill revolves into a mesh; the stroke's profile, copied 1000 times, is too complex to
+    // revolve at all.
+    let mut n = square_node(1, 100.0);
+    if let Some(AppearanceItem::Fill(f)) = n.appearance.items.get_mut(0) {
+        f.effects.push(fx(crate::REVOLVE, json!({})));
+    }
+    let fill_only = n.clone();
+    if let Some(AppearanceItem::Stroke(s)) = n.appearance.items.get_mut(1) {
+        s.effects.push(fx("distort.transform", json!({ "moveH": 1.0, "copies": 1000 })));
+        s.effects.push(fx(crate::REVOLVE, json!({})));
+    }
+    let fill = three_d_meshes(&fill_only).unwrap();
+    let triangles = fill[0].mesh.triangles.len();
+    assert!(triangles > 1);
+    let whole = three_d_meshes(&n);
+    assert!(whole.as_ref().is_err_and(|e| !e.contains("to export")), "the stroke's own error: {whole:?}");
+    // With room for less than the fill's mesh, the stroke's is never built.
+    let mut total = 0;
+    let capped = meshes_within(&n, &mut total, triangles - 1);
+    assert!(capped.as_ref().is_err_and(|e| e.contains("too complex to export")), "{capped:?}");
+    assert_eq!(total, triangles);
+}
+
+#[test]
+fn the_objects_of_one_asset_share_one_triangle_budget() {
+    let mut a = square_node(1, 0.0);
+    a.appearance.effects.push(fx(EXTRUDE, json!({})));
+    let mut b = square_node(2, 300.0);
+    b.appearance.effects.push(fx(EXTRUDE, json!({})));
+    let triangles = |n: &Node| three_d_meshes(n).unwrap().iter().map(|m| m.mesh.triangles.len()).sum::<usize>();
+    let (ta, tb) = (triangles(&a), triangles(&b));
+    assert!(meshes_of_within([&a], ta).is_ok());
+    assert!(meshes_of_within([&b], tb).is_ok());
+    assert!(meshes_of_within([&a, &b], ta.max(tb)).is_err_and(|e| e.contains("too complex to export")));
+    assert_eq!(meshes_of_within([&a, &b], ta + tb).map(|m| m.len()), Ok(4));
+    assert_eq!(three_d_meshes_of([&a, &b]).map(|m| m.len()), Ok(4));
 }
 
 #[test]
diff --git a/crates/effects/src/tests.rs b/crates/effects/src/tests.rs
index 0b3fc0b1c..1afa679aa 100644
--- a/crates/effects/src/tests.rs
+++ b/crates/effects/src/tests.rs
@@ -455,6 +455,92 @@ fn art_past_the_budget_keeps_its_own_gradients_in_place() {
     }
 }
 
+/// A hidden path in a layer that keeps its shape past the budget does not hold the layer's
+/// gradients in place: the layer's bounds leave it out, so the layer's own gradient moves with
+/// the visible art under a Transform effect and Free Distort, as does the art's when the layer is
+/// the art.
+#[test]
+fn a_hidden_path_past_the_budget_leaves_a_layers_gradients_free_to_move() {
+    use std::sync::Arc;
+
+    use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop};
+    use vectorcraft_doc::{AppearanceItem, FillLayer, LayerColor, NodeId, NodeKind, color::Paint};
+    let stops = vec![GradientStop::new(0.0, vectorcraft_color::Color::BLACK), GradientStop::new(1.0, vectorcraft_color::Color::WHITE)];
+    let geom = GradientGeom { start: (0.0, 50.0).into(), end: (100.0, 50.0).into(), aspect: 1.0, focal: None };
+    let placed = Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..GradientPaint::new(Gradient::new(GradientKind::Linear, stops)) }));
+    let end = |ap: &Appearance| match ap.fill_paint() {
+        Paint::Gradient(g) => g.geom.map(|g| g.end.x),
+        _ => None,
+    };
+    // A layer with a visible square and a hidden circle, both 0..100, and a gradient fill of its own.
+    let layer = || {
+        let square = Arc::new(Node::path(NodeId(3), shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::default()));
+        let mut circle = Node::path(NodeId(4), shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::default());
+        circle.visible = false;
+        let mut layer = Node::layer(NodeId(2), "Layer 1", LayerColor::Preset(0));
+        if let NodeKind::Layer { children, .. } = &mut layer.kind {
+            *children = vec![square, Arc::new(circle)];
+        }
+        layer.appearance.items.push(AppearanceItem::Fill(FillLayer::new(placed.clone())));
+        layer
+    };
+    // No room beyond what the paths cost: the square takes each effect, the circle would be drawn
+    // with more lines and keeps its shape.
+    let budget = Budget { anchors: usize::MAX, lines: 0 };
+    // Each scales the art ten times about its center: 0..100 becomes -450..550.
+    let corners = json!({"corners": [[-4.5, -4.5], [5.5, -4.5], [5.5, 5.5], [-4.5, 5.5]]});
+    for grow in [fx("distort.transform", json!({"scaleH": 1000, "scaleV": 1000})), fx("distort.freeDistort", corners)] {
+        let mut art = layer();
+        let carry = crate::reshape::reshape_leaves_within(&mut art, &[&grow], budget);
+        let circle = art.children().unwrap()[1].geometric_bounds().unwrap();
+        assert!(circle.width() < 101.0, "{}: the hidden circle keeps its shape: {circle:?}", grow.id);
+        let square = art.children().unwrap()[0].geometric_bounds().unwrap();
+        assert!((square.x1 - 550.0).abs() < 1e-6, "{}: the square takes the effect: {square:?}", grow.id);
+        let mut own = Appearance::clone(&art.appearance);
+        carry.apply(&mut own);
+        assert_eq!(end(&own), Some(550.0), "{}: the layer's gradient, as the art", grow.id);
+        let mut art = Node::group(NodeId(9), vec![Arc::new(layer())]);
+        crate::reshape::reshape_leaves_within(&mut art, &[&grow], budget);
+        assert_eq!(end(&art.children().unwrap()[0].appearance), Some(550.0), "{}: the layer's gradient, inside the art", grow.id);
+    }
+}
+
+/// A freeform gradient whose points were edited (its vector still fitted to the bounds) moves its
+/// points with a Transform effect and Free Distort, on a path, on a group inside the art and on the
+/// art itself, as a placed gradient does.
+#[test]
+fn edited_freeform_points_follow_a_transform_effect_and_free_distort() {
+    use std::sync::Arc;
+
+    use vectorcraft_color::{Color, Freeform, FreeformPoint, Gradient, GradientKind, GradientPaint};
+    use vectorcraft_doc::{AppearanceItem, FillLayer, NodeId, color::Paint};
+    let mut ramp = GradientPaint::new(Gradient { kind: GradientKind::Freeform, ..Gradient::default() });
+    let pt = |x: f64, c| FreeformPoint::new(Point::new(x, 50.0), c);
+    ramp.set_freeform(Freeform { points: vec![pt(0.0, Color::BLACK), pt(100.0, Color::WHITE)], ..Default::default() });
+    assert!(ramp.geom.is_none() && !ramp.is_placed());
+    let freeform = Paint::Gradient(Box::new(ramp));
+    let xs = |ap: &Appearance| match ap.fill_paint() {
+        Paint::Gradient(g) => g.freeform.as_ref().map(|f| f.points.iter().map(|p| p.at.x).collect::<Vec<_>>()),
+        _ => None,
+    };
+    let square = |ap: Appearance| Arc::new(Node::path(NodeId(3), shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), ap));
+    // Each moves the art 30 pt right.
+    let corners = json!({"corners": [[0.3, 0.0], [1.3, 0.0], [1.3, 1.0], [0.3, 1.0]]});
+    for e in [fx("distort.transform", json!({"moveH": 30})), fx("distort.freeDistort", corners)] {
+        let mut inner = Node::group(NodeId(2), vec![square(Appearance::default())]);
+        inner.appearance.items.push(AppearanceItem::Fill(FillLayer::new(freeform.clone())));
+        let mut art = Node::group(NodeId(9), vec![square(Appearance::basic(freeform.clone(), Paint::None, 0.0)), Arc::new(inner)]);
+        art.appearance.items.push(AppearanceItem::Fill(FillLayer::new(freeform.clone())));
+        let carry = crate::reshape::reshape_leaves_within(&mut art, &[&e], Budget::EFFECTS);
+        let members = art.children().unwrap();
+        assert_eq!(xs(&members[0].appearance), Some(vec![30.0, 130.0]), "{}: the path's points", e.id);
+        assert_eq!(xs(&members[1].appearance), Some(vec![30.0, 130.0]), "{}: the inner group's points", e.id);
+        let mut own = Appearance::clone(&art.appearance);
+        carry.apply(&mut own);
+        assert_eq!(xs(&own), Some(vec![30.0, 130.0]), "{}: the art's own points", e.id);
+    }
+}
+
 /// #3578: a large Roughen draws each of its points as many lines; they stay within the budget,
 /// the Roughen built again with fewer points where they wouldn't.
 #[test]
diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs
index eb61b5126..75835394a 100644
--- a/crates/engine/src/cmd.rs
+++ b/crates/engine/src/cmd.rs
@@ -12,6 +12,7 @@ pub mod clipboard;
 mod colorcmds;
 pub mod colormgmt;
 pub mod colortheme;
+pub mod compositefonts;
 mod compoundshape;
 pub(crate) mod create;
 mod css;
@@ -286,6 +287,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(inline::specs());
         v.extend(textstyles::specs());
         v.extend(fonts::specs());
+        v.extend(compositefonts::specs());
         v.extend(fontfiles::specs());
         v.extend(help::specs());
         v.extend(threads::specs());
@@ -420,8 +422,22 @@ pub(crate) fn text_param<'a>(p: &'a Value, key: &str, cmd: &str) -> Result<Optio
 pub(crate) fn id_param(p: &Value, key: &str) -> Option<NodeId> {
     p.get(key).and_then(Value::as_u64).map(NodeId)
 }
-pub(crate) fn ids_param(p: &Value, key: &str) -> Option<Vec<NodeId>> {
-    p.get(key).and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_u64).map(NodeId).collect())
+/// The object ids `p` gives for `key`, or `None` when `p` leaves it out or gives null. A value that
+/// is not an array, or an entry that is not a non-negative integer, is an error with the message
+/// [`checked_ids_param`] gives, so no entry is dropped. Whether each id names an object is left to
+/// the caller.
+pub(crate) fn ids_param(p: &Value, key: &str, cmd: &str) -> Result<Option<Vec<NodeId>>> {
+    let values = match p.get(key) {
+        None | Some(Value::Null) => return Ok(None),
+        Some(Value::Array(a)) => a,
+        Some(_) => return Err(bad(cmd, format!("{key} must be an array of non-negative integer object ids"))),
+    };
+    values.iter().enumerate().map(|(index, value)| id_entry(value, key, index, cmd)).collect::<Result<Vec<_>>>().map(Some)
+}
+/// Entry `index` (from 0) of the `key` list as an object id: anything but a non-negative integer is
+/// an error naming the key, the entry and its value.
+fn id_entry(value: &Value, key: &str, index: usize, cmd: &str) -> Result<NodeId> {
+    value.as_u64().map(NodeId).ok_or_else(|| bad(cmd, format!("`{key}` entry {index} is {value}, not a non-negative integer object id")))
 }
 /// The objects `p` gives `command`: its `ids`, else its `id` as `ids` of one (as [`targets`] reads
 /// them), each checked ([`checked_id`]): a malformed one, or one naming no object, is an error,
@@ -447,7 +463,7 @@ pub(crate) fn index(v: u64) -> usize {
 pub(crate) fn checked_ids_param(s: &Session, p: &Value, key: &str, command: &str) -> Result<Vec<NodeId>> {
     let values =
         p.get(key).and_then(Value::as_array).ok_or_else(|| bad(command, format!("{key} must be an array of non-negative integer object ids")))?;
-    values.iter().map(|value| checked_id(s, value, command)).collect()
+    values.iter().enumerate().map(|(index, value)| id_entry(value, key, index, command).and_then(|_| checked_id(s, value, command))).collect()
 }
 
 /// The objects a command acts on: `ids` when given (every one checked, and those inside another
diff --git a/crates/engine/src/cmd/addons/cleanup/text.rs b/crates/engine/src/cmd/addons/cleanup/text.rs
index d8f2b0289..73b21356b 100644
--- a/crates/engine/src/cmd/addons/cleanup/text.rs
+++ b/crates/engine/src/cmd/addons/cleanup/text.rs
@@ -962,11 +962,9 @@ fn replace_fonts(s: &mut Session, p: &Value) -> Result<Value> {
     let default = CharStyle::default().font_family;
     let wanted = text_param(p, "font", C)?.filter(|f| !f.trim().is_empty()).unwrap_or(&default);
     let db = FontDb::global();
-    // Any name of the family is stored as its own name.
-    let family = match db.resolve(wanted, "Regular") {
-        Some((f, m)) if m != FontMatch::Missing => f.family.clone(),
-        _ => return Err(bad(C, "the replacement font is not available")),
-    };
+    // Any name of the family is stored as its own name, and a composite font as its own name.
+    let composite = db.composite_font(wanted).is_some();
+    let family = db.stored_family(wanted, "Regular").ok_or_else(|| bad(C, "the replacement font is not available"))?;
     let missing = |st: &CharStyle| db.resolve(&st.font_family, &st.font_style).is_none_or(|(_, m)| m == FontMatch::Missing);
     let lacks = |t: &TextObject| t.runs.iter().any(|r| missing(&r.style));
     let d = &s.doc()?.doc;
@@ -988,8 +986,11 @@ fn replace_fonts(s: &mut Session, p: &Value) -> Result<Value> {
         let mut runs = 0;
         let mut replace = |t: &mut TextObject| {
             for r in t.runs.iter_mut().filter(|r| missing(&r.style)) {
-                // The style the font has closest to the one the character had.
-                r.style.font_style = db.face(&family, &r.style.font_style).map_or_else(|| r.style.font_style.clone(), |f| f.style.clone());
+                // The style the font has closest to the one the character had (a composite font's
+                // parts name their own styles: the character keeps its style).
+                if !composite {
+                    r.style.font_style = db.face(&family, &r.style.font_style).map_or_else(|| r.style.font_style.clone(), |f| f.style.clone());
+                }
                 r.style.font_family = family.clone();
                 r.style.font_version = None;
                 r.style.font_axes.clear();
diff --git a/crates/engine/src/cmd/addons/color.rs b/crates/engine/src/cmd/addons/color.rs
index 574003b93..cd30d29d1 100644
--- a/crates/engine/src/cmd/addons/color.rs
+++ b/crates/engine/src/cmd/addons/color.rs
@@ -174,7 +174,7 @@ fn filter(s: &mut Session, p: &Value) -> Result<Value> {
     let label = effects::effect_info(id).map_or("Apply as Filter", |e| e.label.trim_end_matches('…'));
     let kinds = effects::addons::duotone::swatch_kinds(&s.doc()?.doc);
     let swatches = |name: &str| kinds.get(name).copied();
-    recolor_links(s, &given, label, &|c| map.apply(c), &|c, link, tint| map.apply_link(c, link, tint, &swatches))
+    recolor_links(s, &given, C, label, &|c| map.apply(c), &|c, link, tint| map.apply_link(c, link, tint, &swatches))
 }
 
 /// Apply Fill to Stroke (`to_stroke`) or Apply Stroke to Fill: each target copies one of its own
diff --git a/crates/engine/src/cmd/addons/color/nearest.rs b/crates/engine/src/cmd/addons/color/nearest.rs
index 5a9d0e7c7..0236698be 100644
--- a/crates/engine/src/cmd/addons/color/nearest.rs
+++ b/crates/engine/src/cmd/addons/color/nearest.rs
@@ -189,7 +189,7 @@ pub(super) fn apply(s: &mut Session, p: &Value) -> Result<Value> {
     let given = json!({
         "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "fill": fill, "stroke": stroke, "includeImages": false, "includePatterns": false,
     });
-    let r = recolor_links(s, &given, "Apply Nearest Swatch", &|c| to(c).and_then(Paint::color).unwrap_or(c), &links)?;
+    let r = recolor_links(s, &given, APPLY, "Apply Nearest Swatch", &|c| to(c).and_then(Paint::color).unwrap_or(c), &links)?;
     squash(s, undo, "Apply Nearest Swatch");
     Ok(json!({ "changed": r["changed"], "swatches": names, "added": added }))
 }
diff --git a/crates/engine/src/cmd/appearance.rs b/crates/engine/src/cmd/appearance.rs
index 7f7b34352..02990a662 100644
--- a/crates/engine/src/cmd/appearance.rs
+++ b/crates/engine/src/cmd/appearance.rs
@@ -1230,7 +1230,7 @@ fn copy_from(s: &mut Session, p: &Value) -> Result<Value> {
     let selected = if defaults_only {
         vec![]
     } else {
-        match ids_param(p, "ids") {
+        match ids_param(p, "ids", C)? {
             Some(v) => outermost(&s.doc()?.doc, v),
             None => selected_roots(s)?,
         }
diff --git a/crates/engine/src/cmd/assets.rs b/crates/engine/src/cmd/assets.rs
index fd273e067..8c225b877 100644
--- a/crates/engine/src/cmd/assets.rs
+++ b/crates/engine/src/cmd/assets.rs
@@ -277,12 +277,11 @@ fn export_3d(s: &mut Session, p: &Value) -> Result<Value> {
     for id in ids {
         let Some(a) = d.asset(id) else { continue };
         let format = a.format_3d.as_deref().unwrap_or(DEFAULT_FORMAT_3D);
-        let mut parts = vec![];
-        for node in &a.nodes {
-            let n = d.node(*node).ok_or_else(|| bad(C, format!("no such object {0}", node.0)))?;
-            let what = &a.name;
-            parts.extend(vectorcraft_render::effects::three_d_meshes(n).map_err(|e| bad(C, format!("{what} can't be exported in 3D: {e}")))?);
-        }
+        let nodes =
+            a.nodes.iter().map(|node| d.node(*node).ok_or_else(|| bad(C, format!("no such object {0}", node.0)))).collect::<Result<Vec<_>>>()?;
+        // The asset's objects share one budget of triangles.
+        let what = &a.name;
+        let parts = vectorcraft_render::effects::three_d_meshes_of(nodes).map_err(|e| bad(C, format!("{what} can't be exported in 3D: {e}")))?;
         let base = Some(safe_file_name(&a.name)).filter(|b| !b.is_empty()).unwrap_or_else(|| "Asset".into());
         let mut stem = base.clone();
         let mut k = 1;
diff --git a/crates/engine/src/cmd/colorcmds.rs b/crates/engine/src/cmd/colorcmds.rs
index d70a81700..221521efb 100644
--- a/crates/engine/src/cmd/colorcmds.rs
+++ b/crates/engine/src/cmd/colorcmds.rs
@@ -32,7 +32,7 @@ pub fn specs() -> Vec<CommandSpec> {
             None,
             "{fill?: true, stroke?: true, includeImages?: true, includePatterns?: true, ids?} replace each colour by its RGB inverse (keeps the colour model) in fills, strokes, text, gradient meshes (with fills), colorized image fills (their pixels stay unchanged), other embedded images (a recoloured copy) and pattern tiles (a new pattern swatch; the original stays), as one undo step → {changed}",
             has_selection,
-            |s, p| recolor(s, p, "Invert Colors", &invert)
+            |s, p| recolor(s, p, "edit.colors.invert", "Invert Colors", &invert)
         ),
         cmd!(
             "edit.colors.toCMYK",
@@ -41,7 +41,7 @@ pub fn specs() -> Vec<CommandSpec> {
             None,
             "{fill?, stroke?, includeImages?, includePatterns?, ids?} (as edit.colors.invert) → {changed}",
             has_selection,
-            |s, p| recolor(s, p, "Convert to CMYK", &to_cmyk)
+            |s, p| recolor(s, p, "edit.colors.toCMYK", "Convert to CMYK", &to_cmyk)
         ),
         cmd!(
             "edit.colors.toGrayscale",
@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
             None,
             "{fill?, stroke?, includeImages?, includePatterns?, ids?} (as edit.colors.invert) → {changed}",
             has_selection,
-            |s, p| recolor(s, p, "Convert to Grayscale", &to_gray)
+            |s, p| recolor(s, p, "edit.colors.toGrayscale", "Convert to Grayscale", &to_gray)
         ),
         cmd!(
             "edit.colors.toRGB",
@@ -60,7 +60,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "{fill?, stroke?, includeImages?, includePatterns?, ids?} (as edit.colors.invert) → {changed}",
             has_selection,
             |s, p| {
-                recolor(s, p, "Convert to RGB", &|c| {
+                recolor(s, p, "edit.colors.toRGB", "Convert to RGB", &|c| {
                     let [r, g, b] = c.to_rgb();
                     Color::rgb(r, g, b)
                 })
@@ -331,26 +331,27 @@ impl ColorVisitor for Visit<'_, '_> {
     }
 }
 
-pub(crate) fn recolor(s: &mut Session, p: &Value, label: &str, f: &dyn Fn(Color) -> Color) -> Result<Value> {
-    run_pass(s, p, label, Recolor::new(Scope::of(p), f))
+pub(crate) fn recolor(s: &mut Session, p: &Value, cmd: &str, label: &str, f: &dyn Fn(Color) -> Color) -> Result<Value> {
+    run_pass(s, p, cmd, label, Recolor::new(Scope::of(p), f))
 }
 
 /// [`recolor`] with solid colours and gradient stops mapped through `links`, with their swatch
 /// link and tint.
-pub(crate) fn recolor_links(s: &mut Session, p: &Value, label: &str, f: &dyn Fn(Color) -> Color, links: &LinkMap) -> Result<Value> {
-    run_pass(s, p, label, Recolor::with_links(Scope::of(p), f, links))
+pub(crate) fn recolor_links(s: &mut Session, p: &Value, cmd: &str, label: &str, f: &dyn Fn(Color) -> Color, links: &LinkMap) -> Result<Value> {
+    run_pass(s, p, cmd, label, Recolor::with_links(Scope::of(p), f, links))
 }
 
-/// Run `pass` on the `ids` param's objects (default: the selection) as one undo step.
-fn run_pass(s: &mut Session, p: &Value, label: &str, pass: Recolor) -> Result<Value> {
-    let ids = match ids_param(p, "ids") {
+/// Run `pass` on the `ids` param's objects (default: the selection) as one undo step named `label`;
+/// errors name the command `cmd`.
+fn run_pass(s: &mut Session, p: &Value, cmd: &str, label: &str, pass: Recolor) -> Result<Value> {
+    let ids = match ids_param(p, "ids", cmd)? {
         Some(v) => v,
         None => selected_roots(s)?,
     };
     let colorized_ok = super::paint::check_colorized(&s.doc()?.doc).is_ok();
     let n = s.edit(label, |d, _| {
         let n = pass.run(d, &ids);
-        super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(label, e))?;
+        super::paint::check_colorized_kept(colorized_ok, d).map_err(|e| bad(cmd, e))?;
         Ok(n)
     })?;
     Ok(json!({ "changed": n }))
@@ -358,7 +359,7 @@ fn run_pass(s: &mut Session, p: &Value, label: &str, pass: Recolor) -> Result<Va
 
 fn saturate(s: &mut Session, p: &Value) -> Result<Value> {
     let i = (f64_req(p, "intensity", "edit.colors.saturate")?.clamp(-100.0, 100.0) / 100.0) as f32;
-    recolor(s, p, "Saturate", &move |c| {
+    recolor(s, p, "edit.colors.saturate", "Saturate", &move |c| {
         let [h, sat, v] = c.to_hsb();
         let to = (sat * (1.0 + i)).clamp(0.0, 1.0);
         // A color whose saturation stays the same is returned as it is, so it keeps its swatch link.
@@ -416,12 +417,12 @@ fn adjust_balance(s: &mut Session, p: &Value) -> Result<Value> {
                 (*tint, *c) = (t, base.tinted(t));
                 true
             };
-            return run_pass(s, p, "Adjust Colors", Recolor::links(Scope::of(p), &shift));
+            return run_pass(s, p, C, "Adjust Colors", Recolor::links(Scope::of(p), &shift));
         }
         other => return Err(bad(C, format!("unknown mode `{other}` (rgb|cmyk|gray|global)"))),
     };
     let convert = bool_or(p, "convert", false);
-    recolor(s, p, "Adjust Colors", &move |c| {
+    recolor(s, p, C, "Adjust Colors", &move |c| {
         let out = adjust(c);
         if convert { out } else { keep_model(c, out) }
     })
diff --git a/crates/engine/src/cmd/colormgmt.rs b/crates/engine/src/cmd/colormgmt.rs
index 7bdcfad58..d9b5784b6 100644
--- a/crates/engine/src/cmd/colormgmt.rs
+++ b/crates/engine/src/cmd/colormgmt.rs
@@ -287,7 +287,8 @@ fn assign_profile(s: &mut Session, p: &Value) -> Result<Value> {
 /// How Document Color Mode converts neutral RGB greys (R = G = B) to CMYK (the `grays` param).
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub enum Grays {
-    /// Through the CMYK profile like any colour: four-colour greys and a rich black.
+    /// Through the CMYK profile like any colour: light grays in cyan, magenta and yellow only, darker
+    /// grays in four inks, and a rich black.
     #[default]
     Profile,
     /// On the black plate only: K is the grey's ink percentage (as Convert to Grayscale and then
diff --git a/crates/engine/src/cmd/compositefonts.rs b/crates/engine/src/cmd/compositefonts.rs
new file mode 100644
index 000000000..2b356ab85
--- /dev/null
+++ b/crates/engine/src/cmd/compositefonts.rs
@@ -0,0 +1,309 @@
+//! Type › Composite Fonts…: the document's composite fonts ([`vectorcraft_doc::CompositeFont`]),
+//! which set each class of character (Kanji, Kana, Punctuation, Symbols, Roman, Numerals) in a
+//! font of its own. Type names a composite font as its family, and the font menus list them first.
+//! The font database holds the active document's composite fonts ([`sync`]); a file exported here
+//! carries them to another document.
+//!
+//! Behavior reference (public documentation):
+//! <https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347>.
+
+use serde_json::{Map, Value, json};
+use vectorcraft_doc::text::{COMPOSITE_FONTS_MAX, COMPOSITE_NAME_MAX};
+use vectorcraft_doc::{CharClass, CompositeFont, CompositePart, CompositeParts};
+use vectorcraft_text::FontDb;
+
+use super::fileio::{read_file_head, write_file};
+use super::textstyles::each_text_mut;
+use super::typecmd::refresh_bounds;
+use super::{CommandSpec, Result, Session, bad, cmd, has_doc, switch_or, text_param};
+
+/// The extension of the files Export writes and Import reads.
+pub const EXTS: &[&str] = &["vccomposite"];
+
+/// The largest file Import reads, in bytes.
+const MAX_FILE_BYTES: usize = 4 << 20;
+
+/// The keys a part may give.
+const PART_KEYS: [&str; 7] = ["font", "style", "size", "baseline", "hScale", "vScale", "scaleAtCenter"];
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        cmd!(
+            query "type.compositeFonts.list",
+            "Composite Fonts",
+            [],
+            None,
+            "{} the active document's composite fonts → {fonts: [{name, parts: {kanji, kana, punctuation, symbols, roman, numerals: {font, style, size: % of the type size, baseline: % of the type size (positive raises), hScale: %, vScale: %, scaleAtCenter?: bool}}}]}",
+            has_doc,
+            list
+        ),
+        cmd!(
+            "type.compositeFonts.set",
+            "Composite Fonts…",
+            ["Type"],
+            None,
+            "{fonts: [{name, parts: {kanji: {font, style?: \"Regular\", size?: % 10..400 = 100, baseline?: % -100..100 = 0}, kana?, punctuation?, symbols?, roman?, numerals?: {font, style?, size?, baseline?, hScale?, vScale?: % 10..400 = 100, scaleAtCenter?: bool = false}}}]} replace the active document's composite fonts (Type › Composite Fonts…'s OK), as one undo step, none when nothing changes. A composite font sets each class of character in its part's font: kanji (the base: ideographs, full-width letters and digits and anything no other class takes), kana (hiragana and katakana, both widths), punctuation (East Asian and full-width punctuation, quotes and dashes), symbols (arrows, math, shapes and other symbols), roman (half-width letters, their punctuation and spaces) and numerals (the digits 0 to 9); a part left out is the kanji part. size and baseline are percent of the type's size, hScale and vScale scale kana, roman and numerals only, and scaleAtCenter (kana only) scales them from the em box's center instead of the baseline. Names are trimmed, unique in any case, at most 255 characters, and may not name an installed font; a part's font may not be a composite font; at most 256. Type set in a composite font names it as its family (text.setStyle {font: name}), and the font menus list composite fonts first. A font taken out stays named by its type, which then shows as missing → {fonts}",
+            has_doc,
+            set
+        ),
+        cmd!(
+            query "type.compositeFonts.export",
+            "Export Composite Fonts",
+            [],
+            None,
+            "{path?: .vccomposite file, names?: [name] (default: all), fonts?: [{name, parts}] (as type.compositeFonts.set takes them)} write the active document's composite fonts (all, or those named, any case), or the fonts given, to a file type.compositeFonts.import reads; without path the file's text comes back as data → {path, count} | {data, count}",
+            has_doc,
+            export
+        ),
+        cmd!(
+            "type.compositeFonts.import",
+            "Import Composite Fonts",
+            [],
+            None,
+            "{path: .vccomposite file | data: its text | dataBase64: its bytes (at most 4 MB), apply?: bool = true} read the composite fonts a file holds (type.compositeFonts.export writes them); with apply they join the active document's, a font of the same name (any case) replaced, as one undo step, none when nothing changes; apply false only reads them → {fonts, imported: [name]}",
+            has_doc,
+            import
+        ),
+    ]
+}
+
+/// Register the active document's composite fonts in the font database, and remove the ones the
+/// other open documents (or an earlier active document) defined. Run after each command and when
+/// another document takes the front, so an undo, a revert, an opened or closed file or a document
+/// switch draws type in the active document's own composite fonts, and type naming one it does
+/// not define shows as missing. Whether a composite font was added, changed or removed.
+pub(crate) fn sync(s: &mut Session) -> bool {
+    let db = FontDb::global();
+    let mut names = Vec::new();
+    let mut changed = false;
+    for f in s.active().map(|d| d.doc.composite_fonts.to_vec()).unwrap_or_default() {
+        changed |= db.set_composite_font(&f);
+        names.push(f.name.to_lowercase());
+    }
+    let others = s.docs.iter().flat_map(|d| d.doc.composite_fonts.iter().map(|f| f.name.to_lowercase()));
+    let stale: Vec<String> = s.composite_names.iter().cloned().chain(others).filter(|n| !names.contains(n)).collect();
+    for gone in stale {
+        changed |= db.remove_composite_font(&gone);
+    }
+    s.composite_names = names;
+    changed
+}
+
+/// Leave out a file's unusable composite fonts before registering and measuring its type.
+pub(crate) fn filter_loaded(doc: &mut vectorcraft_doc::Document) {
+    let db = FontDb::global();
+    if let Some(kept) = CompositeFont::usable(&doc.composite_fonts) {
+        *doc.composite_fonts = kept;
+    }
+    doc.composite_fonts.retain(|f| !db.has_installed_family(&f.name));
+}
+
+fn list(s: &mut Session, _: &Value) -> Result<Value> {
+    Ok(json!({ "fonts": *s.doc()?.doc.composite_fonts }))
+}
+
+/// Composite font `v` from command parameters or a file: its name trimmed, each part left out a
+/// copy of the Kanji part, and keys or values a part can't take refused.
+fn parse_font(v: &Value, c: &str) -> Result<CompositeFont> {
+    let o = v.as_object().ok_or_else(|| bad(c, "each font must be {name, parts}"))?;
+    if let Some(k) = o.keys().find(|k| !["name", "parts"].contains(&k.as_str())) {
+        return Err(bad(c, format!("unknown key `{k}`; a font takes name and parts")));
+    }
+    let raw = o.get("name").and_then(Value::as_str).ok_or_else(|| bad(c, "each font needs a name"))?;
+    let name = CompositeFont::clean_name(raw)
+        .ok_or_else(|| bad(c, format!("`{raw}` can't name a composite font (1 to {COMPOSITE_NAME_MAX} characters, no control characters)")))?;
+    let parts = o.get("parts").and_then(Value::as_object).ok_or_else(|| bad(c, format!("`{name}`: parts must be an object")))?;
+    if let Some(k) = parts.keys().find(|k| !CharClass::ALL.iter().any(|c| c.key() == k.as_str())) {
+        return Err(bad(c, format!("`{name}`: unknown class `{k}`; the classes are kanji, kana, punctuation, symbols, roman and numerals")));
+    }
+    let part = |class: CharClass| -> Result<Option<CompositePart>> {
+        let Some(p) = parts.get(class.key()) else { return Ok(None) };
+        let po = p.as_object().ok_or_else(|| bad(c, format!("`{name}`: {} must be an object", class.key())))?;
+        if let Some(k) = po.keys().find(|k| !PART_KEYS.contains(&k.as_str())) {
+            return Err(bad(c, format!("`{name}`: unknown key `{k}` in {}", class.key())));
+        }
+        serde_json::from_value(p.clone()).map(Some).map_err(|e| bad(c, format!("`{name}`: {}: {e}", class.key())))
+    };
+    let kanji = part(CharClass::Kanji)?.ok_or_else(|| bad(c, format!("`{name}`: give the kanji part")))?;
+    let mut f = CompositeFont { name: name.clone(), parts: CompositeParts::all(kanji) };
+    for class in CharClass::ALL.into_iter().skip(1) {
+        if let Some(p) = part(class)? {
+            *f.parts.get_mut(class) = p;
+        }
+    }
+    f.check().map_err(|e| bad(c, format!("`{}`: {e}", f.name)))?;
+    Ok(f)
+}
+
+/// Error unless `fonts` can stand together in a document: names unique in any case, none naming
+/// an installed font, no part set in a composite font, and at most [`COMPOSITE_FONTS_MAX`].
+fn check_set(fonts: &[CompositeFont], c: &str) -> Result<()> {
+    if fonts.len() > COMPOSITE_FONTS_MAX {
+        return Err(bad(c, format!("a document keeps at most {COMPOSITE_FONTS_MAX} composite fonts")));
+    }
+    let db = FontDb::global();
+    let mut names = std::collections::HashSet::new();
+    for f in fonts {
+        if !names.insert(f.name.to_lowercase()) {
+            return Err(bad(c, format!("two composite fonts are named `{}`", f.name)));
+        }
+        if db.has_installed_family(&f.name) {
+            return Err(bad(c, format!("`{}` is the name of an installed font", f.name)));
+        }
+    }
+    for f in fonts {
+        for class in CharClass::ALL {
+            let font = &f.parts.get(class).font;
+            if names.contains(&font.to_lowercase()) || db.composite_font(font).is_some() {
+                return Err(bad(c, format!("`{}`: {} is set in `{font}`, a composite font", f.name, class.key())));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Make `after` the active document's composite fonts, as one undo step named `label` (none when
+/// they are what it has). The font database forgets the ones taken out, and type set in a font
+/// that changed is measured again.
+fn replace(s: &mut Session, label: &str, after: Vec<CompositeFont>) -> Result<()> {
+    let before = s.doc()?.doc.composite_fonts.to_vec();
+    if before == after {
+        return Ok(());
+    }
+    let changed: Vec<String> =
+        before.iter().filter(|b| !after.contains(b)).chain(after.iter().filter(|a| !before.contains(a))).map(|f| f.name.to_lowercase()).collect();
+    let db = FontDb::global();
+    for f in &before {
+        if !after.iter().any(|a| CompositeFont::same_name(&a.name, &f.name)) {
+            db.remove_composite_font(&f.name);
+        }
+    }
+    for f in &after {
+        db.set_composite_font(f);
+    }
+    let r = s.edit(label, |d, _| {
+        *d.composite_fonts = after.clone();
+        each_text_mut(d, &mut |t| {
+            if t.runs.iter().any(|r| changed.contains(&r.style.font_family.to_lowercase())) {
+                refresh_bounds(t);
+            }
+            Ok(())
+        })
+    });
+    sync(s);
+    r
+}
+
+fn set(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "type.compositeFonts.set";
+    let list = p.get("fonts").and_then(Value::as_array).ok_or_else(|| bad(C, "give fonts: [{name, parts}…]"))?;
+    let fonts = list.iter().map(|v| parse_font(v, C)).collect::<Result<Vec<_>>>()?;
+    check_set(&fonts, C)?;
+    replace(s, "Composite Fonts", fonts.clone())?;
+    Ok(json!({ "fonts": fonts }))
+}
+
+fn export(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "type.compositeFonts.export";
+    let path = text_param(p, "path", C)?;
+    if path.is_some_and(|p| p.trim().is_empty()) {
+        return Err(bad(C, "path is empty"));
+    }
+    let all = match p.get("fonts") {
+        None | Some(Value::Null) => s.doc()?.doc.composite_fonts.to_vec(),
+        Some(Value::Array(list)) => {
+            let fonts = list.iter().map(|v| parse_font(v, C)).collect::<Result<Vec<_>>>()?;
+            check_set(&fonts, C)?;
+            fonts
+        }
+        Some(_) => return Err(bad(C, "fonts must be a list of composite fonts")),
+    };
+    let fonts = match p.get("names") {
+        None | Some(Value::Null) => all,
+        Some(Value::Array(names)) => {
+            let mut out = Vec::with_capacity(names.len());
+            for n in names {
+                let n = n.as_str().ok_or_else(|| bad(C, "names must be strings"))?;
+                let f = all
+                    .iter()
+                    .find(|f| CompositeFont::same_name(&f.name, n.trim()))
+                    .ok_or_else(|| bad(C, format!("no composite font named `{n}`")))?;
+                if !out.contains(f) {
+                    out.push(f.clone());
+                }
+            }
+            out
+        }
+        Some(_) => return Err(bad(C, "names must be a list of names")),
+    };
+    if fonts.is_empty() {
+        return Err(bad(C, "no composite fonts to export"));
+    }
+    let mut file = Map::new();
+    file.insert("compositeFonts".into(), json!(fonts));
+    let text = serde_json::to_string_pretty(&file).map_err(|e| bad(C, e.to_string()))?;
+    match path {
+        Some(path) => {
+            write_file(path, text.as_bytes())?;
+            Ok(json!({ "path": path, "count": fonts.len() }))
+        }
+        None => Ok(json!({ "data": text, "count": fonts.len() })),
+    }
+}
+
+/// The composite fonts in the bytes of an exported file.
+fn read_fonts(bytes: &[u8], c: &str) -> Result<Vec<CompositeFont>> {
+    let v: Value = serde_json::from_slice(bytes).map_err(|e| bad(c, format!("not a composite fonts file: {e}")))?;
+    let list = v.get("compositeFonts").and_then(Value::as_array).ok_or_else(|| bad(c, "not a composite fonts file: no compositeFonts list"))?;
+    if list.len() > COMPOSITE_FONTS_MAX {
+        return Err(bad(c, format!("the file holds more than {COMPOSITE_FONTS_MAX} composite fonts")));
+    }
+    list.iter().map(|f| parse_font(f, c)).collect()
+}
+
+fn import(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "type.compositeFonts.import";
+    let apply = switch_or(p, "apply", true, C)?;
+    let given = (text_param(p, "path", C)?, text_param(p, "data", C)?, text_param(p, "dataBase64", C)?);
+    let too_large = || bad(C, "the file is larger than 4 MB");
+    let bytes = match given {
+        (Some(path), None, None) if !path.trim().is_empty() => read_file_head(path, MAX_FILE_BYTES + 1)?,
+        (None, Some(text), None) => text.as_bytes().to_vec(),
+        (None, None, Some(b64)) => {
+            if b64.len() > MAX_FILE_BYTES / 3 * 4 + 4 {
+                return Err(too_large());
+            }
+            vectorcraft_format::base64_decode(b64).ok_or_else(|| bad(C, "dataBase64 is not base64"))?
+        }
+        _ => return Err(bad(C, "give one of path, data or dataBase64")),
+    };
+    if bytes.len() > MAX_FILE_BYTES {
+        return Err(too_large());
+    }
+    let fonts = read_fonts(&bytes, C)?;
+    if fonts.is_empty() {
+        return Err(bad(C, "the file holds no composite fonts"));
+    }
+    let mut names = std::collections::HashSet::new();
+    if let Some(f) = fonts.iter().find(|f| !names.insert(f.name.to_lowercase())) {
+        return Err(bad(C, format!("the file holds two composite fonts named `{}`", f.name)));
+    }
+    if apply {
+        let mut after = s.doc()?.doc.composite_fonts.to_vec();
+        for f in &fonts {
+            match after.iter_mut().find(|a| CompositeFont::same_name(&a.name, &f.name)) {
+                Some(a) => *a = f.clone(),
+                None => after.push(f.clone()),
+            }
+        }
+        check_set(&after, C)?;
+        replace(s, "Import Composite Fonts", after)?;
+    } else {
+        check_set(&fonts, C)?;
+    }
+    let imported: Vec<&str> = fonts.iter().map(|f| f.name.as_str()).collect();
+    Ok(json!({ "fonts": fonts, "imported": imported }))
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/engine/src/cmd/compositefonts/tests.rs b/crates/engine/src/cmd/compositefonts/tests.rs
new file mode 100644
index 000000000..670a85ee2
--- /dev/null
+++ b/crates/engine/src/cmd/compositefonts/tests.rs
@@ -0,0 +1,502 @@
+use serde_json::{Value, json};
+use vectorcraft_doc::{NodeId, NodeKind};
+
+use crate::Session;
+
+/// A composite font named `name`: Source Sans 3 for the base, JetBrains Mono at half size for
+/// Roman, Inter for numerals.
+fn font(name: &str) -> Value {
+    json!({"name": name, "parts": {
+        "kanji": {"font": "Source Sans 3"},
+        "roman": {"font": "JetBrains Mono", "size": 50, "baseline": 10},
+        "numerals": {"font": "Inter", "hScale": 80},
+    }})
+}
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    s
+}
+
+fn names(s: &Session) -> Vec<String> {
+    s.doc().unwrap().doc.composite_fonts.iter().map(|f| f.name.clone()).collect()
+}
+
+fn steps(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+fn text(s: &Session, id: u64) -> vectorcraft_doc::TextObject {
+    match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+        NodeKind::Text(t) => (**t).clone(),
+        _ => panic!("not text"),
+    }
+}
+
+/// A scratch folder of the test's own.
+fn folder(name: &str) -> std::path::PathBuf {
+    let dir = std::env::temp_dir().join(format!("vectorcraft-composite-fonts-{name}-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir
+}
+
+/// Composite Fonts' OK replaces the document's composite fonts as one undo step (none when nothing
+/// changes); parts left out copy the Kanji part; they are saved with the document and undone with
+/// it.
+#[test]
+fn composite_fonts_are_set_as_one_undo_step_and_saved() {
+    let mut s = session();
+    let before = steps(&s);
+    let r = s.execute("type.compositeFonts.set", &json!({"fonts": [font(" CF Saved A "), font("CF Saved B")]})).unwrap();
+    assert_eq!(r["fonts"][0]["name"], "CF Saved A");
+    assert_eq!(names(&s), ["CF Saved A", "CF Saved B"]);
+    assert_eq!(steps(&s), before + 1);
+    let f = &s.doc().unwrap().doc.composite_fonts[0];
+    assert_eq!((f.parts.kana.font.as_str(), f.parts.roman.size, f.parts.numerals.h_scale), ("Source Sans 3", 50.0, 80.0));
+    // The same fonts again change nothing.
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Saved A"), font("CF Saved B")]})).unwrap();
+    assert_eq!(steps(&s), before + 1);
+    let listed = s.execute("type.compositeFonts.list", &json!({})).unwrap();
+    assert_eq!(listed["fonts"].as_array().map(Vec::len), Some(2));
+    // They travel with the file.
+    let back = vectorcraft_format::load(&vectorcraft_format::save_file(&s.doc().unwrap().doc)).unwrap();
+    assert_eq!(*back.composite_fonts, *s.doc().unwrap().doc.composite_fonts);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(names(&s).is_empty());
+}
+
+/// Bad fonts are refused with an error and no undo step: a name that is empty, shared (in any
+/// case) or an installed font's; a part set in a composite font; an unknown class or key; a value
+/// out of range, of the wrong type, or on a class that can't take it; no Kanji part.
+#[test]
+fn bad_composite_fonts_are_refused() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Refused Base")]})).unwrap();
+    let before = steps(&s);
+    let with = |f: &dyn Fn(&mut Value)| {
+        let mut v = font("CF Refused");
+        f(&mut v);
+        json!({"fonts": [v]})
+    };
+    for bad in [
+        json!({}),
+        json!({"fonts": "CF"}),
+        json!({"fonts": [font("  ")]}),
+        json!({"fonts": [font("CF Twice"), font("cf twice")]}),
+        json!({"fonts": [font("Source Sans 3")]}),
+        json!({"fonts": [font("Tab\tName")]}),
+        with(&|v| v["parts"]["roman"]["font"] = json!("CF Refused Base")),
+        with(&|v| v["parts"]["roman"]["font"] = json!("CF Refused")),
+        with(&|v| v["parts"]["hangul"] = json!({"font": "Inter"})),
+        with(&|v| v["parts"]["Roman"] = json!({"font": "Inter"})),
+        with(&|v| v["parts"]["roman"]["width"] = json!(3)),
+        with(&|v| v["parts"]["roman"]["size"] = json!(5)),
+        with(&|v| v["parts"]["roman"]["size"] = json!("50")),
+        with(&|v| v["parts"]["roman"]["baseline"] = json!(-120)),
+        with(&|v| v["parts"]["kanji"]["hScale"] = json!(90)),
+        with(&|v| v["parts"]["punctuation"] = json!({"font": "Inter", "vScale": 90})),
+        with(&|v| v["parts"]["roman"]["scaleAtCenter"] = json!(true)),
+        with(&|v| v["parts"]["kana"] = json!({"font": "Inter", "scaleAtCenter": "yes"})),
+        with(&|v| v["parts"]["roman"]["font"] = json!("")),
+        with(&|v| v["extra"] = json!(1)),
+        with(&|v| {
+            v["parts"].as_object_mut().unwrap().remove("kanji");
+        }),
+    ] {
+        assert!(s.execute("type.compositeFonts.set", &bad).is_err(), "accepted {bad}");
+        assert_eq!(names(&s), ["CF Refused Base"]);
+        assert_eq!(steps(&s), before);
+    }
+    // Kana scaled at the center is allowed.
+    let ok = with(&|v| v["parts"]["kana"] = json!({"font": "Inter", "vScale": 80, "scaleAtCenter": true}));
+    s.execute("type.compositeFonts.set", &ok).unwrap();
+    assert_eq!(names(&s), ["CF Refused"]);
+}
+
+/// Type set in a composite font names it and is not missing; each class is drawn in its part's
+/// font; changing the font measures the type again, and taking it out leaves the type naming it,
+/// shown as missing.
+#[test]
+fn type_set_in_a_composite_font_follows_it() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Type")]})).unwrap();
+    let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab12", "size": 20})).unwrap()["id"].as_u64().unwrap();
+    let r = s.execute("text.setStyle", &json!({"ids": [id], "font": "CF Type"})).unwrap();
+    assert!(r.get("warning").is_none(), "{r}");
+    let t = text(&s, id);
+    assert_eq!(t.runs[0].style.font_family, "CF Type");
+    let db = vectorcraft_text::FontDb::global();
+    let face = |family: &str| db.face(family, "Regular").unwrap().id();
+    let lay = vectorcraft_text::layout(db, &t);
+    let fonts: Vec<u32> = lay.glyphs.iter().map(|g| g.font_id).collect();
+    assert_eq!(fonts, [face("JetBrains Mono"), face("JetBrains Mono"), face("Inter"), face("Inter")]);
+    let missing = |s: &mut Session| s.execute("text.fonts", &json!({})).unwrap().as_array().unwrap().iter().filter(|f| f["missing"] == true).count();
+    assert_eq!(missing(&mut s), 0);
+    // Roman at full size makes the type wider, measured again in the same step.
+    let wide = t.cached_bounds.unwrap().width();
+    let mut full = font("CF Type");
+    full["parts"]["roman"]["size"] = json!(100);
+    let before = steps(&s);
+    s.execute("type.compositeFonts.set", &json!({"fonts": [full]})).unwrap();
+    assert_eq!(steps(&s), before + 1);
+    assert!(text(&s, id).cached_bounds.unwrap().width() > wide + 1.0);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!((text(&s, id).cached_bounds.unwrap().width() - wide).abs() < 1e-6);
+    assert_eq!(db.composite_font("CF Type").unwrap().parts.roman.size, 50.0);
+    // Taken out, the type keeps the name, now missing; undone, the font is back.
+    s.execute("type.compositeFonts.set", &json!({"fonts": []})).unwrap();
+    assert!(db.composite_font("CF Type").is_none());
+    assert_eq!(text(&s, id).runs[0].style.font_family, "CF Type");
+    assert_eq!(missing(&mut s), 1);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(db.composite_font("CF Type").is_some());
+    assert_eq!(missing(&mut s), 0);
+}
+
+/// Type in a symbol's art is measured again too when the composite font it names changes.
+#[test]
+fn type_in_symbol_art_follows_its_composite_font() {
+    fn width(s: &Session) -> f64 {
+        fn find(n: &vectorcraft_doc::Node) -> Option<f64> {
+            if let NodeKind::Text(t) = &n.kind {
+                return t.cached_bounds.map(|b| b.width());
+            }
+            n.children().into_iter().flatten().find_map(|c| find(c))
+        }
+        s.doc().unwrap().doc.symbols.iter().find_map(|sym| find(&sym.art)).unwrap()
+    }
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Symbol")]})).unwrap();
+    let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab12", "size": 20, "font": "CF Symbol"})).unwrap()["id"].as_u64().unwrap();
+    s.execute("symbol.new", &json!({"name": "CF Mark", "ids": [id]})).unwrap();
+    let narrow = width(&s);
+    let mut full = font("CF Symbol");
+    full["parts"]["roman"]["size"] = json!(100);
+    s.execute("type.compositeFonts.set", &json!({"fonts": [full]})).unwrap();
+    assert!(width(&s) > narrow + 1.0);
+}
+
+/// The font database forgets a composite font once no open document defines it: after the step
+/// that added it is undone, and after its document closes.
+#[test]
+fn composite_fonts_no_document_defines_are_forgotten() {
+    let db = vectorcraft_text::FontDb::global();
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Forgotten Undo")]})).unwrap();
+    assert!(db.composite_font("CF Forgotten Undo").is_some());
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(db.composite_font("CF Forgotten Undo").is_none());
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert!(db.composite_font("CF Forgotten Undo").is_some());
+    s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Forgotten Close")]})).unwrap();
+    s.execute("file.close", &json!({})).unwrap();
+    assert!(db.composite_font("CF Forgotten Close").is_none());
+    assert!(db.composite_font("CF Forgotten Undo").is_some());
+}
+
+/// SVG and legacy `.ai` write type in a composite font as its outlines, since a reader can't find
+/// the font by its name.
+#[test]
+fn exports_outline_type_in_a_composite_font() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Export")]})).unwrap();
+    s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab1", "size": 20, "font": "CF Export"})).unwrap();
+    let svg = s.execute("document.export", &json!({"format": "svg"})).unwrap();
+    let svg = String::from_utf8(vectorcraft_format::base64_decode(svg["dataBase64"].as_str().unwrap()).unwrap()).unwrap();
+    assert!(!svg.contains("CF Export") && !svg.contains("<text") && svg.contains("<path"), "{svg}");
+    let ai = vectorcraft_eps::export_legacy_ai(&s.doc().unwrap().doc, &vectorcraft_eps::LegacyAiOptions::default()).unwrap();
+    assert!(!String::from_utf8_lossy(&ai.bytes).contains("CF Export"));
+}
+
+/// A document exported without a session (whose composite fonts the font database doesn't hold),
+/// or while another document defines the name differently, still has its type in a composite font
+/// written as outlines, drawn in its own definition's parts: SVG
+/// writes the outlines the same type set in the part's font writes, PDF embeds the part's font, and
+/// legacy `.ai` doesn't name the composite font.
+#[test]
+fn exports_draw_composite_fonts_of_a_document_without_a_session() {
+    let mut s = session();
+    let mono = json!({"name": "CF Standalone", "parts": {"kanji": {"font": "JetBrains Mono"}}});
+    s.execute("type.compositeFonts.set", &json!({"fonts": [mono]})).unwrap();
+    let id =
+        s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab1", "size": 20, "font": "CF Standalone"})).unwrap()["id"].as_u64().unwrap();
+    let doc = (*s.doc().unwrap().doc).clone();
+    // The font database forgets the font; the copy of the document still defines it.
+    s.execute("type.compositeFonts.set", &json!({"fonts": []})).unwrap();
+    let db = vectorcraft_text::FontDb::global();
+    assert!(db.composite_font("CF Standalone").is_none());
+    let paths = |svg: &str| svg.split(" d=\"").skip(1).filter_map(|p| p.split('"').next().map(str::to_string)).collect::<Vec<_>>();
+    let svg = vectorcraft_svg::export(&doc, &vectorcraft_svg::ExportOptions::default());
+    assert!(!svg.contains("CF Standalone") && !svg.contains("<text"), "{svg}");
+    s.execute("text.setStyle", &json!({"ids": [id], "font": "JetBrains Mono"})).unwrap();
+    let plain = vectorcraft_svg::export(&s.doc().unwrap().doc, &vectorcraft_svg::ExportOptions { outline_text: true, ..Default::default() });
+    assert!(!paths(&svg).is_empty());
+    assert_eq!(paths(&svg), paths(&plain));
+    let pdf = vectorcraft_pdf::export(&doc, &vectorcraft_pdf::PdfOptions::uncompressed()).unwrap();
+    assert!(String::from_utf8_lossy(&pdf).contains("JetBrainsMono"));
+    let ai = vectorcraft_eps::export_legacy_ai(&doc, &vectorcraft_eps::LegacyAiOptions::default()).unwrap();
+    assert!(!String::from_utf8_lossy(&ai.bytes).contains("CF Standalone"));
+    // The fonts lent for the exports are forgotten again.
+    assert!(db.composite_font("CF Standalone").is_none());
+    // With the front document defining the name differently, the exported document's own
+    // definition draws its type, and the front document's is put back.
+    let inter = json!({"name": "CF Standalone", "parts": {"kanji": {"font": "Inter"}}});
+    s.execute("type.compositeFonts.set", &json!({"fonts": [inter]})).unwrap();
+    let svg = vectorcraft_svg::export(&doc, &vectorcraft_svg::ExportOptions::default());
+    assert_eq!(paths(&svg), paths(&plain));
+    assert_eq!(db.composite_font("CF Standalone").unwrap().parts.kanji.font, "Inter");
+}
+
+/// Replace Font and Replace Missing Fonts set type in a composite font by the font's own name,
+/// not its Kanji part's, and keep the type's style.
+#[test]
+fn replacing_a_font_with_a_composite_font_names_it() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Replace")]})).unwrap();
+    let id =
+        s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab12", "size": 20, "font": "Source Serif 4"})).unwrap()["id"].as_u64().unwrap();
+    let r = s.execute("text.replaceFont", &json!({"from": {"family": "Source Serif 4"}, "to": {"family": "cf replace"}})).unwrap();
+    assert_eq!(r["runs"], 1, "{r}");
+    assert!(r.get("warning").is_none(), "{r}");
+    let t = text(&s, id);
+    assert_eq!((t.runs[0].style.font_family.as_str(), t.runs[0].style.font_style.as_str()), ("CF Replace", "Regular"));
+    let gone = s
+        .execute("text.create", &json!({"x": 10, "y": 90, "text": "Lost", "size": 20, "font": "No Such Font Family", "style": "Bold"}))
+        .unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let r = s.execute("addon.cleanup.replaceFonts", &json!({"font": "CF Replace"})).unwrap();
+    assert_eq!((r["runs"].as_u64(), r["font"].as_str()), (Some(1), Some("CF Replace")), "{r}");
+    let t = text(&s, gone);
+    assert_eq!((t.runs[0].style.font_family.as_str(), t.runs[0].style.font_style.as_str()), ("CF Replace", "Bold"));
+}
+
+/// When a part's font is missing, though the Kanji part's is installed, text.missingFonts names
+/// that part's font for type with characters in that part, text.fonts shows the composite font as
+/// missing (resolved in the fallback font that draws that part), and setting type in it warns;
+/// missingGlyphs counts the characters that the font of their part lacks. Each run is checked on
+/// its own, as layout splits it.
+#[test]
+fn font_inventory_checks_the_part_of_each_character() {
+    let mut s = session();
+    let mut f = font("CF Inventory");
+    f["parts"]["kanji"]["font"] = json!("Source Serif 4");
+    f["parts"]["roman"]["font"] = json!("No Such Part Font");
+    s.execute("type.compositeFonts.set", &json!({"fonts": [f]})).unwrap();
+    // Numerals are drawn in Inter: nothing is missing.
+    let r = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "12", "size": 20, "font": "CF Inventory"})).unwrap();
+    assert!(r.get("warning").is_none(), "{r}");
+    assert_eq!(s.execute("text.missingFonts", &json!({})).unwrap()["count"], 0);
+    // Roman letters are drawn in the missing font.
+    let r = s.execute("text.create", &json!({"x": 10, "y": 90, "text": "Ab", "size": 20, "font": "CF Inventory"})).unwrap();
+    assert!(r["warning"].as_str().is_some_and(|w| w.contains("No Such Part Font")), "{r}");
+    let missing = s.execute("text.missingFonts", &json!({})).unwrap();
+    let names: Vec<&str> = missing["fonts"].as_array().unwrap().iter().filter_map(|f| f["family"].as_str()).collect();
+    assert_eq!(names, ["No Such Part Font"], "{missing}");
+    let fonts = s.execute("text.fonts", &json!({})).unwrap();
+    let row = fonts.as_array().unwrap().iter().find(|r| r["family"] == "CF Inventory").cloned().unwrap();
+    assert_eq!((&row["missing"], &row["status"]), (&json!(true), &json!("missing")), "{row}");
+    assert_eq!(row["resolved"]["family"], vectorcraft_text::FALLBACK_FAMILY, "{row}");
+    // A run that starts with a combining mark after a run ending in kana: the mark is Roman.
+    let boundary = json!({"name": "CF Boundary", "parts": {"kanji": {"font": "Source Sans 3"}, "roman": {"font": "No Such Part Font"}}});
+    s.execute("type.compositeFonts.set", &json!({"fonts": [boundary]})).unwrap();
+    let id = s.execute("text.create", &json!({"x": 10, "y": 170, "text": "\u{304B}\u{301}", "size": 20, "font": "CF Boundary"})).unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let row =
+        |s: &mut Session| s.execute("text.fonts", &json!({})).unwrap().as_array().unwrap().iter().find(|r| r["family"] == "CF Boundary").cloned();
+    assert_eq!(row(&mut s).unwrap()["status"], "exact");
+    s.execute("text.setRangeStyle", &json!({"id": id, "start": 3, "end": 5, "size": 30})).unwrap();
+    assert_eq!(text(&s, id).runs.len(), 2);
+    assert_eq!(row(&mut s).unwrap()["status"], "missing");
+    // A symbol the Kanji part's font draws but the Symbols part's font lacks.
+    let db = vectorcraft_text::FontDb::global();
+    let (mono, sans) = (db.face("JetBrains Mono", "Regular").unwrap(), db.face("Source Sans 3", "Regular").unwrap());
+    let c = ('\u{2190}'..='\u{2BFF}').find(|c| mono.covers(*c) && !sans.covers(*c)).expect("a symbol only JetBrains Mono draws");
+    let glyphs = json!({"name": "CF Glyphs", "parts": {"kanji": {"font": "JetBrains Mono"}, "symbols": {"font": "Source Sans 3"}}});
+    s.execute("type.compositeFonts.set", &json!({"fonts": [glyphs]})).unwrap();
+    s.execute("text.create", &json!({"x": 10, "y": 130, "text": c.to_string(), "size": 20, "font": "CF Glyphs"})).unwrap();
+    let fonts = s.execute("text.fonts", &json!({})).unwrap();
+    let row = fonts.as_array().unwrap().iter().find(|r| r["family"] == "CF Glyphs").cloned().unwrap();
+    assert_eq!(row["missingGlyphs"], 1, "{row}");
+}
+
+/// The Glyphs panel's alternates of a character in a composite font come from the font of the
+/// part its grapheme cluster falls in.
+#[test]
+fn glyph_alternates_of_composite_type_come_from_the_characters_part() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Glyph Part")]})).unwrap();
+    let id =
+        s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab12", "size": 20, "font": "CF Glyph Part"})).unwrap()["id"].as_u64().unwrap();
+    let r = s.execute("text.glyphAlternates", &json!({"id": id, "start": 2})).unwrap();
+    assert_eq!(r["font"], "Inter", "{r}");
+    let r = s.execute("text.glyphAlternates", &json!({"id": id, "start": 0})).unwrap();
+    assert_eq!(r["font"], "JetBrains Mono", "{r}");
+    // A combining mark is drawn in the part of the character it follows.
+    let id = s.execute("text.create", &json!({"x": 10, "y": 90, "text": "1\u{301}", "size": 20, "font": "CF Glyph Part"})).unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let r = s.execute("text.glyphAlternates", &json!({"id": id, "start": 1})).unwrap();
+    assert_eq!(r["font"], "Inter", "{r}");
+}
+
+/// With two documents defining one name differently, the type is drawn in the front document's.
+#[test]
+fn the_front_document_defines_a_shared_name() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Front")]})).unwrap();
+    s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
+    let mut other = font("CF Front");
+    other["parts"]["roman"]["size"] = json!(75);
+    s.execute("type.compositeFonts.set", &json!({"fonts": [other]})).unwrap();
+    let db = vectorcraft_text::FontDb::global();
+    assert_eq!(db.composite_font("CF Front").unwrap().parts.roman.size, 75.0);
+    s.execute("document.activate", &json!({"index": 0})).unwrap();
+    assert_eq!(db.composite_font("CF Front").unwrap().parts.roman.size, 50.0);
+}
+
+/// A composite font only a document in the back defines is not available in the front one, where
+/// type naming it shows as missing; a click on the back document's tab brings it back.
+#[test]
+fn a_font_only_a_back_document_defines_is_missing_in_front() {
+    let db = vectorcraft_text::FontDb::global();
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Back Only")]})).unwrap();
+    s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap();
+    assert!(db.composite_font("CF Back Only").is_none());
+    s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab", "size": 20, "font": "CF Back Only"})).unwrap();
+    let fonts = s.execute("text.fonts", &json!({})).unwrap();
+    assert!(fonts.as_array().unwrap().iter().any(|f| f["missing"] == true), "{fonts}");
+    assert!(s.set_active(0));
+    assert!(db.composite_font("CF Back Only").is_some());
+}
+
+/// A newly opened document measures a missing font without using the previous tab's composite
+/// font of the same name.
+#[test]
+fn opened_document_measures_missing_composite_font_as_missing() {
+    let mut s = session();
+    s.execute("type.compositeFonts.set", &json!({"fonts": [font("CF Previous Tab")]})).unwrap();
+    let id =
+        s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab", "size": 20, "font": "CF Previous Tab"})).unwrap()["id"].as_u64().unwrap();
+    let mut doc = (*s.doc().unwrap().doc).clone();
+    doc.composite_fonts.clear();
+    if let NodeKind::Text(t) = &mut doc.node_mut(NodeId(id)).unwrap().kind {
+        t.cached_bounds = None;
+    }
+    s.add_document(doc, None);
+    assert!(s.set_active(0));
+    assert!(s.set_active(1));
+    let actual = text(&s, id);
+    let expected = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &actual).bounds;
+    assert_eq!(actual.cached_bounds, Some(expected));
+}
+
+/// A loaded composite font cannot replace an installed family used by existing type.
+#[test]
+fn loaded_composite_font_cannot_take_an_installed_family_name() {
+    let mut s = session();
+    let id = s.execute("text.create", &json!({"x": 10, "y": 50, "text": "Ab", "size": 20, "font": "Inter"})).unwrap()["id"].as_u64().unwrap();
+    let mut doc = (*s.doc().unwrap().doc).clone();
+    doc.composite_fonts.push(vectorcraft_doc::CompositeFont::new("Inter", "Source Sans 3", "Regular"));
+    if let NodeKind::Text(t) = &mut doc.node_mut(NodeId(id)).unwrap().kind {
+        t.cached_bounds = None;
+    }
+    s.add_document(doc, None);
+    assert!(names(&s).is_empty());
+    assert!(vectorcraft_text::FontDb::global().composite_font("Inter").is_none());
+    let actual = text(&s, id);
+    let expected = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &actual).bounds;
+    assert_eq!(actual.cached_bounds, Some(expected));
+}
+
+/// A file's composite fonts that Composite Fonts… would refuse (a value out of range, a name used
+/// twice) are left out when the file opens.
+#[test]
+fn unusable_composite_fonts_in_a_file_are_left_out() {
+    let db = vectorcraft_text::FontDb::global();
+    let mut s = session();
+    let mut doc = (*s.doc().unwrap().doc).clone();
+    let mut wild = vectorcraft_doc::CompositeFont::new("CF Wild", "Source Sans 3", "Regular");
+    wild.parts.roman.size = 5000.0;
+    let good = vectorcraft_doc::CompositeFont::new("CF Kept", "Source Sans 3", "Regular");
+    let twice = vectorcraft_doc::CompositeFont::new("cf kept", "Inter", "Regular");
+    *doc.composite_fonts = vec![wild, good, twice];
+    s.add_document(doc, None);
+    assert_eq!(names(&s), ["CF Kept"]);
+    s.execute("document.activate", &json!({"index": 1})).unwrap();
+    assert!(db.composite_font("CF Wild").is_none());
+    assert_eq!(db.composite_font("CF Kept").unwrap().parts.roman.font, "Source Sans 3");
+}
+
+/// Export writes the document's composite fonts (all, or those named) to a file; Import reads it:
+/// with apply false it only returns them, otherwise they join the document's, replacing a font of
+/// the same name, as one undo step.
+#[test]
+fn composite_fonts_export_and_import() {
+    let dir = folder("io");
+    let path = dir.join("Mixed fonts (日本).vccomposite");
+    let path = path.to_str().unwrap();
+    let mut s = session();
+    assert!(s.execute("type.compositeFonts.export", &json!({"path": path})).is_err(), "nothing to export");
+    let mut slash = font("CF IO a/b: \"quoted\" 日本");
+    slash["parts"]["kana"] = json!({"font": "Inter", "vScale": 80, "scaleAtCenter": true});
+    s.execute("type.compositeFonts.set", &json!({"fonts": [slash, font("CF IO Other")]})).unwrap();
+    assert!(s.execute("type.compositeFonts.export", &json!({"path": path, "names": ["CF IO Nope"]})).is_err());
+    let r = s
+        .execute("type.compositeFonts.export", &json!({"path": path, "names": ["cf io a/b: \"quoted\" 日本", "CF IO a/b: \"quoted\" 日本"]}))
+        .unwrap();
+    assert_eq!(r["count"], 1);
+    let saved = s.doc().unwrap().doc.composite_fonts[0].clone();
+
+    let mut t = session();
+    let mut mine = font("CF IO a/b: \"quoted\" 日本");
+    mine["parts"]["roman"]["size"] = json!(90);
+    t.execute("type.compositeFonts.set", &json!({"fonts": [mine, font("CF IO Kept")]})).unwrap();
+    let before = steps(&t);
+    let read = t.execute("type.compositeFonts.import", &json!({"path": path, "apply": false})).unwrap();
+    assert_eq!(read["fonts"].as_array().map(Vec::len), Some(1));
+    assert_eq!(steps(&t), before);
+    t.execute("type.compositeFonts.import", &json!({"path": path})).unwrap();
+    assert_eq!(steps(&t), before + 1);
+    assert_eq!(names(&t), ["CF IO a/b: \"quoted\" 日本", "CF IO Kept"]);
+    assert_eq!(t.doc().unwrap().doc.composite_fonts[0], saved);
+    // The same file again changes nothing.
+    t.execute("type.compositeFonts.import", &json!({"path": path})).unwrap();
+    assert_eq!(steps(&t), before + 1);
+
+    // Files that aren't composite fonts, or are too large, are refused.
+    for (file, bytes) in [
+        ("bad.vccomposite", b"not json".to_vec()),
+        ("empty.vccomposite", br#"{"compositeFonts": []}"#.to_vec()),
+        ("twice.vccomposite", format!(r#"{{"compositeFonts": [{}, {}]}}"#, font("CF Dup"), font("cf dup")).into_bytes()),
+        ("large.vccomposite", vec![b' '; (4 << 20) + 1]),
+    ] {
+        let p = dir.join(file);
+        std::fs::write(&p, bytes).unwrap();
+        assert!(t.execute("type.compositeFonts.import", &json!({"path": p.to_str().unwrap()})).is_err(), "{file}");
+        assert_eq!(steps(&t), before + 1);
+    }
+    assert!(t.execute("type.compositeFonts.import", &json!({"path": path, "apply": "no"})).is_err());
+    assert!(t.execute("type.compositeFonts.import", &json!({"path": ""})).is_err());
+    assert!(t.execute("type.compositeFonts.import", &json!({"path": path, "data": "{}"})).is_err());
+    assert!(t.execute("type.compositeFonts.import", &json!({"dataBase64": "%%%"})).is_err());
+
+    // Without a path, Export gives the file's text, which Import takes as data.
+    let data = s.execute("type.compositeFonts.export", &json!({"names": ["CF IO Other"]})).unwrap();
+    assert_eq!(data["count"], 1);
+    let mut u = session();
+    let r = u.execute("type.compositeFonts.import", &json!({"data": data["data"]})).unwrap();
+    assert_eq!(r["imported"], json!(["CF IO Other"]));
+    assert_eq!(names(&u), ["CF IO Other"]);
+    // Fonts given are written in place of the document's; bad ones are refused.
+    let given = s.execute("type.compositeFonts.export", &json!({"fonts": [font("CF IO Given")]})).unwrap();
+    assert!(given["data"].as_str().unwrap().contains("CF IO Given"));
+    assert!(s.execute("type.compositeFonts.export", &json!({"fonts": [font("")]})).is_err());
+    assert!(s.execute("type.compositeFonts.export", &json!({"fonts": []})).is_err());
+    assert!(s.execute("type.compositeFonts.export", &json!({"path": " "})).is_err());
+    let _ = std::fs::remove_dir_all(&dir);
+}
diff --git a/crates/engine/src/cmd/create.rs b/crates/engine/src/cmd/create.rs
index 6860df149..407b20a1a 100644
--- a/crates/engine/src/cmd/create.rs
+++ b/crates/engine/src/cmd/create.rs
@@ -743,7 +743,7 @@ fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
     let mut made = super::typecmd::with_overflow(s, id.as_slice(), made);
     if p.get("font").is_some() || p.get("style").is_some() {
         let runs = match id.and_then(|i| s.doc().ok()?.doc.node(i)).map(|n| &n.kind) {
-            Some(NodeKind::Text(t)) => t.runs.iter().map(|r| super::fonts::font_of(&r.style)).collect(),
+            Some(NodeKind::Text(t)) => t.runs.iter().flat_map(super::fonts::run_fonts).collect(),
             _ => Default::default(),
         };
         if let Some(w) = super::fonts::set_font_warning(runs) {
diff --git a/crates/engine/src/cmd/docmenu.rs b/crates/engine/src/cmd/docmenu.rs
index 5b1b4300b..a475bc743 100644
--- a/crates/engine/src/cmd/docmenu.rs
+++ b/crates/engine/src/cmd/docmenu.rs
@@ -256,7 +256,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Document Color Mode",
             ["File", "Document Color Mode"],
             None,
-            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every color of the art (opacity masks, effect colors and graphs' series and label paints included), symbols, graph designs, pattern tiles, graphic styles (their effect colors included), brushes, swatches and the paints new art takes through the color settings, together in one undo step (Undo restores their original values; Redo reapplies the conversion); swatch links kept; Gray colors stay Gray, on the black plate), intent?, grays?: \"profile\" (default: RGB grays separate through the CMYK profile like any color, into four-color grays and a rich black) | \"black\" (to CMYK, RGB grays with R = G = B go on the black plate only, K = their gray value)} → {changed: how many colors of the art, symbols, graph designs and pattern tiles changed; the colors of graphic styles and brushes are not counted}",
+            "{mode: \"cmyk\"|\"rgb\", convert?: true (convert every color of the art (opacity masks, effect colors and graphs' series and label paints included), symbols, graph designs, pattern tiles, graphic styles (their effect colors included), brushes, swatches and the paints new art takes through the color settings, together in one undo step (Undo restores their original values; Redo reapplies the conversion); swatch links kept; Gray colors stay Gray, on the black plate), intent?, grays?: \"profile\" (default: RGB grays separate through the CMYK profile like any color, into light grays in cyan, magenta and yellow only, darker four-color grays and a rich black) | \"black\" (to CMYK, RGB grays with R = G = B go on the black plate only, K = their gray value)} → {changed: how many colors of the art, symbols, graph designs and pattern tiles changed; the colors of graphic styles and brushes are not counted}",
             has_doc,
             super::colormgmt::convert_mode
         ),
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 19c64859e..bf6b673ff 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -794,11 +794,14 @@ fn new_document_from_state(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
     let mut doc = Document::clone(chosen.as_ref().unwrap_or(&st.doc));
     let (imported_from, import_losses, opened_by) = (st.imported_from.clone(), st.import_losses.clone(), st.opened_by.clone());
-    if let Some(path) = st.path.as_deref() {
+    let base = super::links::LinkBase::of(st);
+    if base.doc.is_some() {
         // Files are looked for within the asking caller's roots, else within those of the caller that opened the source.
         let roots = crate::file_access::current().or_else(|| opened_by.clone());
-        crate::file_access::confine(roots.as_ref(), || super::links::with_found_paths(&mut doc, path));
+        crate::file_access::confine(roots.as_ref(), || super::links::with_found_paths(&mut doc, base));
     }
+    // The copy's links keep their relative paths, which name places from the same file.
+    let links_from = base.relative.map(str::to_string);
     doc.drop_edit_modes();
     if doc.pattern_edit.is_some() {
         super::patterncmds::finish_edit(&mut doc, &mut vectorcraft_doc::Selection::default())?;
@@ -815,6 +818,7 @@ fn new_document_from_state(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc_mut()?;
     st.imported_from = imported_from;
     st.import_losses = import_losses;
+    st.links_from = links_from;
     st.opened_by = st.opened_by.take().or(opened_by);
     st.mark_unsaved();
     Ok(json!({ "index": i, "title": st.title() }))
diff --git a/crates/engine/src/cmd/fileio/load.rs b/crates/engine/src/cmd/fileio/load.rs
index 7ff22689c..697f3c1d7 100644
--- a/crates/engine/src/cmd/fileio/load.rs
+++ b/crates/engine/src/cmd/fileio/load.rs
@@ -564,13 +564,14 @@ impl ReadFile {
 
 /// The first half of [`open_bytes_with`], which needs no session (an app may do it on another
 /// thread): read and decode the file, read its linked files and lay out its type → what
-/// [`open_read`] opens. The linked files are looked for from `path`, where the file was read from,
+/// [`open_read`] opens. Type in the file's composite fonts is measured again once the document
+/// opens and its composite fonts are registered. The linked files are looked for from `path`, where the file was read from,
 /// and modified ones are read again when `update_links` (Preferences › File Handling › Update
 /// Links set to Automatically; see [`crate::cmd::links::resolve`]).
 pub fn read_for_open(name: &str, bytes: &[u8], path: Option<String>, p: &Value, update_links: bool, low_res_proxy_eps: bool) -> Result<ReadFile> {
     let opts = LoadOptions::from_params("document.open", p)?;
     let mut loaded = load_with(name, bytes, &opts)?;
-    let links = crate::cmd::links::resolve(&mut loaded.doc, path.as_deref(), update_links, low_res_proxy_eps);
+    let links = crate::cmd::links::resolve(&mut loaded.doc, crate::cmd::links::LinkBase::file(path.as_deref()), update_links, low_res_proxy_eps);
     Session::refresh_text_bounds(&mut loaded.doc);
     Ok(ReadFile { loaded, opts, path, links })
 }
@@ -590,7 +591,8 @@ pub fn open_template(s: &mut Session, name: &str, bytes: &[u8], path: Option<&st
             "only this Affinity file's embedded preview could be read: use File › Open to see it with its warning, or export SVG or PDF from Affinity first",
         ));
     }
-    let links = crate::cmd::links::resolve(&mut loaded.doc, path, s.prefs.update_links == "automatically", s.prefs.low_res_proxy_eps);
+    let base = crate::cmd::links::LinkBase::file(path);
+    let links = crate::cmd::links::resolve(&mut loaded.doc, base, s.prefs.update_links == "automatically", s.prefs.low_res_proxy_eps);
     open_loaded(s, loaded, links, path.map(str::to_string), &LoadOptions::default(), true)
 }
 
@@ -629,6 +631,7 @@ fn open_loaded(s: &mut Session, loaded: Loaded, links: Resolved, path: Option<St
     // writes .ai that way).
     let partial = format.id == "pdf" && opts.is_partial();
     let lossy_ai = format.id == "ai" && !restored;
+    let read_from = path.clone();
     let path = path.filter(|_| !template && !partial && !lossy_ai && SAVE_FORMATS.contains(&format.id));
     let saves_back = path.is_some();
     let converted = saves_back && converted && s.prefs.append_converted;
@@ -648,6 +651,7 @@ fn open_loaded(s: &mut Session, loaded: Loaded, links: Resolved, path: Option<St
     st.converted = converted;
     st.imported_from = source_path;
     st.import_losses = losses;
+    st.links_from = read_from;
     let opened = &s.documents()[index];
     let (title, file_info_title) = (opened.title(), opened.doc.title.clone());
     Ok(super::merge(
diff --git a/crates/engine/src/cmd/fileio/save.rs b/crates/engine/src/cmd/fileio/save.rs
index 893b783bf..c4db832d2 100644
--- a/crates/engine/src/cmd/fileio/save.rs
+++ b/crates/engine/src/cmd/fileio/save.rs
@@ -777,7 +777,8 @@ fn job_for_stamped(s: &Session, st: &DocState, plan: SavePlan, stamped: Option<i
         stamp_doc_dates(Arc::make_mut(&mut snapshot), at);
     }
     // A native file records its links' paths relative to where it is written.
-    let relative = plan.path.as_deref().filter(|_| is_native(plan.format)).and_then(|p| crate::cmd::links::with_relative_paths(&own, p));
+    let base = crate::cmd::links::LinkBase::of(st);
+    let relative = plan.path.as_deref().filter(|_| is_native(plan.format)).and_then(|p| crate::cmd::links::with_relative_paths(&own, base, p));
     let doc = relative.map_or(own, Arc::new);
     let mut params = plan.options.clone();
     if is_svg(plan.format) {
diff --git a/crates/engine/src/cmd/fileio/tests_aiimport.rs b/crates/engine/src/cmd/fileio/tests_aiimport.rs
index 26e6bbc3d..8c1722a60 100644
--- a/crates/engine/src/cmd/fileio/tests_aiimport.rs
+++ b/crates/engine/src/cmd/fileio/tests_aiimport.rs
@@ -720,7 +720,7 @@ fn a_file_whose_pdf_part_cant_be_read_outlines_its_type_when_asked() {
     assert!(paths > 0, "the outlines are there: {r}");
 }
 
-/// An image too large to read from the editing data of a file whose PDF part can't be read is
+/// An image whose data is cut short in the editing data of a file whose PDF part can't be read is
 /// left out, and both notes say so.
 #[test]
 fn a_file_whose_pdf_part_cant_be_read_notes_an_image_left_out() {
@@ -729,7 +729,7 @@ fn a_file_whose_pdf_part_cant_be_read_notes_an_image_left_out() {
     let mut s = Session::new();
     let e = open(&mut s, name, &file, json!({"editingData": false})).unwrap_err().to_string();
     let r = open(&mut s, name, &file, json!({})).unwrap();
-    assert_eq!(r["warnings"], json!([unread_pdf_part(&e), "an image too large to read from the editing data was left out"]), "{r}");
+    assert_eq!(r["warnings"], json!([unread_pdf_part(&e), "an image whose data is cut short was left out"]), "{r}");
 }
 
 /// A copied file whose PDF part can't be read pastes the objects of its editing data when asked
diff --git a/crates/engine/src/cmd/fileio/tests_pdfedit.rs b/crates/engine/src/cmd/fileio/tests_pdfedit.rs
index a38e35e82..4a6f67143 100644
--- a/crates/engine/src/cmd/fileio/tests_pdfedit.rs
+++ b/crates/engine/src/cmd/fileio/tests_pdfedit.rs
@@ -932,25 +932,31 @@ fn gradients_and_patterns_come_back_from_the_editing_copy() {
     }
     let r = s.execute("document.export", &json!({"format": "ai", "aiVersion": 7})).unwrap();
     let legacy = load::load_with("art.ai", &b64(&r), &LoadOptions::default()).unwrap();
-    // Each gradient the art paints with, by its kind and its stops' places and colors to 5% (version
-    // 7 writes a gradient stroke as its filled outline, so the objects differ, and a spot color's
-    // tint through its CMYK equivalent, 2% off here).
+    // Each gradient the art paints with, by its kind and its stops' places, and its stops' colors
+    // within 5% (version 7 writes a gradient stroke as its filled outline, so the objects differ),
+    // except a spot color's tint, which version 7 writes through its CMYK equivalent: 70% of that
+    // equivalent displays about 7% off the tint of the spot color.
     let gradients = |doc: &vectorcraft_doc::Document| {
-        let mut all = std::collections::BTreeSet::new();
+        let mut all = std::collections::BTreeMap::new();
         doc.walk(|node| {
             for it in node.appearance.items.iter() {
                 if let vectorcraft_color::Paint::Gradient(g) = it.paint() {
-                    let stops: Vec<String> = g
-                        .gradient
-                        .stops
-                        .iter()
-                        .map(|s| format!("{:.3} {:?}", s.offset, s.color.to_rgb().map(|v| (v * 20.0).round() * 5.0)))
-                        .collect();
-                    all.insert(format!("{:?} {stops:?}", g.gradient.kind));
+                    let places: Vec<String> = g.gradient.stops.iter().map(|s| format!("{:.3}", s.offset)).collect();
+                    let colors: Vec<([f32; 3], bool)> =
+                        g.gradient.stops.iter().map(|s| (s.color.to_rgb(), s.swatch.is_some() && s.tint < 1.0)).collect();
+                    all.insert(format!("{:?} {places:?}", g.gradient.kind), colors);
                 }
             }
         });
         all
     };
-    assert_eq!(gradients(&legacy.doc), gradients(&before));
+    let (got, want) = (gradients(&legacy.doc), gradients(&before));
+    assert_eq!(got.keys().collect::<Vec<_>>(), want.keys().collect::<Vec<_>>());
+    for (key, stops) in &want {
+        for (i, (rgb, spot)) in stops.iter().enumerate() {
+            let back = got[key][i].0;
+            let most = if *spot { 0.1 } else { 0.05 };
+            assert!((0..3).all(|c| (back[c] - rgb[c]).abs() < most), "{key} stop {i}: {back:?} for {rgb:?}");
+        }
+    }
 }
diff --git a/crates/engine/src/cmd/fontfiles.rs b/crates/engine/src/cmd/fontfiles.rs
index cadbd6509..309347985 100644
--- a/crates/engine/src/cmd/fontfiles.rs
+++ b/crates/engine/src/cmd/fontfiles.rs
@@ -67,7 +67,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Missing Fonts",
             [],
             None,
-            "{} → {fonts: [{family, style, status: missing|substitute, resolved: {family, style}}] (sorted by name; at most 1000), count, fontsNextToDocument?} the fonts the active document's type uses, in its layers and its symbols, that aren't available as named: missing (the family is unknown and the fallback family stands in) or substitute (the family is there but not the style; resolved names the stand-in), as text.fonts says. CSS generic families such as sans-serif and names longer than 256 bytes are left out. fontsNextToDocument: the Fonts folder next to the saved document (File › Package writes it), when there is one and a search may start there (not in another app's folders, such as a mail app's attachments)",
+            "{} → {fonts: [{family, style, status: missing|substitute, resolved: {family, style}}] (sorted by name; at most 1000), count, fontsNextToDocument?} the fonts the active document's type uses, in its layers and its symbols (for type in a composite font, the fonts of the parts its characters are drawn in), that aren't available as named: missing (the family is unknown and the fallback family stands in) or substitute (the family is there but not the style; resolved names the stand-in), as text.fonts says. CSS generic families such as sans-serif and names longer than 256 bytes are left out. fontsNextToDocument: the Fonts folder next to the saved document (File › Package writes it), when there is one and a search may start there (not in another app's folders, such as a mail app's attachments)",
             has_doc,
             missing
         ),
@@ -103,8 +103,8 @@ pub struct MissingFont {
     pub resolved: Option<(String, String)>,
 }
 
-/// The fonts the type of `d` uses, in its layers and its symbols, that aren't available as named
-/// (sorted by family and style, each once whatever version its type names; at most 1000). CSS generic families such as `sans-serif`
+/// The fonts the type of `d` uses, in its layers and its symbols (a composite font's parts, those
+/// its characters are drawn in, in place of its name), that aren't available as named (sorted by family and style, each once whatever version its type names; at most 1000). CSS generic families such as `sans-serif`
 /// ([`GENERIC_FAMILIES`]) and names longer than 256 bytes are left out.
 pub fn missing_fonts(d: &Document) -> Vec<MissingFont> {
     let db = FontDb::global();
diff --git a/crates/engine/src/cmd/fonts.rs b/crates/engine/src/cmd/fonts.rs
index ba91f87fa..2a6d1cb0d 100644
--- a/crates/engine/src/cmd/fonts.rs
+++ b/crates/engine/src/cmd/fonts.rs
@@ -21,7 +21,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Fonts in Document",
             [],
             None,
-            "{selectionOnly?} (the type in the art of the symbols in scope included: all of the document's, or those the selected instances show) → [{family, style, runs, objects, missing, status: exact|substitute|missing, resolved: {family, style}, missingGlyphs, version?: the installed version the type names (when it names one)}] sorted by name. A font is found by any of its names (ヒラギノ角ゴシック = Hiragino Sans) among the loaded and installed fonts; substitute: the family is there but not the style (resolved names the stand-in); missing: the family is unknown (the fallback family stands in); missingGlyphs: characters of its text the resolved font lacks (drawn by a fallback font)",
+            "{selectionOnly?} (the type in the art of the symbols in scope included: all of the document's, or those the selected instances show) → [{family, style, runs, objects, missing, status: exact|substitute|missing, resolved: {family, style}, missingGlyphs, version?: the installed version the type names (when it names one)}] sorted by name. A font is found by any of its names (ヒラギノ角ゴシック = Hiragino Sans) among the loaded and installed fonts; substitute: the family is there but not the style (resolved names the stand-in); missing: the family is unknown (the fallback family stands in); missingGlyphs: characters of its text the resolved font lacks (drawn by a fallback font). For a composite font, status is the worst among the parts its characters are drawn in, and missingGlyphs counts the characters their part's font lacks",
             has_doc,
             fonts
         ),
@@ -30,7 +30,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Replace Font",
             [],
             None,
-            "{from: {family, style?}, to: {family (any of its names; stored as the font's own family name), style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style); the type in the art of the symbols in scope changes too (all of the document's, or those the selected instances show, so every instance of them follows); text that is hidden or locked, in a hidden or locked group or layer (or group of a symbol's art), or on a locked artboard keeps its font; when no run changes (text already set in the new font, or none to change), the document and its undo history stay as they are → {runs: the runs changed, skipped?: the text objects left in the font, warning?: text (some text was left in its font, or the style set isn't available: its type is drawn in the family's closest style)}",
+            "{from: {family, style?}, to: {family (any of its names; stored as the font's own family name, a composite font's as its own name), style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style); the type in the art of the symbols in scope changes too (all of the document's, or those the selected instances show, so every instance of them follows); text that is hidden or locked, in a hidden or locked group or layer (or group of a symbol's art), or on a locked artboard keeps its font; when no run changes (text already set in the new font, or none to change), the document and its undo history stay as they are → {runs: the runs changed, skipped?: the text objects left in the font, warning?: text (some text was left in its font, or the style set isn't available: its type is drawn in the family's closest style)}",
             has_doc,
             replace
         ),
@@ -208,7 +208,18 @@ pub(super) fn font_label((family, style, version): &UsedFont) -> String {
     }
 }
 
-/// The fonts (family, style, version) of the type in the layers and symbols of `d`.
+/// The fonts (family, style, version) run `r` is drawn in: its own, or, set in a composite font,
+/// the fonts of the parts its characters fall in ([`vectorcraft_text::FontDb::composite_fonts_for`]).
+pub(super) fn run_fonts(r: &TextRun) -> Vec<UsedFont> {
+    let parts = if r.inline.is_some() { None } else { vectorcraft_text::FontDb::global().composite_fonts_for(&r.style.font_family, &r.text) };
+    match parts {
+        Some(parts) => parts.into_iter().map(|(family, style)| (family, style, None)).collect(),
+        None => vec![font_of(&r.style)],
+    }
+}
+
+/// The fonts (family, style, version) the type in the layers and symbols of `d` is drawn in, a
+/// composite font's parts in place of its name ([`run_fonts`]).
 pub(super) fn used_fonts(d: &Document) -> BTreeSet<UsedFont> {
     art_fonts(d, &[])
 }
@@ -219,7 +230,7 @@ pub(super) fn art_fonts(d: &Document, art: &[Node]) -> BTreeSet<UsedFont> {
     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(), r.style.font_version.clone())));
+            fonts.extend(t.runs.iter().flat_map(run_fonts));
         }
     };
     d.walk(&mut add);
@@ -344,7 +355,7 @@ impl Printed<'_> {
                     self.overflow.insert(n.id);
                 }
                 for r in runs {
-                    self.fonts.insert((r.style.font_family.clone(), r.style.font_style.clone(), r.style.font_version.clone()));
+                    self.fonts.extend(run_fonts(r));
                     // Inline graphics draw their symbols' art.
                     if let Some(art) = &r.inline {
                         self.symbol(&art.symbol);
@@ -546,14 +557,15 @@ fn font_inventory(s: &Session, selected: Option<&[NodeId]>) -> Result<Value> {
     let symbols = if selected.is_some() { Some(selected_symbols(s, selected)?.0) } else { None };
     let mut texts: Vec<&TextObject> = ids.iter().filter_map(|id| text(d, *id)).collect();
     texts.extend(symbol_texts(d, symbols.as_ref()).into_iter().map(|(t, _)| t));
-    let mut found: BTreeMap<UsedFont, (usize, usize, String)> = BTreeMap::new();
+    // Each font's runs, objects and the text of its runs.
+    let mut found: BTreeMap<UsedFont, (usize, usize, Vec<&str>)> = BTreeMap::new();
     for t in texts {
         let mut seen = BTreeSet::new();
         for r in &t.runs {
             let font = (r.style.font_family.clone(), r.style.font_style.clone(), r.style.font_version.clone());
             let e = found.entry(font.clone()).or_default();
             e.0 += 1;
-            e.2.push_str(&r.text);
+            e.2.push(&r.text);
             if seen.insert(font) {
                 e.1 += 1;
             }
@@ -561,14 +573,27 @@ fn font_inventory(s: &Session, selected: Option<&[NodeId]>) -> Result<Value> {
     }
     let list: Vec<Value> = found
         .into_iter()
-        .map(|((family, style, version), (runs, objects, chars))| {
+        .map(|((family, style, version), (runs, objects, texts))| {
             // The face the type is set in: the version it names when that one is installed.
-            let resolved = db.resolve(&family, &style).map(|(f, m)| (db.face_version(&family, &style, version.as_deref()).unwrap_or(f), m));
-            let status = resolved.as_ref().map(|(_, m)| *m).unwrap_or(vectorcraft_text::FontMatch::Missing);
-            let mut lacking: Vec<char> = chars.chars().filter(|c| !c.is_whitespace() && !c.is_control()).collect();
-            lacking.sort_unstable();
-            lacking.dedup();
-            lacking.retain(|c| !resolved.as_ref().is_some_and(|(f, _)| f.covers(*c)));
+            let mut resolved = db.resolve(&family, &style).map(|(f, m)| (db.face_version(&family, &style, version.as_deref()).unwrap_or(f), m));
+            let (status, lacking) = match db.composite_coverage(&family, &texts) {
+                // A composite font: each character is drawn by the font of the part it falls in, and
+                // the row names the face of the first part that isn't there as named.
+                Some(c) => {
+                    if c.status != vectorcraft_text::FontMatch::Exact {
+                        resolved = c.face.map(|f| (f, c.status));
+                    }
+                    (c.status, c.lacking)
+                }
+                None => {
+                    let status = resolved.as_ref().map(|(_, m)| *m).unwrap_or(vectorcraft_text::FontMatch::Missing);
+                    let mut lacking: Vec<char> = texts.concat().chars().filter(|c| !c.is_whitespace() && !c.is_control()).collect();
+                    lacking.sort_unstable();
+                    lacking.dedup();
+                    lacking.retain(|c| !resolved.as_ref().is_some_and(|(f, _)| f.covers(*c)));
+                    (status, lacking)
+                }
+            };
             let mut row = json!({
                 "family": family, "style": style, "runs": runs, "objects": objects,
                 "missing": status == vectorcraft_text::FontMatch::Missing,
@@ -612,10 +637,11 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {
     let (ff, fs) = font_param(p, "from", C)?;
     let (tf, ts) = font_param(p, "to", C)?;
     let db = vectorcraft_text::FontDb::global();
-    // Any name of the family (ヒラギノ角ゴシック) is stored as its own name (Hiragino Sans).
-    let tf = match db.resolve(&tf, ts.as_deref().unwrap_or("Regular")) {
-        Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => f.family.clone(),
-        _ => return Err(bad(C, format!("font family `{tf}` is not available"))),
+    // Any name of the family (ヒラギノ角ゴシック) is stored as its own name (Hiragino Sans), and a
+    // composite font as its own name.
+    let composite = db.composite_font(&tf).is_some();
+    let Some(tf) = db.stored_family(&tf, ts.as_deref().unwrap_or("Regular")) else {
+        return Err(bad(C, format!("font family `{tf}` is not available")));
     };
     let matches = |st: &vectorcraft_doc::CharStyle| {
         st.font_family.eq_ignore_ascii_case(&ff) && fs.as_ref().is_none_or(|x| st.font_style.eq_ignore_ascii_case(x))
@@ -626,8 +652,10 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {
         if !matches(st) {
             return None;
         }
-        // An explicit style, else the closest the new family has to the old one.
-        let style = ts.clone().or_else(|| db.face(&tf, &st.font_style).map(|f| f.style.clone())).unwrap_or_else(|| st.font_style.clone());
+        // An explicit style, else the closest the new family has to the old one (a composite font's
+        // parts name their own styles: the run keeps its style).
+        let closest = || if composite { None } else { db.face(&tf, &st.font_style).map(|f| f.style.clone()) };
+        let style = ts.clone().or_else(closest).unwrap_or_else(|| st.font_style.clone());
         (st.font_family != tf || st.font_style != style || st.font_version.is_some() || !st.font_axes.is_empty()).then_some(style)
     };
     // Only text the Selection tool can reach changes: not hidden or locked, in a hidden or locked
@@ -674,7 +702,7 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {
                         // Another font: none of the old one's versions or Variable Font settings.
                         r.style.font_version = None;
                         r.style.font_axes.clear();
-                        set.insert(font_of(&r.style));
+                        set.extend(run_fonts(r));
                         changed = true;
                         n += 1;
                     }
diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs
index 6fe0746ac..cf7c9b6b2 100644
--- a/crates/engine/src/cmd/layer.rs
+++ b/crates/engine/src/cmd/layer.rs
@@ -601,7 +601,7 @@ fn set_current(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn highlight(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "layer.highlight";
-    let mut ids = ids_param(p, "ids").ok_or_else(|| bad(C, "missing ids"))?;
+    let mut ids = ids_param(p, "ids", C)?.ok_or_else(|| bad(C, "missing ids"))?;
     ids.truncate(MAX_ROWS);
     let mode = str_param(p, "mode").unwrap_or("set");
     let st = s.doc_mut()?;
@@ -740,7 +740,7 @@ enum Place {
 /// Drag rows in the Layers panel.
 fn move_rows(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "layer.move";
-    let mut ids = ids_param(p, "ids").or_else(|| id_param(p, "id").map(|i| vec![i])).ok_or_else(|| bad(C, "missing ids"))?;
+    let mut ids = ids_param(p, "ids", C)?.or_else(|| id_param(p, "id").map(|i| vec![i])).ok_or_else(|| bad(C, "missing ids"))?;
     ids.truncate(MAX_ROWS);
     let target = id_param(p, "target").ok_or_else(|| bad(C, "missing target"))?;
     let place = match str_param(p, "place").unwrap_or("inside") {
diff --git a/crates/engine/src/cmd/library.rs b/crates/engine/src/cmd/library.rs
index b4f570582..48e2d1793 100644
--- a/crates/engine/src/cmd/library.rs
+++ b/crates/engine/src/cmd/library.rs
@@ -966,7 +966,7 @@ enum Item {
 /// The selected objects (or `ids`) as a library graphic (its id and name set by the caller).
 fn graphic_of(s: &Session, p: &Value, cmd: &str) -> Result<LibraryGraphic> {
     let st = s.doc()?;
-    let ids = match ids_param(p, "ids") {
+    let ids = match ids_param(p, "ids", cmd)? {
         Some(ids) => ids,
         None => st.selection.in_paint_order(&st.doc),
     };
@@ -1006,7 +1006,7 @@ fn color_of(s: &Session, p: &Value, stroke: bool, cmd: &str) -> Result<NewColor>
         let given = NewColor { name: color.to_hex(), color, spot: None, tint: 1.0 };
         return Ok(spot_color(s, given, swatch, tint));
     }
-    match selected_paint(s, p, stroke)? {
+    match selected_paint(s, p, stroke, cmd)? {
         Paint::Solid { color, swatch, tint } => {
             let swatch = swatch.filter(|n| !n.is_empty());
             let name = swatch.clone().unwrap_or_else(|| color.to_hex());
@@ -1029,9 +1029,9 @@ fn spot_color(s: &Session, c: NewColor, swatch: Option<String>, tint: f32) -> Ne
 
 /// The first selected object's (or `ids`') fill (`stroke`: stroke) paint (type's: its first
 /// character's, as the proxy shows it), else the default one.
-fn selected_paint(s: &Session, p: &Value, stroke: bool) -> Result<Paint> {
+fn selected_paint(s: &Session, p: &Value, stroke: bool, cmd: &str) -> Result<Paint> {
     let st = s.doc()?;
-    let ids = match ids_param(p, "ids") {
+    let ids = match ids_param(p, "ids", cmd)? {
         Some(ids) => ids,
         None => st.selection.objects.clone(),
     };
@@ -1071,7 +1071,7 @@ fn gradient_of(s: &Session, p: &Value, stroke: bool, cmd: &str) -> Result<Librar
             let sw = s.doc()?.doc.swatch(name).filter(|w| matches!(w.paint, Paint::Gradient(_)));
             (Some(name.to_string()), sw.ok_or_else(|| bad(cmd, format!("no gradient swatch `{name}`")))?.paint.clone())
         }
-        None => (None, selected_paint(s, p, stroke)?),
+        None => (None, selected_paint(s, p, stroke, cmd)?),
     };
     let Paint::Gradient(mut g) = paint else {
         return Err(bad(cmd, if stroke { "the selection has no gradient stroke" } else { "the selection has no gradient fill" }));
@@ -1094,7 +1094,7 @@ fn pattern_of(s: &Session, p: &Value, stroke: bool, cmd: &str) -> Result<Library
             _ if d.pattern(name).is_some() => name.to_string(),
             _ => return Err(bad(cmd, format!("no pattern swatch `{name}`"))),
         },
-        None => match selected_paint(s, p, stroke)? {
+        None => match selected_paint(s, p, stroke, cmd)? {
             Paint::Pattern { pattern, .. } => pattern,
             _ => return Err(bad(cmd, if stroke { "the selection has no pattern stroke" } else { "the selection has no pattern fill" })),
         },
diff --git a/crates/engine/src/cmd/links.rs b/crates/engine/src/cmd/links.rs
index 28d8be2ee..22d61723e 100644
--- a/crates/engine/src/cmd/links.rs
+++ b/crates/engine/src/cmd/links.rs
@@ -23,7 +23,7 @@
 
 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet};
-use std::path::{Component, Path};
+use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 
 use serde_json::{Value, json};
@@ -219,6 +219,30 @@ struct Found {
     modified: Option<u64>,
     /// Read when telling whether it changed needed them.
     bytes: Option<Vec<u8>>,
+    /// `path` relative to the folder of [`LinkBase::relative`], when [`locate`] had that file.
+    relative: Option<Option<String>>,
+}
+
+/// The files a document's links are looked for from: `doc`, whose folder a link's path is followed
+/// from and its file is looked for by name in, and `relative`, the file its links' stored relative
+/// paths name places from (the file the document was read from).
+#[derive(Clone, Copy, Debug, Default)]
+pub struct LinkBase<'a> {
+    pub doc: Option<&'a str>,
+    pub relative: Option<&'a str>,
+}
+
+impl<'a> LinkBase<'a> {
+    /// Both the file at `path`.
+    pub fn file(path: Option<&'a str>) -> Self {
+        Self { doc: path, relative: path }
+    }
+
+    /// The open document `st`'s. One with no file of its own looks beside the file it was read from.
+    pub(crate) fn of(st: &'a crate::DocState) -> Self {
+        let (path, from) = (st.path.as_deref(), st.links_from.as_deref());
+        Self { doc: path.or(from), relative: from.or(path) }
+    }
 }
 
 impl Found {
@@ -237,7 +261,17 @@ impl Found {
 
     /// [`Self::link`] with the bytes' hash already taken.
     fn link_hashed(&self, hash: String, base: &LinkInfo) -> LinkInfo {
-        LinkInfo { path: self.path.clone(), size: Some(self.size), modified: self.modified, hash: Some(hash), ..base.clone() }
+        LinkInfo { size: Some(self.size), modified: self.modified, hash: Some(hash), ..self.moved(base) }
+    }
+
+    /// `base` pointing at this file. A file found away from `base`'s path takes its relative path
+    /// from where it was found.
+    fn moved(&self, base: &LinkInfo) -> LinkInfo {
+        let relative = match &self.relative {
+            Some(found) if self.path != base.path => found.clone(),
+            _ => base.relative.clone(),
+        };
+        LinkInfo { path: self.path.clone(), relative, ..base.clone() }
     }
 }
 
@@ -255,15 +289,41 @@ pub(crate) fn link_info(path: &str, bytes: &[u8]) -> LinkInfo {
 /// The file at `path` when there is one.
 fn found_at(path: String) -> Option<Found> {
     let (size, modified) = file_stamp(&path)?;
-    Some(Found { path, size, modified, bytes: None })
+    Some(Found { path, size, modified, bytes: None, relative: None })
 }
 
-/// Where the file of `link` (stored in the document saved at `doc_path`) is: at its path, else at
-/// its relative path or by name in the document's folder. Only paths
-/// [`fileio::document_path`] follows are looked at.
-fn locate(link: &LinkInfo, doc_path: Option<&str>) -> Option<Found> {
-    let stored = [Some(link.path.as_str()), link.relative.as_deref(), Some(link.name())];
-    stored.into_iter().flatten().filter_map(|p| fileio::document_path(p, doc_path).ok()).find_map(found_at)
+/// Where the file of `link` (of a document looking from `base`) is: at its path, else at its
+/// relative path from the folder of [`LinkBase::relative`], then from the document's folder, else
+/// by name in the document's folder, then in that of [`LinkBase::relative`]. Only paths
+/// [`fileio::document_path`] follows from the document's own file are looked at.
+fn locate(link: &LinkInfo, base: LinkBase) -> Option<Found> {
+    let (relative, other) = (link.relative.as_deref(), base.doc != base.relative);
+    let stored = [
+        (Some(link.path.as_str()), base.doc),
+        (relative, base.relative),
+        (relative.filter(|_| other), base.doc),
+        (Some(link.name()), base.doc),
+        (other.then_some(link.name()), base.relative),
+    ];
+    let mut f = stored.into_iter().filter_map(|(p, from)| follow_from(p?, from, base.doc, fileio::document_path)).find_map(found_at)?;
+    f.relative = base.relative.map(|from| {
+        let from = absolute_path(from);
+        Path::new(&from).parent().and_then(|dir| relative_path(Path::new(&f.path), dir))
+    });
+    Some(f)
+}
+
+/// The place `stored` names from the file `from`, as `resolve` ([`fileio::document_path`]) follows
+/// it, when it also follows that place from the document's own file `doc`: a network share the
+/// document is no longer on is refused.
+pub(crate) fn follow_from(
+    stored: &str,
+    from: Option<&str>,
+    doc: Option<&str>,
+    resolve: impl Fn(&str, Option<&str>) -> std::result::Result<String, craft_docpath::Refused>,
+) -> Option<String> {
+    let path = resolve(stored, from).ok()?;
+    if from == doc { Some(path) } else { resolve(&path, doc).ok() }
 }
 
 /// Why the path of `link` (stored in the document saved at `doc_path`) isn't followed, when it
@@ -272,10 +332,10 @@ fn refused(link: &LinkInfo, doc_path: Option<&str>) -> Option<craft_docpath::Ref
     fileio::document_path(&link.path, doc_path).err().filter(|r| *r != craft_docpath::Refused::Invalid)
 }
 
-/// Where the file of group `g` (of the document saved at `doc_path`) is and whether it still has
+/// Where the file of group `g` (of a document looking from `base`) is and whether it still has
 /// the content shown. Its bytes are read only when its size or modification time changed.
-fn probe(g: &Group, doc_path: Option<&str>) -> (Status, Option<Found>) {
-    let Some(mut f) = locate(&g.link, doc_path) else { return (Status::Missing, None) };
+fn probe(g: &Group, base: LinkBase) -> (Status, Option<Found>) {
+    let Some(mut f) = locate(&g.link, base) else { return (Status::Missing, None) };
     let l = &g.link;
     if l.size == Some(f.size) && l.modified.is_some() && l.modified == f.modified {
         return (Status::Ok, Some(f));
@@ -328,9 +388,9 @@ pub(crate) struct LinkedFile {
     pub bytes: Option<Vec<u8>>,
 }
 
-/// Every file the linked images of `d` (saved at `doc_path`) show, in the layers, symbols and
+/// Every file the linked images of `d` (looking from `base`) show, in the layers, symbols and
 /// patterns, once each.
-pub(crate) fn linked_files(d: &Document, doc_path: Option<&str>) -> Vec<LinkedFile> {
+pub(crate) fn linked_files(d: &Document, base: LinkBase) -> Vec<LinkedFile> {
     let mut seen = std::collections::BTreeSet::new();
     groups(d, None)
         .into_iter()
@@ -338,7 +398,7 @@ pub(crate) fn linked_files(d: &Document, doc_path: Option<&str>) -> Vec<LinkedFi
         .map(|g| {
             let named = fileio::format_for_name(g.link.name()).or_else(|| fileio::readable_format_for_name(g.link.name()));
             let own = |b: &&ImageBlob| !b.is_proxy() && named.is_some_and(|f| f.mime == b.mime);
-            let found = locate(&g.link, doc_path);
+            let found = locate(&g.link, base);
             let found_path = found.as_ref().map(|f| f.path.clone());
             let bytes = found.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(), found_path, bytes }
@@ -348,7 +408,7 @@ pub(crate) fn linked_files(d: &Document, doc_path: Option<&str>) -> Vec<LinkedFi
 
 /// `d` for output: linked raster images that still show only their saved preview read their files
 /// again (Preferences › Use Low Resolution Proxy for Linked EPS keeps the preview on screen only).
-pub(crate) fn full_linked_images<'a>(d: &'a Document, doc_path: Option<&str>) -> (Cow<'a, Document>, Vec<String>) {
+pub(crate) fn full_linked_images<'a>(d: &'a Document, base: LinkBase) -> (Cow<'a, Document>, Vec<String>) {
     let mut keys = BTreeSet::new();
     d.visit_images(|_, im| {
         if im.link.is_some() && d.images.get(&im.key).is_some_and(ImageBlob::is_proxy) {
@@ -363,7 +423,7 @@ pub(crate) fn full_linked_images<'a>(d: &'a Document, doc_path: Option<&str>) ->
     let all = groups(d, None);
     for key in keys {
         let Some(g) = all.iter().find(|g| g.document.is_none() && g.key == key) else { continue };
-        let Some(mut f) = locate(&g.link, doc_path) else {
+        let Some(mut f) = locate(&g.link, base) else {
             previews.insert(key);
             continue;
         };
@@ -398,7 +458,7 @@ pub(crate) fn full_linked_images<'a>(d: &'a Document, doc_path: Option<&str>) ->
 pub(crate) fn files_to_find(st: &crate::DocState, ids: Option<&[NodeId]>) -> Vec<(LinkInfo, Vec<NodeId>)> {
     groups(&st.doc, ids)
         .into_iter()
-        .filter(|g| !g.ids.is_empty() && (ids.is_some() || probe(g, st.path.as_deref()).0 == Status::Missing))
+        .filter(|g| !g.ids.is_empty() && (ids.is_some() || probe(g, LinkBase::of(st)).0 == Status::Missing))
         .map(|g| (g.link, g.ids))
         .collect()
 }
@@ -847,13 +907,13 @@ impl Resolved {
     }
 }
 
-/// The linked files of document `d`, just read from `doc_path`: those found unchanged are read
-/// again (their images had the preview), modified ones are read again when `update`, links found
-/// away from their path take the new path. A link nothing is known of whose image, or placed
+/// The linked files of document `d`, just read and looking from `base`: those found unchanged are
+/// read again (their images had the preview), modified ones are read again when `update`, links
+/// found away from their path take the new path. A link nothing is known of whose image, or placed
 /// document, shows a preview (a file another app wrote kept only that) was never read: its file is
 /// read now, into the object's bounds, which isn't a change to report. A placed document whose
 /// file's bytes are gone isn't showing a preview. Nothing here is an undo step.
-pub fn resolve(d: &mut Document, doc_path: Option<&str>, update: bool, low_res_proxy_eps: bool) -> Resolved {
+pub fn resolve(d: &mut Document, base: LinkBase, update: bool, low_res_proxy_eps: bool) -> Resolved {
     let mut out = Resolved::default();
     // The image (with its preview) and hash of each file read for a preview here, by path: images
     // of other keys linking to the same file share them, rather than each reading, decoding and
@@ -863,14 +923,14 @@ pub fn resolve(d: &mut Document, doc_path: Option<&str>, update: bool, low_res_p
     // away from its path or read again.
     let mut moved: Vec<(String, String, bool, LinkInfo)> = vec![];
     for g in groups(d, None) {
-        let row = rows(std::iter::once(&g), doc_path);
+        let row = rows(std::iter::once(&g), base.doc);
         let shows_preview = match g.document {
             None => previewing(d, &g.key),
             Some(_) => d.images.get(&g.key).is_some_and(ImageBlob::is_proxy),
         };
         let unread = g.link.hash.is_none() && g.link.size.is_none() && shows_preview;
         let eps_preview = keep_eps_preview(low_res_proxy_eps, &g, d);
-        match probe(&g, doc_path) {
+        match probe(&g, base) {
             (Status::Missing, _) => out.missing.extend(row),
             (Status::Modified, Some(mut f)) if update || unread => {
                 let force = unread.then_some(Preserve::Bounds);
@@ -894,7 +954,7 @@ pub fn resolve(d: &mut Document, doc_path: Option<&str>, update: bool, low_res_p
                     None => {
                         let link = match f.bytes.take() {
                             Some(b) => f.link(&b, &g.link),
-                            None => LinkInfo { path: f.path.clone(), ..g.link.clone() },
+                            None => f.moved(&g.link),
                         };
                         if link != g.link {
                             set_links(d, &g.ids, &link);
@@ -932,7 +992,7 @@ pub fn resolve(d: &mut Document, doc_path: Option<&str>, update: bool, low_res_p
                 // Found away from its path, or read again: the link follows.
                 let link = match &bytes {
                     Some(b) => f.link(b, &g.link),
-                    None => LinkInfo { path: f.path.clone(), ..g.link.clone() },
+                    None => f.moved(&g.link),
                 };
                 if link != g.link {
                     set_links(d, &g.ids, &link);
@@ -1035,42 +1095,68 @@ fn relative_path(target: &Path, base: &Path) -> Option<String> {
     Some(ups.chain(rest).collect::<Vec<std::borrow::Cow<str>>>().join("/"))
 }
 
-/// `d` as saved to `dest`: the links' paths relative to its folder written in; `None` when they
-/// are already. Links in the layers, symbols, graph designs, patterns and opacity masks are all set.
-pub fn with_relative_paths(d: &Document, dest: &str) -> Option<Document> {
-    let dest = absolute_path(dest);
-    let dir = Path::new(&dest).parent()?;
-    let relative = |l: &LinkInfo| relative_path(Path::new(&l.path), dir);
-    let outdated = |l: &LinkInfo| relative(l) != l.relative;
-    let mut changed = false;
-    d.visit_images(|_, im| changed |= im.link.as_ref().is_some_and(outdated));
-    d.visit_placed(|_, p| changed |= outdated(&p.link));
-    if !changed {
-        return None;
+/// The file `link` (of a document looking from `base`) is written relative to: where [`locate`]
+/// finds it, else the place its relative path names from the folder of [`LinkBase::relative`],
+/// else its path.
+fn link_target(link: &LinkInfo, base: LinkBase) -> PathBuf {
+    if let Some(f) = locate(link, base) {
+        return PathBuf::from(f.path);
+    }
+    match (base.relative, link.relative.as_deref()) {
+        (Some(_), Some(rel)) => fileio::document_path(rel, base.relative).map_or_else(|_| PathBuf::from(&link.path), PathBuf::from),
+        _ => PathBuf::from(&link.path),
     }
-    let mut d = d.clone();
-    d.update_links_where(outdated, |l| l.relative = relative(l));
-    Some(d)
 }
 
-/// Sets each link of `d`, a copy of the document saved at `doc_path` that has no file of its own,
-/// to the path where that document finds its file, so the copy finds the same files.
-/// Links in the layers, symbols, graph designs, patterns and opacity masks are all set.
-pub(crate) fn with_found_paths(d: &mut Document, doc_path: &str) {
-    // The new path of each link by what `locate` reads of it: its path, relative path and name.
-    let mut found: BTreeMap<(String, Option<String>), Option<String>> = BTreeMap::new();
+/// `d` (looking from `base`) as saved to `dest`: the links' paths relative to its folder written
+/// in; `None` when they are already. A link whose file is not at its path is written relative to
+/// where its file is found, else to the place its relative path names. Links in the layers,
+/// symbols, graph designs, patterns and opacity masks are all set.
+pub fn with_relative_paths(d: &Document, base: LinkBase, dest: &str) -> Option<Document> {
+    let dest = absolute_path(dest);
+    let dir = Path::new(&dest).parent()?;
+    // The relative path of each link by its path and stored relative path, each file looked at once.
+    let mut wanted: BTreeMap<(String, Option<String>), Option<String>> = BTreeMap::new();
     let mut look = |l: &LinkInfo| {
-        found.entry((l.path.clone(), l.relative.clone())).or_insert_with(|| locate(l, Some(doc_path)).map(|f| f.path));
+        wanted.entry((l.path.clone(), l.relative.clone())).or_insert_with(|| relative_path(&link_target(l, base), dir));
     };
     d.visit_images(|_, im| im.link.iter().for_each(&mut look));
     d.visit_placed(|_, p| look(&p.link));
-    found.retain(|(path, _), f| f.as_ref().is_some_and(|f| f != path));
+    wanted.retain(|(_, stored), rel| rel != stored);
+    if wanted.is_empty() {
+        return None;
+    }
+    let key = |l: &LinkInfo| (l.path.clone(), l.relative.clone());
+    let mut d = d.clone();
+    d.update_links_where(|l| wanted.contains_key(&key(l)), |l| l.relative = wanted.get(&key(l)).cloned().flatten());
+    Some(d)
+}
+
+/// Sets each link of `d`, a copy of a document looking from `base`, to the path where that
+/// document finds its file, and its relative path to it as that document's links have them, so
+/// the copy finds the same files. Links in the layers, symbols, graph designs, patterns and opacity
+/// masks are all set.
+pub(crate) fn with_found_paths(d: &mut Document, base: LinkBase) {
+    // The new path and relative path of each link by what `locate` reads of it: its path, relative
+    // path and name.
+    type PathAndRelative = (String, Option<String>);
+    let mut found: BTreeMap<PathAndRelative, Option<PathAndRelative>> = BTreeMap::new();
+    let mut look = |l: &LinkInfo| {
+        found.entry((l.path.clone(), l.relative.clone())).or_insert_with(|| {
+            let moved = locate(l, base)?.moved(l);
+            Some((moved.path, moved.relative))
+        });
+    };
+    d.visit_images(|_, im| im.link.iter().for_each(&mut look));
+    d.visit_placed(|_, p| look(&p.link));
+    found.retain(|(path, _), f| f.as_ref().is_some_and(|(f, _)| f != path));
     if found.is_empty() {
         return;
     }
     d.update_links(|l| {
-        if let Some(Some(f)) = found.get(&(l.path.clone(), l.relative.clone())) {
-            l.path = f.clone();
+        if let Some(Some((path, relative))) = found.get(&(l.path.clone(), l.relative.clone())) {
+            l.path = path.clone();
+            l.relative = relative.clone();
         }
     });
 }
@@ -1079,15 +1165,15 @@ pub(crate) fn with_found_paths(d: &mut Document, doc_path: &str) {
 
 fn check(s: &mut Session, p: &Value) -> Result<Value> {
     let st = s.doc()?;
-    let ids = ids_param(p, "ids");
+    let ids = ids_param(p, "ids", "links.check")?;
     let (mut missing, mut modified) = (0, 0);
     let mut links = vec![];
     for g in groups(&st.doc, ids.as_deref()).iter().filter(|g| !g.ids.is_empty()) {
-        let (status, found) = probe(g, st.path.as_deref());
+        let (status, found) = probe(g, LinkBase::of(st));
         missing += usize::from(status == Status::Missing);
         modified += usize::from(status == Status::Modified);
         let mut row = json!({ "name": g.link.name(), "path": g.link.path, "status": status.as_str(), "ids": ids_json(&g.ids) });
-        note_refused(&mut row, &g.link, st.path.as_deref());
+        note_refused(&mut row, &g.link, LinkBase::of(st).doc);
         if let Some(f) = found.filter(|f| f.path != g.link.path) {
             row["found"] = json!(f.path);
         }
@@ -1100,7 +1186,7 @@ fn check(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn update(s: &mut Session, p: &Value) -> Result<Value> {
-    update_where(s, ids_param(p, "ids"), None)
+    update_where(s, ids_param(p, "ids", "links.update")?, None)
 }
 
 /// Update Links in the active document of `s` for objects `ids` (default: the linked files that
@@ -1112,7 +1198,7 @@ fn update_where(s: &mut Session, ids: Option<Vec<NodeId>>, path: Option<&str>) -
     let (mut reads, mut missing) = (vec![], vec![]);
     let asked = ids.is_some() || path.is_some();
     for g in groups(&st.doc, ids.as_deref()).into_iter().filter(|g| path.is_none_or(|p| g.document.is_some() && g.link.path == p)) {
-        match probe(&g, st.path.as_deref()) {
+        match probe(&g, LinkBase::of(st)) {
             (Status::Missing, _) | (_, None) => missing.extend(ids_json(&g.ids)),
             // Unchanged and showing the file: nothing to read unless asked for.
             (Status::Ok, Some(_)) if !asked && !stale(&st.doc, &g) => {}
@@ -1225,14 +1311,14 @@ fn relink(s: &mut Session, p: &Value) -> Result<Value> {
             _ => None,
         })
     };
-    let mut ids: Vec<NodeId> = match (&each, ids_param(p, "ids")) {
+    let mut ids: Vec<NodeId> = match (&each, ids_param(p, "ids", C)?) {
         (Some(each), _) => each.iter().flat_map(|(ids, _)| ids.iter().copied()).collect(),
         (None, Some(ids)) => ids,
         (None, None) => {
             let selected: Vec<NodeId> = st.selection.objects.iter().copied().filter(|id| image(id).is_some()).collect();
             match folder_param {
                 Some(_) if selected.is_empty() => {
-                    groups(&st.doc, None).into_iter().filter(|g| probe(g, st.path.as_deref()).0 == Status::Missing).flat_map(|g| g.ids).collect()
+                    groups(&st.doc, None).into_iter().filter(|g| probe(g, LinkBase::of(st)).0 == Status::Missing).flat_map(|g| g.ids).collect()
                 }
                 _ => selected,
             }
@@ -1368,7 +1454,7 @@ fn missing_in_folder(
     let Some(dir) = files.first().and_then(|(_, p)| Path::new(p).parent()).map(Path::to_path_buf) else { return };
     for g in groups(&st.doc, None).into_iter().filter(|g| !(images_only && g.document.is_some())) {
         let rest: Vec<NodeId> = g.ids.iter().copied().filter(|id| !given.contains(id)).collect();
-        if rest.is_empty() || probe(&g, st.path.as_deref()).0 != Status::Missing {
+        if rest.is_empty() || probe(&g, LinkBase::of(st)).0 != Status::Missing {
             continue;
         }
         let found = absolute_path(&dir.join(g.link.name()).to_string_lossy());
@@ -1482,7 +1568,7 @@ fn linked_param(st: &crate::DocState, p: &Value, cmd: &str) -> Result<NodeId> {
 pub(crate) fn statuses(st: &crate::DocState) -> BTreeMap<NodeId, (Status, Option<String>, bool)> {
     let mut out = BTreeMap::new();
     for g in groups(&st.doc, None).iter().filter(|g| !g.ids.is_empty()) {
-        let (status, found) = probe(g, st.path.as_deref());
+        let (status, found) = probe(g, LinkBase::of(st));
         let found = found.map(|f| f.path).filter(|p| *p != g.link.path);
         let preview = stale(&st.doc, g);
         out.extend(g.ids.iter().map(|id| (*id, (status, found.clone(), preview))));
@@ -1603,7 +1689,7 @@ fn embed(s: &mut Session, p: &Value) -> Result<Value> {
         Some(NodeKind::PlacedDocument(_)) => true,
         _ => false,
     };
-    let ids = ids_param(p, "ids").unwrap_or_else(|| st.selection.objects.iter().copied().filter(linked).collect());
+    let ids = ids_param(p, "ids", C)?.unwrap_or_else(|| st.selection.objects.iter().copied().filter(linked).collect());
     if let Some(id) = ids.iter().find(|id| !matches!(kind(id), Some(NodeKind::Image(_) | NodeKind::PlacedDocument(_)))) {
         return Err(bad(C, format!("object {} is not an image or a placed document", id.0)));
     }
@@ -1625,7 +1711,7 @@ fn embed(s: &mut Session, p: &Value) -> Result<Value> {
             done.extend(g.ids);
             continue;
         }
-        match probe(&g, st.path.as_deref()) {
+        match probe(&g, LinkBase::of(st)) {
             (Status::Ok | Status::Modified, Some(mut f)) => match read_image(&mut f, &g.link) {
                 Ok(read) => {
                     done.extend(&g.ids);
@@ -1714,8 +1800,9 @@ fn file_fields(st: &crate::DocState, id: NodeId, l: &LinkInfo, out: &mut Value)
 }
 
 fn file_fields_here(st: &crate::DocState, id: NodeId, l: &LinkInfo, out: &mut Value) {
-    let status = groups(&st.doc, Some(&[id])).first().map_or(Status::Missing, |g| probe(g, st.path.as_deref()).0);
-    let doc_path = st.path.as_deref();
+    let base = LinkBase::of(st);
+    let status = groups(&st.doc, Some(&[id])).first().map_or(Status::Missing, |g| probe(g, base).0);
+    let doc_path = base.doc;
     let path = fileio::document_path(&l.path, doc_path).ok();
     let stamp = path.as_deref().and_then(file_stamp);
     out["status"] = json!(status.as_str());
@@ -1792,7 +1879,8 @@ fn info(s: &mut Session, p: &Value) -> Result<Value> {
 fn placement_options(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "links.placementOptions";
     let st = s.doc()?;
-    let ids = ids_param(p, "ids").unwrap_or_else(|| st.selection.objects.iter().copied().filter(|id| placement_of(&st.doc, *id).is_some()).collect());
+    let ids =
+        ids_param(p, "ids", C)?.unwrap_or_else(|| st.selection.objects.iter().copied().filter(|id| placement_of(&st.doc, *id).is_some()).collect());
     if let Some(id) = ids.iter().find(|id| placement_of(&st.doc, **id).is_none()) {
         return Err(bad(C, format!("object {} is not an image or a linked file", id.0)));
     }
diff --git a/crates/engine/src/cmd/object/transform.rs b/crates/engine/src/cmd/object/transform.rs
index 7940fc879..ae45f4d97 100644
--- a/crates/engine/src/cmd/object/transform.rs
+++ b/crates/engine/src/cmd/object/transform.rs
@@ -114,7 +114,7 @@ fn apply_transform_moving_guides(
     let c = xf.as_coeffs();
     let is_translation = (c[0] - 1.0).abs() < 1e-9 && c[1].abs() < 1e-9 && c[2].abs() < 1e-9 && (c[3] - 1.0).abs() < 1e-9;
     let delta = guides.unwrap_or(Vec2::new(c[4], c[5]));
-    let with_guides = objects && ids_param(p, "ids").is_none() && is_translation;
+    let with_guides = objects && p.get("ids").is_none_or(Value::is_null) && is_translation;
     let has_guides = with_guides && !s.doc()?.selection.guides.is_empty();
     // A transform of ids that name no object, or an identity transform without a copy, moves
     // nothing: the document and its undo history stay as they are, and Transform Again repeats it.
@@ -254,7 +254,7 @@ pub(super) fn transform(s: &mut Session, p: &Value) -> Result<Value> {
     if p.get("ids").is_none() && crate::cmd::brushsym::selected_part(s)?.is_some() {
         return Ok(json!({ "warning": crate::cmd::brushsym::part_only().to_string() }));
     }
-    let (ids, anchors) = match ids_param(p, "ids") {
+    let (ids, anchors) = match ids_param(p, "ids", "object.transform")? {
         Some(v) => (outermost(&s.doc()?.doc, v), false),
         None => (selected_roots_to_transform(s)?, bool_or(p, "anchors", false)),
     };
diff --git a/crates/engine/src/cmd/opacitymask.rs b/crates/engine/src/cmd/opacitymask.rs
index b8b0138c5..9d81576b0 100644
--- a/crates/engine/src/cmd/opacitymask.rs
+++ b/crates/engine/src/cmd/opacitymask.rs
@@ -210,7 +210,7 @@ fn make(s: &mut Session, p: &Value) -> Result<Value> {
         Some(id) => Err(bad(C, format!("object {} is hidden or locked, or on a locked artboard", id.0))),
         None => Ok(()),
     };
-    let mut ids = match ids_param(p, "ids") {
+    let mut ids = match ids_param(p, "ids", C)? {
         Some(ids) => {
             if let Some(id) = ids.iter().find(|id| d.node(**id).is_none()) {
                 return Err(EngineError::NoNode(*id));
diff --git a/crates/engine/src/cmd/overprint.rs b/crates/engine/src/cmd/overprint.rs
index 7cab59481..7906a68e8 100644
--- a/crates/engine/src/cmd/overprint.rs
+++ b/crates/engine/src/cmd/overprint.rs
@@ -229,7 +229,7 @@ pub(crate) fn overprint_black(s: &mut Session, p: &Value) -> Result<Value> {
         rich: bool_or(p, "includeCmyBlacks", false),
         spot: bool_or(p, "includeSpotBlacks", false),
     };
-    let ids = match ids_param(p, "ids") {
+    let ids = match ids_param(p, "ids", "edit.colors.overprintBlack")? {
         Some(v) => v,
         None => selected_roots(s)?,
     };
diff --git a/crates/engine/src/cmd/package.rs b/crates/engine/src/cmd/package.rs
index e102bf1f7..673ad2cbb 100644
--- a/crates/engine/src/cmd/package.rs
+++ b/crates/engine/src/cmd/package.rs
@@ -13,6 +13,7 @@ use vectorcraft_doc::{Document, LinkInfo};
 use serde_json::{Value, json};
 
 use super::fileio::{create_dir, write_file};
+use super::links::LinkBase;
 use super::{CommandSpec, Result, Session, bad, bool_or, cmd, has_doc, str_param, unique_name};
 
 const C: &str = "file.package";
@@ -187,8 +188,18 @@ impl<'a> Collector<'a> {
     }
 
     /// Collects the files `doc` links. `by_name`: `doc` is a placed `.ai` file's editing data,
-    /// whose links are not rewritten, so its copy finds them by name beside it.
-    fn collect(&mut self, doc: &mut Document, source: &str, destination: &str, depth: usize, by_name: bool) -> Result<()> {
+    /// whose links are not rewritten, so its copy finds them by name beside it. `lookup`: the
+    /// document whose links (with the same paths as `doc`'s) are looked for, and where from, when
+    /// not `doc` from `source`.
+    fn collect(
+        &mut self,
+        doc: &mut Document,
+        source: &str,
+        destination: &str,
+        depth: usize,
+        by_name: bool,
+        lookup: Option<(&Document, LinkBase)>,
+    ) -> Result<()> {
         // The caller checks cycles and depth before descending; active documents have
         // a destination reserved so back-links can point at their single packaged copy.
         self.visiting.insert(source.to_string(), destination.to_string());
@@ -210,6 +221,10 @@ impl<'a> Collector<'a> {
         // The fonts of the type on the PDF and `.ai` pages placed linked.
         let mut placed_fonts = BTreeSet::new();
         let mut placed = BTreeMap::<String, PlacedPages>::new();
+        let linked_files = |doc: &Document| match lookup {
+            Some((d, base)) => super::links::linked_files(d, base),
+            None => super::links::linked_files(doc, LinkBase::file(Some(source))),
+        };
         doc.visit_placed(|_, p| {
             let page = (p.link.page.unwrap_or(1), p.bounding, p.page_box);
             let pages = placed.entry(p.link.path.clone()).or_default();
@@ -218,7 +233,7 @@ impl<'a> Collector<'a> {
             }
         });
         if self.opts.copy_fonts && !self.opts.copy_links && !placed.is_empty() {
-            for file in super::links::linked_files(doc, Some(source)) {
+            for file in linked_files(doc) {
                 if let (Some(pages), Some(bytes)) = (placed.get(&file.path), &file.bytes) {
                     placed_fonts.extend(page_fonts(&file.name, bytes, file.found_path.as_deref().unwrap_or(&file.path), pages));
                 }
@@ -226,7 +241,7 @@ impl<'a> Collector<'a> {
         }
         if self.opts.copy_links {
             heading(&mut lines, "LINKED FILES");
-            for file in super::links::linked_files(doc, Some(source)) {
+            for file in linked_files(doc) {
                 let found_path = file.found_path.as_deref().unwrap_or(&file.path);
                 if let Some(ancestor) = self.visiting.get(found_path).cloned() {
                     // The ancestor is already included (possibly the root document). A
@@ -272,7 +287,7 @@ impl<'a> Collector<'a> {
                     if depth >= vectorcraft_doc::placed_document::MAX_DEPTH {
                         self.warn(&mut lines, format!("{}: nesting limit reached; copied unchanged without collecting its own links", file.path));
                     } else {
-                        self.collect(&mut art, found_path, &destination_file, depth + 1, true)?;
+                        self.collect(&mut art, found_path, &destination_file, depth + 1, true, None)?;
                     }
                 } else if self.opts.copy_fonts
                     && let Some(pages) = pages
@@ -289,7 +304,7 @@ impl<'a> Collector<'a> {
                                 let include_linked =
                                     saved.doc.linked_only_images().iter().any(|key| saved.doc.images.get(key).is_some_and(|blob| !blob.is_proxy()));
                                 let mut nested = saved.doc;
-                                self.collect(&mut nested, found_path, &destination_file, depth + 1, false)?;
+                                self.collect(&mut nested, found_path, &destination_file, depth + 1, false, None)?;
                                 if self.opts.relink {
                                     #[cfg(test)]
                                     PARTS_READ.with(|c| c.set(c.get() + 1));
@@ -405,6 +420,8 @@ fn package(s: &mut Session, p: &Value) -> Result<Value> {
 pub struct Package {
     o: Options,
     doc_path: String,
+    /// The file the document's links' stored relative paths are taken from.
+    links_from: String,
     stem: String,
     name: String,
     root: Option<PathBuf>,
@@ -450,7 +467,8 @@ fn prepare(s: &mut Session, p: &Value) -> Result<Package> {
     let root = folder.map(|f| Path::new(f).join(&name));
     let info = if o.report { Some(super::docinfo::report(s, false)?) } else { None };
     let doc = s.doc()?.doc.clone();
-    Ok(Package { o, doc_path, stem, name, root, info, doc })
+    let links_from = s.doc()?.links_from.clone().unwrap_or_else(|| doc_path.clone());
+    Ok(Package { o, doc_path, links_from, stem, name, root, info, doc })
 }
 
 impl Package {
@@ -464,18 +482,27 @@ impl Package {
 
 /// [`Package::write`].
 fn collect_and_write(package: Package, write: &mut dyn FnMut(&str, &[u8]) -> Result<()>) -> Result<Value> {
-    let Package { o, doc_path, stem, name, root, info, doc } = package;
-    let mut doc = (*doc).clone();
+    let Package { o, doc_path, links_from, stem, name, root, info, doc: original } = package;
+    let mut doc = (*original).clone();
     let doc_name = format!("{stem}.{}", vectorcraft_format::EXTENSION);
+    let base = LinkBase { doc: Some(&doc_path), relative: Some(&links_from) };
+    // After a save in another folder, links found away from their paths take the paths where they
+    // were found, as a copy of the document has them.
+    let found = (links_from != doc_path).then(|| {
+        super::links::with_found_paths(&mut doc, base);
+        doc.clone()
+    });
+    let looked = found.as_ref().unwrap_or(&original);
     // Prepare original links for the destination *before* rebasing copied links.
     // Recalculating afterward would overwrite the portable relative paths.
     if let Some(root) = &root
-        && let Some(d) = super::links::with_relative_paths(&doc, &root.join(&doc_name).to_string_lossy())
+        && let Some(d) = super::links::with_relative_paths(&doc, base, &root.join(&doc_name).to_string_lossy())
     {
         doc = d;
     }
     let mut collector = Collector::new(&o, root.clone(), &doc_name);
-    collector.collect(&mut doc, &doc_path, &doc_name, 0, false)?;
+    // The files are looked for where the links name them before the rebasing above.
+    collector.collect(&mut doc, &doc_path, &doc_name, 0, false, Some((looked, base)))?;
     let mut entries = std::mem::take(&mut collector.entries);
     entries.insert(0, (doc_name.clone(), vectorcraft_format::save_file(&doc)));
     let mut taken = std::mem::take(&mut collector.taken);
diff --git a/crates/engine/src/cmd/paint.rs b/crates/engine/src/cmd/paint.rs
index 19cdcfbbd..a2cd9a14a 100644
--- a/crates/engine/src/cmd/paint.rs
+++ b/crates/engine/src/cmd/paint.rs
@@ -950,7 +950,7 @@ fn proxy_recolor(s: &mut Session, p: &Value, cmd: &str, label: &str, f: &dyn Fn(
         // The proxy recolors its paints, including a colorized image's fill, without changing image pixels or pattern tiles.
         ItemTarget::Top => {
             let q = json!({"fill": !stroke, "stroke": stroke, "includeImages": false, "includePatterns": false, "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()});
-            (super::colorcmds::recolor(s, &q, label, f)?, None)
+            (super::colorcmds::recolor(s, &q, cmd, label, f)?, None)
         }
     };
     let shown_ids = if shown_item.is_some() { ids } else { leaf_targets(s, &ids)? };
diff --git a/crates/engine/src/cmd/path.rs b/crates/engine/src/cmd/path.rs
index fb81e1e49..4cb6880f0 100644
--- a/crates/engine/src/cmd/path.rs
+++ b/crates/engine/src/cmd/path.rs
@@ -597,7 +597,7 @@ pub(super) fn join(s: &mut Session, p: &Value) -> Result<Value> {
         },
     };
 
-    if let Some(ids) = ids_param(p, "ids") {
+    if let Some(ids) = ids_param(p, "ids", C)? {
         if ends.is_some() && ids.len() > 2 {
             return Err(bad(C, "`ends` applies to joining exactly two paths"));
         }
@@ -1101,7 +1101,7 @@ fn average_join_ends(s: &Session, p: &Value, c: &str) -> Result<Option<[End; 2]>
     let doc = &st.doc;
     let subpath = |id: NodeId, si: usize| doc.node(id)?.path_data()?.subpaths.get(si).filter(|sp| !sp.closed && !sp.anchors.is_empty());
     let last = |sp: &SubPath| sp.anchors.len().saturating_sub(1);
-    let ids = ids_param(p, "ids");
+    let ids = ids_param(p, "ids", c)?;
     let ends = if ids.is_none() && !st.selection.anchors.is_empty() {
         let picked: Vec<End> = st.selection.anchors.iter().flat_map(|(&id, set)| set.iter().map(move |&(si, ai)| (id, si, ai))).collect();
         match picked.as_slice() {
diff --git a/crates/engine/src/cmd/patterncmds.rs b/crates/engine/src/cmd/patterncmds.rs
index 1e7f88d2b..55c4390c2 100644
--- a/crates/engine/src/cmd/patterncmds.rs
+++ b/crates/engine/src/cmd/patterncmds.rs
@@ -219,8 +219,8 @@ fn ids_json(ids: &[NodeId]) -> Value {
     json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() })
 }
 
-fn roots(s: &Session, p: &Value) -> Result<Vec<NodeId>> {
-    match ids_param(p, "ids") {
+fn roots(s: &Session, p: &Value, cmd: &str) -> Result<Vec<NodeId>> {
+    match ids_param(p, "ids", cmd)? {
         Some(ids) => {
             let st = s.doc()?;
             let mut sel = Selection::default();
@@ -306,7 +306,7 @@ fn pattern_make(s: &mut Session, p: &Value) -> Result<Value> {
     if editing(s).is_some() {
         return Err(bad(C, "already in pattern editing mode"));
     }
-    let roots = roots(s, p)?;
+    let roots = roots(s, p, C)?;
     if roots.is_empty() {
         return Err(bad(C, "select the art for the pattern tile"));
     }
@@ -665,9 +665,9 @@ fn pattern_transform(s: &mut Session, p: &Value) -> Result<Value> {
 // ---------- Repeat ----------
 
 /// Make a repeat from the selection, or switch the selected repeat's kind.
-fn make_repeat(s: &mut Session, p: &Value, label: &str, make: impl Fn(Vec<Arc<Node>>) -> RepeatSpec) -> Result<Value> {
+fn make_repeat(s: &mut Session, p: &Value, cmd: &str, label: &str, make: impl Fn(Vec<Arc<Node>>) -> RepeatSpec) -> Result<Value> {
     let existing = selected_repeats(s);
-    if ids_param(p, "ids").is_none()
+    if ids_param(p, "ids", cmd)?.is_none()
         && let [r] = existing.as_slice()
     {
         let r = *r;
@@ -680,7 +680,7 @@ fn make_repeat(s: &mut Session, p: &Value, label: &str, make: impl Fn(Vec<Arc<No
         })?;
         return Ok(json!({ "id": r.0 }));
     }
-    let roots = roots(s, p)?;
+    let roots = roots(s, p, cmd)?;
     if roots.is_empty() {
         return Err(EngineError::Other("select the art to repeat".into()));
     }
@@ -699,14 +699,14 @@ fn repeat_radial(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("object.repeat.radial", "instances must be 1..1000"));
     }
     let radius = p.get("radius").and_then(Value::as_f64).filter(|r| r.is_finite() && *r >= 0.0);
-    make_repeat(s, p, "Radial Repeat", |src| RepeatSpec::radial(src, n as u32, radius))
+    make_repeat(s, p, "object.repeat.radial", "Radial Repeat", |src| RepeatSpec::radial(src, n as u32, radius))
 }
 
 fn repeat_grid(s: &mut Session, p: &Value) -> Result<Value> {
     let (hs, vs) = (p.get("hSpacing").and_then(Value::as_f64), p.get("vSpacing").and_then(Value::as_f64));
     let rows = p.get("rows").and_then(Value::as_u64).map(|v| v.clamp(1, 500) as u32);
     let cols = p.get("cols").and_then(Value::as_u64).map(|v| v.clamp(1, 500) as u32);
-    make_repeat(s, p, "Grid Repeat", |src| {
+    make_repeat(s, p, "object.repeat.grid", "Grid Repeat", |src| {
         let b = vectorcraft_doc::live::nodes_bounds(&src).unwrap_or(Rect::new(0.0, 0.0, 10.0, 10.0));
         let mut r = RepeatSpec::grid(src, hs.unwrap_or(b.width() / 4.0), vs.unwrap_or(b.height() / 4.0));
         if let RepeatKind::Grid { rows: rr, cols: cc, .. } = &mut r.kind {
@@ -720,7 +720,7 @@ fn repeat_grid(s: &mut Session, p: &Value) -> Result<Value> {
 fn repeat_mirror(s: &mut Session, p: &Value) -> Result<Value> {
     let angle = f64_or(p, "angle", 90.0);
     let offset = f64_or(p, "offset", 10.0);
-    make_repeat(s, p, "Mirror Repeat", |src| RepeatSpec::mirror(src, angle, offset))
+    make_repeat(s, p, "object.repeat.mirror", "Mirror Repeat", |src| RepeatSpec::mirror(src, angle, offset))
 }
 
 fn repeat_release(s: &mut Session, _: &Value) -> Result<Value> {
diff --git a/crates/engine/src/cmd/place.rs b/crates/engine/src/cmd/place.rs
index 40d176ab8..db9bbf67d 100644
--- a/crates/engine/src/cmd/place.rs
+++ b/crates/engine/src/cmd/place.rs
@@ -254,7 +254,7 @@ fn load(p: &Value, cmd: &str, board: Option<Rect>, link_pdf: bool) -> Result<Loa
             ));
         }
         // Linked images show their files, found from its folder.
-        super::links::resolve(&mut l.doc, src.path, false, false);
+        super::links::resolve(&mut l.doc, super::links::LinkBase::file(src.path), false, false);
         (l.doc, l.warnings)
     };
     doc.drop_edit_modes();
@@ -312,7 +312,7 @@ pub(crate) fn pdf_art(
     // file again: one already being read further up, or past the most nested reads, keeps its links
     // as stored, as a VectorCraft document's do.
     if alone && let Some(_reading) = document::Reading::enter(bytes) {
-        super::links::resolve(&mut doc, path, false, false);
+        super::links::resolve(&mut doc, super::links::LinkBase::file(path), false, false);
     }
     doc.drop_edit_modes();
     let layers = std::mem::take(&mut doc.layers);
diff --git a/crates/engine/src/cmd/place/document.rs b/crates/engine/src/cmd/place/document.rs
index bea33fcf3..9f58e4851 100644
--- a/crates/engine/src/cmd/place/document.rs
+++ b/crates/engine/src/cmd/place/document.rs
@@ -133,7 +133,7 @@ pub(crate) fn document_art(
     // A document already being read further up, or past [`MAX_NESTED_READS`] of them, has its links
     // left as stored.
     if let Some(_reading) = Reading::enter(bytes) {
-        super::super::links::resolve(&mut l.doc, path, false, false);
+        super::super::links::resolve(&mut l.doc, super::super::links::LinkBase::file(path), false, false);
     }
     l.doc.drop_edit_modes();
     let n = l.doc.artboards.len();
@@ -332,7 +332,7 @@ pub(crate) fn node(d: &mut Document, s: &Source, link: LinkInfo, bounding: bool)
 /// `d` for output: linked images and placed documents that keep only their previews get their
 /// files back, else output as their previews, with a warning.
 pub(crate) fn full_documents(d: &Document) -> (Cow<'_, Document>, Vec<String>) {
-    let (d, mut warnings) = super::super::links::full_linked_images(d, None);
+    let (d, mut warnings) = super::super::links::full_linked_images(d, Default::default());
     let doc = match &d {
         Cow::Borrowed(doc) => doc,
         Cow::Owned(doc) => doc,
diff --git a/crates/engine/src/cmd/plugin.rs b/crates/engine/src/cmd/plugin.rs
index 8e7fc717e..08b56cde7 100644
--- a/crates/engine/src/cmd/plugin.rs
+++ b/crates/engine/src/cmd/plugin.rs
@@ -24,7 +24,10 @@
 //! `vc_cancelled` and `vc_log` ([`vectorcraft_plugins::host`]): run inside a
 //! [`vectorcraft_doc::cancel::scope`] (the app's heavy filters and background exports), its
 //! progress goes to the scope's sink and it sees the scope's Cancel; its log lines go to the log
-//! under its id.
+//! under its id. One that lists `settings` or `cache` may keep settings and a cache of its own
+//! (`vc_settings_*`, `vc_cache_*`), in the plug-in store under its id ([`crate::store`]):
+//! `plugin.clearCache` empties the cache, `plugin.list` and `plugin.info` give its size
+//! (`cacheBytes`), replacing the plug-in keeps both and `plugin.remove` deletes them.
 
 use std::sync::{Arc, Mutex};
 
@@ -141,7 +144,7 @@ impl FilterRun {
         let st = s.doc()?;
         // While an object of a dynamic symbol instance's art is selected, the selection is refused,
         // as `selected_roots` refuses it.
-        let selected = match ids_param(p, "ids") {
+        let selected = match ids_param(p, "ids", C)? {
             Some(ids) => ids,
             None => {
                 super::edit::refuse_symbol_part(s)?;
@@ -340,14 +343,27 @@ fn grant_param(c: &str, p: &Value) -> Result<Option<Vec<Permission>>> {
     Ok(Some(out))
 }
 
+/// Would installing `plugin` take another module's place: one installed with its id and other
+/// bytes, or, with none installed, the settings and cache the plug-in store keeps for its id?
+fn takes_over(s: &Session, plugin: &Plugin) -> bool {
+    match registry::get(plugin.id()) {
+        Some(installed) => installed.hash() != plugin.hash(),
+        None => s.has_plugin_storage(plugin.id()),
+    }
+}
+
 /// `plugin.install`: loads and checks the module, refuses one that asks for a heavy budget unless
-/// `allowHeavy` says the user agreed, and one that lists permissions the user hasn't granted this
-/// very module unless `grant` lists them all, and one whose SHA-256 isn't the `hash` given; records
-/// the grant with the module's hash, keeps it for the next start and installs it → its
-/// `plugin.list` entry.
+/// `allowHeavy` says the user agreed, one that lists permissions the user hasn't granted this very
+/// module unless `grant` lists them all, one that would take another module's place ([`takes_over`])
+/// unless `replace` is true, and one whose SHA-256 isn't the `hash` given; records the grant with
+/// the module's hash, keeps it for the next start and installs it → its `plugin.list` entry.
 fn install(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "plugin.install";
-    let (replace, allow_heavy) = (switch_or(p, "replace", true, C)?, switch_or(p, "allowHeavy", false, C)?);
+    let replace = match p.get("replace") {
+        None | Some(Value::Null) => None,
+        Some(_) => Some(switch_or(p, "replace", false, C)?),
+    };
+    let allow_heavy = switch_or(p, "allowHeavy", false, C)?;
     let grant = grant_param(C, p)?;
     let (plugin, bytes) = load_given(C, p)?;
     // `hash` pins the module the user was shown: one with other bytes is refused.
@@ -356,9 +372,21 @@ fn install(s: &mut Session, p: &Value) -> Result<Value> {
     {
         return Err(bad(C, "the module doesn't have the SHA-256 `hash` gives: nothing was installed"));
     }
-    if !replace && registry::get(plugin.id()).is_some() {
+    if replace == Some(false) && registry::get(plugin.id()).is_some() {
         return Err(bad(C, format!("a plug-in with id {:?} is already installed", plugin.id())));
     }
+    // Another module under the id gets the settings and cache kept for it: whoever installs it asks
+    // the user first.
+    if replace != Some(true) && takes_over(s, &plugin) {
+        let name = permissions::display_text(&plugin.manifest().name, permissions::MAX_SHOWN_NAME);
+        return Err(bad(
+            C,
+            format!(
+                "“{name}” is another module than the plug-in with id {:?} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees",
+                plugin.id()
+            ),
+        ));
+    }
     // A heavy plug-in is installed once the user agrees: whoever installs it asks them first.
     if plugin.manifest().budget == Budget::Heavy && !allow_heavy {
         let (minutes, times) = vectorcraft_plugins::heavy_terms();
@@ -393,6 +421,8 @@ fn install(s: &mut Session, p: &Value) -> Result<Value> {
             stored = false;
         }
     }
+    // It gets the settings and cache kept for its id.
+    s.attach_plugin_storage(plugin.id());
     // Installing a disabled plug-in again (an updated version) turns it on for the next launch too,
     // also when it is disabled by its stored file alone (it stopped a launch while loading). When
     // the new version could not replace the stored file, the old one stays disabled.
@@ -407,15 +437,17 @@ fn install(s: &mut Session, p: &Value) -> Result<Value> {
     if changed {
         s.store_disabled_plugins();
     }
-    Ok(describe(&registry::install(plugin)))
+    Ok(describe_installed(&registry::install(plugin)))
 }
 
-/// `plugin.inspect`: what installing the module would install, without installing it, and whether
-/// that needs the user to grant its permissions first (`needsApproval`).
+/// `plugin.inspect`: what installing the module would install, without installing it, whether that
+/// needs the user to grant its permissions first (`needsApproval`) and whether it would take
+/// another module's place (`needsReplace`).
 fn inspect(s: &mut Session, p: &Value) -> Result<Value> {
     load_given("plugin.inspect", p).map(|(plugin, _)| {
         let mut v = describe(&plugin);
         v["needsApproval"] = json!(!s.plugin_approved(&plugin));
+        v["needsReplace"] = json!(takes_over(s, &plugin));
         v
     })
 }
@@ -486,6 +518,9 @@ fn load_folder(s: &Session, folder: &str) -> Value {
     };
     match registry::load_folder_where(std::path::Path::new(folder), allow, s.plugin_approver()) {
         Ok(r) => {
+            for id in &r.loaded {
+                s.attach_plugin_storage(id);
+            }
             if r.disabled_changed {
                 s.store_disabled_plugins();
             }
@@ -517,11 +552,18 @@ fn reload(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(report)
 }
 
+/// [`describe`] for an installed plug-in, with the bytes its cache holds (`cacheBytes`).
+fn describe_installed(p: &Plugin) -> Value {
+    let mut v = describe(p);
+    v["cacheBytes"] = json!(registry::storage(p.id()).map_or(0, |st| st.cache_bytes()));
+    v
+}
+
 fn list(_: &mut Session, _: &Value) -> Result<Value> {
     let folder = FOLDER.lock().unwrap_or_else(|e| e.into_inner()).as_ref().map(|(_, _, r)| r.clone());
     let disabled: Vec<Value> = safe_mode::disabled().iter().map(safe_mode::Item::to_json).collect();
     Ok(
-        json!({"plugins": registry::list().iter().map(|p| describe(p)).collect::<Vec<_>>(), "folder": folder, "safeMode": safe_mode::active(), "disabled": disabled}),
+        json!({"plugins": registry::list().iter().map(|p| describe_installed(p)).collect::<Vec<_>>(), "folder": folder, "safeMode": safe_mode::active(), "disabled": disabled}),
     )
 }
 
@@ -576,7 +618,7 @@ fn set_enabled(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn info(_: &mut Session, p: &Value) -> Result<Value> {
     let plugin = plugin_by_id("plugin.info", p)?;
-    let mut v = describe(&plugin);
+    let mut v = describe_installed(&plugin);
     v["manifest"] = serde_json::to_value(plugin.manifest()).unwrap_or(Value::Null);
     v["defaults"] = Value::Object(plugin.manifest().defaults());
     v["lastError"] = json!(effect::last_error(plugin.id()));
@@ -585,15 +627,48 @@ fn info(_: &mut Session, p: &Value) -> Result<Value> {
 
 fn remove(s: &mut Session, p: &Value) -> Result<Value> {
     let id = str_param(p, "id").ok_or_else(|| bad("plugin.remove", "missing `id`"))?;
+    let installed = registry::get(id).is_some();
+    // Settings and cache the store keeps for an id that isn't installed are deleted too.
+    let stored = !installed && vectorcraft_plugins::manifest::valid_id(id) && s.has_plugin_storage(id);
+    // Its settings and cache go first: when they can't be moved aside, the plug-in stays installed,
+    // as it was, and a second `plugin.remove` tries again.
+    if (installed || stored)
+        && let Err(e) = s.remove_plugin_storage(id)
+    {
+        if installed {
+            s.attach_plugin_storage(id);
+        }
+        return Err(EngineError::Other(e.to_string()));
+    }
     // Installed again, it asks again.
     registry::revoke(id);
     s.store_grant(id, None);
     s.unstore_plugin(id);
-    if registry::remove(id) { Ok(json!({"removed": id})) } else { Err(err(vectorcraft_plugins::Error::NotFound(id.into()))) }
+    if !stored && (!installed || !registry::remove(id)) {
+        return Err(err(vectorcraft_plugins::Error::NotFound(id.into())));
+    }
+    Ok(json!({"removed": id}))
+}
+
+/// `plugin.clearCache`: empties the cache of plug-in `id`, else of every installed plug-in →
+/// `{cleared: [id], bytesFreed}`. Settings stay.
+fn clear_cache(_: &mut Session, p: &Value) -> Result<Value> {
+    let plugins = match p.get("id").filter(|v| !v.is_null()) {
+        Some(_) => vec![plugin_by_id("plugin.clearCache", p)?],
+        None => registry::list(),
+    };
+    let (mut cleared, mut freed) = (Vec::new(), 0_u64);
+    for plugin in plugins {
+        if let Some(st) = registry::storage(plugin.id()) {
+            freed += st.clear_cache().map_err(|e| EngineError::Other(e.to_string()))?;
+        }
+        cleared.push(plugin.id().to_string());
+    }
+    Ok(json!({"cleared": cleared, "bytesFreed": freed}))
 }
 
 /// This module's commands: `plugin.list`, `.info`, `.run`, `.install`, `.inspect`, `.remove`,
-/// `.reload`, `.safeMode` and `.setEnabled`.
+/// `.reload`, `.clearCache`, `.safeMode` and `.setEnabled`.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -601,7 +676,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "List Plug-ins",
             [],
             None,
-            "{} → {plugins: [{id, name, version, kind: \"filter\"|\"effect\"|\"exporter\", author, description, params (doc), paramsSchema, effect? (the effect id of a live effect: plugin.<id>), format? and extensions? (an exporter's format id, plugin.<id>, for document.export, and its file extensions), budget?: \"heavy\" (a filter that may compute for longer, see plugin.install's allowHeavy), size, source, permissions: [name] (what it may do: the ones its manifest lists, else the ones its kind implies; progress: it may report its progress, see Cancel and write log lines), hash (the module's SHA-256), api (the plug-in API level it was built for, 1 or 2)}], folder: the Additional Plug-ins Folder load report {folder, loaded, failed: [{file, error}]} | null, safeMode: bool (no plug-in loads or runs, see plugin.safeMode), disabled: [{id, file, name, label}] (turned off for the next launch, see plugin.setEnabled)}",
+            "{} → {plugins: [{id, name, version, kind: \"filter\"|\"effect\"|\"exporter\", author, description, params (doc), paramsSchema, effect? (the effect id of a live effect: plugin.<id>), format? and extensions? (an exporter's format id, plugin.<id>, for document.export, and its file extensions), budget?: \"heavy\" (a filter that may compute for longer, see plugin.install's allowHeavy), size, source, permissions: [name] (what it may do: the ones its manifest lists, else the ones its kind implies; progress: it may report its progress, see Cancel and write log lines; settings: it may keep settings of its own; cache: it may keep a cache of its own), hash (the module's SHA-256), api (the plug-in API level it was built for, 1 or 2), cacheBytes (the bytes its cache holds; see plugin.clearCache)}], folder: the Additional Plug-ins Folder load report {folder, loaded, failed: [{file, error}]} | null, safeMode: bool (no plug-in loads or runs, see plugin.safeMode), disabled: [{id, file, name, label}] (turned off for the next launch, see plugin.setEnabled)}",
             always,
             list
         ),
@@ -628,7 +703,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Install Plug-in",
             [],
             None,
-            "{path: a .wasm file (desktop) | dataBase64: the module (+ name?: shown as its source), replace?: bool (true: a plug-in with the same id is replaced), name?: file name (with dataBase64), allowHeavy?: bool (true once the user agreed to a heavy budget: a filter whose manifest asks for one, budget \"heavy\" in plugin.inspect, installs only with it), grant?: [permission] (the permissions the user granted: a plug-in whose manifest lists permissions, needsApproval in plugin.inspect, installs only when grant holds every one of them; the grant is recorded with the module's hash and covers only that module, so a module with other bytes needs a new grant even when it lists the same permissions; with a plug-in store attached, only the grants kept there count), hash?: string (the module's SHA-256 as plugin.inspect gave it: a module with other bytes is refused)} validate and install a WebAssembly plug-in for this session → its plugin.list entry",
+            "{path: a .wasm file (desktop) | dataBase64: the module (+ name?: shown as its source), replace?: bool (true once the user agreed: a module with other bytes than the plug-in installed with its id, or with none installed, one whose id has settings or a cache in the plug-in store, installs only with it, takes that plug-in's place and gets its settings and cache; false: one whose id is installed is refused; left out, the same module installs again), name?: file name (with dataBase64), allowHeavy?: bool (true once the user agreed to a heavy budget: a filter whose manifest asks for one, budget \"heavy\" in plugin.inspect, installs only with it), grant?: [permission] (the permissions the user granted: a plug-in whose manifest lists permissions, needsApproval in plugin.inspect, installs only when grant holds every one of them; the grant is recorded with the module's hash and covers only that module, so a module with other bytes needs a new grant even when it lists the same permissions; with a plug-in store attached, only the grants kept there count), hash?: string (the module's SHA-256 as plugin.inspect gave it: a module with other bytes is refused)} validate and install a WebAssembly plug-in for this session → its plugin.list entry",
             always,
             install
         ),
@@ -637,11 +712,28 @@ pub fn specs() -> Vec<CommandSpec> {
             "Inspect Plug-in",
             [],
             None,
-            "{path: a .wasm file (desktop) | dataBase64: the module, name?: the file name shown as its source (with dataBase64)} validate a WebAssembly plug-in without installing it → the plugin.list entry it would have, plus needsApproval: bool (true when it lists permissions the user hasn't granted this very module, its bytes included: plugin.install then needs grant)",
+            "{path: a .wasm file (desktop) | dataBase64: the module, name?: the file name shown as its source (with dataBase64)} validate a WebAssembly plug-in without installing it → the plugin.list entry it would have, plus needsApproval: bool (true when it lists permissions the user hasn't granted this very module, its bytes included: plugin.install then needs grant) and needsReplace: bool (true when it would take the place of another module with its id: plugin.install then needs replace: true)",
             always,
             inspect
         ),
-        cmd!(query "plugin.remove", "Remove Plug-in", [], None, "{id} uninstall a plug-in (its live effects then leave the geometry as it is) → {removed}", always, remove),
+        cmd!(
+            query "plugin.remove",
+            "Remove Plug-in",
+            [],
+            None,
+            "{id} uninstall a plug-in (its live effects then leave the geometry as it is) and delete the settings and cache it kept (when their folder can't be moved aside, the command fails and the plug-in stays installed); for an id that isn't installed, deletes the settings and cache the plug-in store still keeps for it → {removed}",
+            always,
+            remove
+        ),
+        cmd!(
+            query "plugin.clearCache",
+            "Clear Plug-in Cache",
+            [],
+            None,
+            "{id?} delete every entry in the cache of plug-in id (default: of every installed plug-in); its settings stay → {cleared: [id], bytesFreed}",
+            always,
+            clear_cache
+        ),
         cmd!(
             query "plugin.reload",
             "Reload Plug-ins",
diff --git a/crates/engine/src/cmd/recovery.rs b/crates/engine/src/cmd/recovery.rs
index 8b5731b33..a06597ac8 100644
--- a/crates/engine/src/cmd/recovery.rs
+++ b/crates/engine/src/cmd/recovery.rs
@@ -575,6 +575,10 @@ struct Meta {
     /// (see [`crate::DocState::import_losses`]): a restored copy still refuses to replace it.
     imported_from: Option<String>,
     import_losses: Vec<String>,
+    /// The file the links' relative paths name places from, for a copy without `path` (see
+    /// [`crate::DocState::links_from`]).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    links_from: Option<String>,
     /// The document's images by key, in entries of the area (none in copies written before
     /// images were kept apart: the document entry holds them).
     #[serde(skip_serializing_if = "BTreeMap::is_empty")]
@@ -844,6 +848,7 @@ pub fn jobs(s: &mut Session, store: &Arc<dyn RecoveryStore>) -> Result<(Vec<Reco
             saved,
             imported_from: st.imported_from.clone(),
             import_losses: st.import_losses.clone(),
+            links_from: st.links_from.clone().filter(|_| st.path.is_none()),
             // Filled in as the copy is written.
             images: BTreeMap::new(),
         };
@@ -1061,11 +1066,14 @@ fn restore_one(s: &mut Session, store: &Arc<dyn RecoveryStore>, file: &str) -> R
     if doc.title.is_empty() {
         doc.title = if meta.title.is_empty() { stem.to_string() } else { meta.title.clone() };
     }
-    // Linked files are looked for from the document's own folder.
-    let links = super::links::resolve(&mut doc, meta.path.as_deref(), s.prefs.update_links == "automatically", s.prefs.low_res_proxy_eps);
+    // Linked files are looked for from the document's own folder, else from the file it was read from.
+    let links_from = meta.path.clone().or_else(|| meta.links_from.clone());
+    let base = super::links::LinkBase::file(links_from.as_deref());
+    let links = super::links::resolve(&mut doc, base, s.prefs.update_links == "automatically", s.prefs.low_res_proxy_eps);
     let index = s.add_document(doc, meta.path.clone());
     let st = s.doc_mut()?;
     st.recovered = true;
+    st.links_from = links_from;
     st.imported_from = meta.imported_from.clone();
     st.import_losses = meta.import_losses.clone();
     st.format = SAVE_FORMATS.iter().copied().find(|f| *f == meta.format).unwrap_or("vectorcraft");
diff --git a/crates/engine/src/cmd/slices.rs b/crates/engine/src/cmd/slices.rs
index f52c26a1c..5792c44fd 100644
--- a/crates/engine/src/cmd/slices.rs
+++ b/crates/engine/src/cmd/slices.rs
@@ -204,7 +204,7 @@ impl Session {
 /// The slices a command acts on: `slices` (ids that must all be slices), else the selected ones.
 fn slice_targets(s: &Session, p: &Value, cmd: &str) -> Result<Vec<NodeId>> {
     let st = s.doc()?;
-    match ids_param(p, "slices") {
+    match ids_param(p, "slices", cmd)? {
         Some(ids) => match ids.iter().find(|id| !st.doc.is_slice(**id)) {
             Some(id) => Err(bad(cmd, format!("{id} is not a slice"))),
             None => Ok(dedup(ids)),
@@ -290,7 +290,7 @@ pub(crate) fn options_json(o: &SliceOptions) -> Value {
 // ---------- Object → Slice ----------
 
 fn make(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = match ids_param(p, "ids") {
+    let ids = match ids_param(p, "ids", "object.slice.make")? {
         Some(ids) => super::edit::outermost(&s.doc()?.doc, ids),
         None => super::edit::selected_roots(s)?,
     };
@@ -734,7 +734,8 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn select(s: &mut Session, p: &Value) -> Result<Value> {
-    let ids = slice_targets(s, &json!({ "slices": p.get("slices").cloned().unwrap_or(json!([])) }), "object.slice.select")?;
+    let slices = p.get("slices").filter(|v| !v.is_null()).cloned().unwrap_or(json!([]));
+    let ids = slice_targets(s, &json!({ "slices": slices }), "object.slice.select")?;
     let toggle = bool_or(p, "toggle", false);
     s.select(|_, sel| {
         let mut now = if toggle { sel.slices.clone() } else { vec![] };
diff --git a/crates/engine/src/cmd/symboledit.rs b/crates/engine/src/cmd/symboledit.rs
index de262cf2b..a3745975b 100644
--- a/crates/engine/src/cmd/symboledit.rs
+++ b/crates/engine/src/cmd/symboledit.rs
@@ -65,7 +65,8 @@ pub(crate) fn enter(s: &mut Session, p: &Value) -> Result<Value> {
     if st.doc.pattern_edit.is_some() {
         return Err(bad(C, "finish editing the pattern first"));
     }
-    let given = object_param(p, "id", C)?.map(|i| vec![i]).or_else(|| super::ids_param(p, "ids").filter(|v| !v.is_empty()));
+    let ids = super::ids_param(p, "ids", C)?;
+    let given = object_param(p, "id", C)?.map(|i| vec![i]).or_else(|| ids.filter(|v| !v.is_empty()));
     let (name, xf, instance) = match given {
         Some(ids) => {
             let symbols = ids.iter().map(|id| instance_of(&st.doc, *id)).collect::<Option<Vec<_>>>();
diff --git a/crates/engine/src/cmd/textedit.rs b/crates/engine/src/cmd/textedit.rs
index d8514ef56..4274ce6d5 100644
--- a/crates/engine/src/cmd/textedit.rs
+++ b/crates/engine/src/cmd/textedit.rs
@@ -1068,7 +1068,7 @@ fn set_range_style(s: &mut Session, p: &Value) -> Result<Value> {
             if sets_font {
                 // Empty text has one run, which the empty range styles. Characters that kept their font aren't the command's.
                 let styled = if a == b { t.runs.clone() } else { unprotected_runs(&t.runs, a, b, &kept) };
-                set.extend(styled.iter().map(|r| super::fonts::font_of(&r.style)));
+                set.extend(styled.iter().flat_map(super::fonts::run_fonts));
             }
             refresh_bounds(t);
             n = if *f == id { t.runs.len() } else { n };
@@ -1140,7 +1140,12 @@ fn glyph_target(t: &TextObject, p: &Value, c: &str) -> Result<(char, std::ops::R
                 return Err(bad(c, "an inline graphic has no glyphs"));
             }
             let db = vectorcraft_text::FontDb::global();
-            let face = db.style_face(&run.style).filter(|_| db.has_family(&run.style.font_family));
+            let face = match db.composite_resolve_at(&run.style.font_family, &run.text, start - at) {
+                // Type in a composite font: the character is drawn in the font of the part its
+                // grapheme cluster falls in.
+                Some((face, m)) => (m != vectorcraft_text::FontMatch::Missing).then_some(face),
+                None => db.style_face(&run.style).filter(|_| db.has_family(&run.style.font_family)),
+            };
             let face = face.ok_or_else(|| bad(c, format!("the font {} is not available", run.style.font_family)))?;
             return Ok((ch, start..start + ch.len_utf8(), face));
         }
diff --git a/crates/engine/src/cmd/textstyles.rs b/crates/engine/src/cmd/textstyles.rs
index 17b2f0f0c..68394e7fd 100644
--- a/crates/engine/src/cmd/textstyles.rs
+++ b/crates/engine/src/cmd/textstyles.rs
@@ -327,7 +327,7 @@ fn font_change(before: &CharStyle, mut st: CharStyle, attrs: &Map<String, Value>
 
 /// Change text in layers, symbols, graph designs, pattern tiles, saved pattern tiles restored by
 /// Cancel, and brush art, including opacity masks in those trees.
-fn each_text_mut(d: &mut Document, f: &mut impl FnMut(&mut vectorcraft_doc::TextObject) -> Result<()>) -> Result<()> {
+pub(crate) fn each_text_mut(d: &mut Document, f: &mut impl FnMut(&mut vectorcraft_doc::TextObject) -> Result<()>) -> Result<()> {
     fn has_text(n: &Node) -> bool {
         matches!(n.kind, NodeKind::Text(_))
             || n.extras().mask.as_ref().is_some_and(|mask| has_text(&mask.art))
diff --git a/crates/engine/src/cmd/typecmd.rs b/crates/engine/src/cmd/typecmd.rs
index b349ef894..c5663b58a 100644
--- a/crates/engine/src/cmd/typecmd.rs
+++ b/crates/engine/src/cmd/typecmd.rs
@@ -919,7 +919,7 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
                         super::textedit::unprotected_runs(&t.runs, a, b, &kept)
                     }
                 };
-                set.extend(styled.iter().map(|r| super::fonts::font_of(&r.style)));
+                set.extend(styled.iter().flat_map(super::fonts::run_fonts));
             }
             if let Some(j) = justify {
                 let span = para_span(range, t);
diff --git a/crates/engine/src/cmd/typemenu.rs b/crates/engine/src/cmd/typemenu.rs
index 872ceee4b..58b4e2e6b 100644
--- a/crates/engine/src/cmd/typemenu.rs
+++ b/crates/engine/src/cmd/typemenu.rs
@@ -56,7 +56,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Type on a Path Options…",
             ["Type", "Type on a Path"],
             None,
-            "{ids?|id?, start?: 0..1, end?: 0..1|null, flip?: bool, effect?: rainbow|skew|3dRibbon|stairStep|gravity, alignToPath?: ascender|descender|center|baseline, spacing?: pt} set the selected type on a path's options: start and end place its start and end brackets as fractions of the path's length (end null: the end of the path, or once round a closed path), and flip then turns the type to the other side of its path (the path runs the other way, the brackets swap ends); none given: query → the first object's {start, end, flip: false, effect, alignToPath, spacing}",
+            "{ids?|id?, start?: 0..1, end?: 0..1|null, flip?: bool, effect?: rainbow|skew|3dRibbon|stairStep|gravity, alignToPath?: ascender|descender|center|baseline, spacing?: pt} set the selected type on a path's options: start and end place its start and end brackets as fractions of the path's length (end null: the end of the path, or once round a closed path), and flip then turns the type to the other side of its path (the path runs the other way, the brackets swap ends); alignToPath runs each character's em box top (ascender), font bounding box bottom (descender), half the height of its H's top above the baseline (center) or baseline along the path, by the character's own font, size and vertical scale (vertical type: half an em either way, or none for center); none given: query → the first object's {start, end, flip: false, effect, alignToPath, spacing}",
             has_selection,
             path_options
         ),
diff --git a/crates/engine/src/command_sets.rs b/crates/engine/src/command_sets.rs
index 2224ddccc..9fcb7cd4c 100644
--- a/crates/engine/src/command_sets.rs
+++ b/crates/engine/src/command_sets.rs
@@ -121,13 +121,14 @@ pub(crate) const SELECTS_GIVEN_IDS: &[&str] = &[
 /// The non-empty `ids` given to a command whose params description names `ids` as a key (the
 /// key callers outside the app may pass it, [`cmd::params::takes_key`]), or its `id` as `ids` of
 /// one when no `ids` are given and the description takes `id` so
-/// ([`cmd::params::id_stands_for_ids`]), as [`cmd::targets`] reads them.
+/// ([`cmd::params::id_stands_for_ids`]), as [`cmd::targets`] reads them. Entries of `ids` that are
+/// not ids are left out of this list; `Session::execute` refuses them before it reads it.
 pub(crate) fn given_ids(description: &'static str, params: &Value) -> Option<Vec<NodeId>> {
     if !cmd::params::takes_key(description, "ids") {
         return None;
     }
     match params.get("ids").filter(|v| !v.is_null()) {
-        Some(_) => cmd::ids_param(params, "ids"),
+        Some(v) => v.as_array().map(|a| a.iter().filter_map(Value::as_u64).map(NodeId).collect()),
         None => cmd::id_param(params, "id").filter(|_| cmd::params::id_stands_for_ids(description)).map(|id| vec![id]),
     }
     .filter(|ids| !ids.is_empty())
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
index 0baab9654..e70bf5c2d 100644
--- a/crates/engine/src/doc_state.rs
+++ b/crates/engine/src/doc_state.rs
@@ -95,6 +95,11 @@ pub struct DocState {
     /// so an export or save to it asks first ([`cmd::fileio::check_not_lossy_overwrite`]). Not saved.
     pub imported_from: Option<String>,
     pub import_losses: Vec<String>,
+    /// The file its links' stored relative paths name places from: the file the document was read
+    /// from, also when that file is not its own (such as a `.ai` file another app wrote). A save
+    /// writes the saved file's relative paths and leaves the open document's links as they are.
+    /// `None`: the document's own file. Not saved ([`crate::cmd::links::LinkBase`]).
+    pub links_from: Option<String>,
     /// Transform Again after a perspective move or scale (Perspective Selection tool): the
     /// `perspective.transform` params it repeats. `None` once an ordinary transform follows.
     pub last_perspective: Option<Value>,
@@ -296,6 +301,7 @@ impl DocState {
             layers_open,
             imported_from: None,
             import_losses: vec![],
+            links_from: None,
             last_perspective: None,
             opened_by: file_access::current(),
             empty_artboards: Default::default(),
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index c9533158d..27972ef20 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -172,6 +172,9 @@ pub struct Session {
     /// has inherited the selection's appearance: the documents ([`DocState::uid`]) whose newest
     /// history step takes the colors the batch finally left.
     pub(crate) batch_paint_docs: Vec<u64>,
+    /// The composite fonts (lowercase names) that the open documents defined when the font
+    /// database was last brought in step with them ([`cmd::compositefonts::sync`]).
+    pub(crate) composite_names: Vec<String>,
     /// While a command that changes nothing in the document runs (a query, or one of
     /// [`command_sets::JOURNALED_READS`]): it reads the instance of an object selected in a symbol
     /// instance's art.
diff --git a/crates/engine/src/session/documents.rs b/crates/engine/src/session/documents.rs
index d4859cdf1..b0619c992 100644
--- a/crates/engine/src/session/documents.rs
+++ b/crates/engine/src/session/documents.rs
@@ -83,6 +83,7 @@ impl Session {
             batch_stash: None,
             batch_steps: None,
             batch_paint_docs: Vec::new(),
+            composite_names: Vec::new(),
             reading: false,
             place_hand_off: None,
             queue_hand_off: None,
@@ -176,10 +177,16 @@ impl Session {
 
     pub fn set_active(&mut self, index: usize) -> bool {
         if index < self.docs.len() {
-            if self.active != Some(index) {
+            let switched = self.active != Some(index);
+            if switched {
                 self.reset_tool_for_doc_switch();
             }
             self.active = Some(index);
+            // Type is drawn in the composite fonts of the document now in front, and measured again
+            // when they differ from those of the document before.
+            if switched && cmd::compositefonts::sync(self) {
+                self.refresh_document_text_bounds(index);
+            }
             true
         } else {
             false
@@ -196,7 +203,7 @@ impl Session {
         format!("Untitled-{}", self.untitled_counter)
     }
 
-    /// Text layout bounds are a cache (not saved): compute them for a document just read, or
+    /// Text layout bounds are a cache (not saved): compute them after its fonts are registered, or
     /// selection boxes and hit testing would use the rough estimate until each text is edited, and
     /// what is fitted to type's bounds (an envelope warping it) would come out differently. That
     /// holds for the type in symbol definitions, pattern tiles, graph designs and opacity masks too,
@@ -211,6 +218,14 @@ impl Session {
         }
     }
 
+    /// [`Session::refresh_text_bounds`] for open document `index`, as a change that is not an
+    /// edit: a saved document stays saved, and its undo history keeps its documents as they are.
+    fn refresh_document_text_bounds(&mut self, index: usize) {
+        if let Some(st) = self.docs.get_mut(index) {
+            st.change_unsaved(|doc| Self::refresh_text_bounds(Arc::make_mut(doc)));
+        }
+    }
+
     /// Add a document and make it active. Between `edit.undoGroup.begin` and `edit.undoGroup.end`,
     /// an undo group with the begun group's name opens in it: here outside a command, and after the
     /// command that adds it otherwise ([`Session::execute`]).
@@ -218,7 +233,7 @@ impl Session {
         // Every edit is checked against the document before it, so the first one is within the cap
         // (importers and the native reader have seen to theirs already, with a warning).
         doc.limit_depth();
-        Self::refresh_text_bounds(&mut doc);
+        cmd::compositefonts::filter_loaded(&mut doc);
         // Guides from files saved before guides had layers go on a layer.
         doc.adopt_guides();
         cmd::dimension::conform(&mut doc);
@@ -229,6 +244,8 @@ impl Session {
         self.docs.push(st);
         let i = self.docs.len() - 1;
         self.active = Some(i);
+        cmd::compositefonts::sync(self);
+        self.refresh_document_text_bounds(i);
         if self.depth == 0
             && let Some(label) = self.explicit_undo_group.clone()
         {
@@ -244,7 +261,7 @@ impl Session {
             return false;
         }
         doc.limit_depth();
-        Self::refresh_text_bounds(&mut doc);
+        cmd::compositefonts::filter_loaded(&mut doc);
         doc.adopt_guides();
         cmd::dimension::conform(&mut doc);
         if self.active == Some(index) {
@@ -280,6 +297,12 @@ impl Session {
         if let Some(stash) = &mut self.batch_stash {
             stash.push(old);
         }
+        // Type in the composite fonts of a document in the back is measured again when it comes to
+        // the front.
+        if self.active == Some(index) {
+            cmd::compositefonts::sync(self);
+        }
+        self.refresh_document_text_bounds(index);
         true
     }
 
@@ -296,6 +319,7 @@ impl Session {
             stash.push(old);
         }
         self.active = if self.docs.is_empty() { None } else { Some(index.min(self.docs.len() - 1)) };
+        cmd::compositefonts::sync(self);
         true
     }
 
diff --git a/crates/engine/src/session/execute.rs b/crates/engine/src/session/execute.rs
index 71f90e7e4..5ad84885f 100644
--- a/crates/engine/src/session/execute.rs
+++ b/crates/engine/src/session/execute.rs
@@ -15,11 +15,14 @@ impl Session {
         r
     }
 
-    /// Error, under the command's own id, at the first of `ids` that is malformed, names no node, or
-    /// names a layer or sublayer: a command in [`SELECTS_GIVEN_IDS`] acts on objects.
+    /// Error, under the command's own id, at the first of `ids` that is malformed, else at the first
+    /// that names no node or names a layer or sublayer: a command in [`SELECTS_GIVEN_IDS`] acts on
+    /// objects.
     fn check_given_ids(&self, id: &str, params: &Value) -> Result<()> {
         let (Some(st), Some(ids)) = (self.active(), params.get("ids")) else { return Ok(()) };
         let Some(given) = ids.as_array() else { return cmd::checked_ids_param(self, params, "ids", id).map(drop) };
+        // A malformed entry anywhere in the list is refused first, under the key and the entry.
+        cmd::ids_param(params, "ids", id)?;
         for value in given {
             let node = cmd::checked_id(self, value, id)?;
             if st.doc.node(node).is_some_and(|n| n.is_layer()) {
@@ -65,6 +68,13 @@ impl Session {
         if SELECTS_GIVEN_IDS.contains(&id) {
             self.check_given_ids(id, params)?;
         }
+        // An `ids` list with an entry that is not an object id, or an `ids` that is not a list, is
+        // refused under the command's id before the menu check, which would otherwise run on the
+        // other entries or on the selection. This holds with no document open too, where commands
+        // such as `effect.list` still run.
+        if cmd::params::takes_key(spec.params, "ids") {
+            cmd::ids_param(params, "ids", id)?;
+        }
         // Clear's menu needs a selection; an agent supplying explicit targets only needs a
         // document. The command validates those targets before making any edit.
         let given = given_ids(spec.params, params);
@@ -147,6 +157,9 @@ impl Session {
         }
         if let Some(open) = open {
             self.open_undo_groups_in_new_documents(&open);
+            // Type is drawn in the composite fonts of the documents open now, an undone or opened
+            // document's included.
+            cmd::compositefonts::sync(self);
         }
         let journaled = spec.journal || (self.depth == 0 && std::mem::take(&mut self.journal_query));
         if journaled && self.depth == 0 && self.active().is_none_or(|d| d.interaction.is_none()) {
diff --git a/crates/engine/src/store.rs b/crates/engine/src/store.rs
index e54f8deb9..f7fba0a9b 100644
--- a/crates/engine/src/store.rs
+++ b/crates/engine/src/store.rs
@@ -19,6 +19,11 @@
 //!   copied: it is loaded from where it is. `grants.json` holds what the user granted the plug-ins
 //!   stored there that list permissions (id, module hash, permissions); a stored plug-in whose
 //!   permissions it doesn't grant is skipped with a log record, and stays in the folder.
+//! * **Plug-in settings and caches**: `storage/id-<id>/` in the plug-in store, the id written as
+//!   [`case_safe`] writes it, holds what a plug-in
+//!   keeps with the `settings` and `cache` permissions ([`PluginStorage`]): `settings.json` and a
+//!   `cache` folder with one file per entry. The host names every file; a plug-in only names keys.
+//!   Replacing a plug-in keeps them, and `plugin.remove` deletes them.
 //!
 //! The files are untrusted input like any other: sizes and counts are capped, a file that does not
 //! parse is skipped with a log record, and every write is atomic.
@@ -26,9 +31,12 @@
 use std::collections::BTreeMap;
 use std::io::Read;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
 
 use vectorcraft_pdf::{PdfPreset, builtin_preset};
 use vectorcraft_plugins::safe_mode;
+use vectorcraft_plugins::storage::{self, Meter, Storage, StorageError};
 
 use crate::Session;
 use crate::cmd::pdfcmds::{PRESET_FORMAT, PresetFile};
@@ -55,6 +63,25 @@ pub const DISABLED_LOCK: &str = "disabled.lock";
 const GRANTS_FILE: &str = "grants.json";
 /// The largest grants file read.
 const MAX_GRANTS_FILE: u64 = 1 << 20;
+/// The folder in the plug-in store that holds each plug-in's settings and cache.
+const PLUGIN_DATA_DIR: &str = "storage";
+/// A plug-in's settings file, in its folder.
+const SETTINGS_FILE: &str = "settings.json";
+/// Where a settings file that doesn't read is moved, replacing the one moved there before.
+const BAD_SETTINGS_FILE: &str = "settings.unreadable.json";
+/// The folder of a plug-in's cache entries, in its folder.
+const CACHE_DIR: &str = "cache";
+/// The extension of a cache entry's file.
+const CACHE_EXT: &str = "bin";
+/// Items in a cache folder a write looks at, at most: the entries, and temporary files a write left.
+/// A write to a folder that holds more is refused as full.
+pub(crate) const MAX_CACHE_SCAN: usize = storage::MAX_CACHE_ENTRIES * 2;
+/// Held while a plug-in's settings or cache change, so two runs can't pass a cap together or lose
+/// each other's settings.
+static PLUGIN_DATA_LOCK: Mutex<()> = Mutex::new(());
+/// The closed flag of each plug-in folder's storage, shared by every storage made for the folder
+/// until the plug-in is removed, which sets it and drops it.
+static PLUGIN_DATA_OPEN: Mutex<BTreeMap<PathBuf, Arc<AtomicBool>>> = Mutex::new(BTreeMap::new());
 
 /// The file name (without extension) a stored item called `name` gets: its name made safe for any
 /// file system, then a hash of the name, so that names that differ only in characters a file name
@@ -262,8 +289,8 @@ impl Session {
     /// Install the plug-ins kept in the plug-in folder: none in Safe Mode, and none the user
     /// disabled (matched by file name, which is made from the id). The launch marker names each
     /// file while it loads. A module that doesn't load, and one that lists permissions the grants
-    /// there don't grant that very module, is skipped with a log record, and stays in the folder
-    /// with its grant.
+    /// there don't grant that very module ([`grant_covers`]), is skipped with a log record, and
+    /// stays in the folder with its grant.
     pub fn load_stored_plugins(&mut self) {
         let Some(dir) = self.plugin_dir.clone() else { return };
         if safe_mode::active() {
@@ -295,15 +322,19 @@ impl Session {
                 // module stored here load.
                 Ok(plugin) if plugin.manifest().asks_permissions() => {
                     let m = plugin.manifest();
-                    match grants.get(&m.id).filter(|g| g.covers(&m.id, plugin.hash(), &m.permissions())) {
+                    match grants.get(&m.id).filter(|g| grant_covers(g, &plugin)) {
                         Some(g) => {
                             vectorcraft_plugins::registry::grant(g.clone());
+                            vectorcraft_plugins::registry::set_storage(&m.id, plugin_storage(Some(&dir), &m.id));
                             vectorcraft_plugins::registry::install(plugin.with_source(path.display().to_string()));
                         }
-                        None => log::warn!("skipping the stored plug-in {}: the user hasn't approved this module's permissions", path.display()),
+                        None => {
+                            log::warn!("skipping the stored plug-in {}: the user hasn't granted this module the permissions it lists", path.display())
+                        }
                     }
                 }
                 Ok(plugin) => {
+                    vectorcraft_plugins::registry::set_storage(plugin.id(), plugin_storage(Some(&dir), plugin.id()));
                     vectorcraft_plugins::registry::install(plugin.with_source(path.display().to_string()));
                 }
                 Err(e) => log::warn!("skipping the stored plug-in {}: {e}", path.display()),
@@ -347,7 +378,7 @@ impl Session {
 
     /// Whether `plugin` installs without asking the user: it lists no permissions, or this very
     /// module (its id and SHA-256) was granted every one it lists, in the grants of the attached
-    /// plug-in store when there is one, else in this process's
+    /// plug-in store when there is one ([`grant_covers`]), else in this process's
     /// ([`vectorcraft_plugins::registry::approved`]).
     pub(crate) fn plugin_approved(&self, plugin: &vectorcraft_plugins::Plugin) -> bool {
         self.plugin_approver()(plugin)
@@ -360,7 +391,7 @@ impl Session {
         move |plugin| {
             let m = plugin.manifest();
             match &grants {
-                Some(grants) if m.asks_permissions() => grants.get(&m.id).is_some_and(|g| g.covers(&m.id, plugin.hash(), &m.permissions())),
+                Some(grants) if m.asks_permissions() => grants.get(&m.id).is_some_and(|g| grant_covers(g, plugin)),
                 _ => vectorcraft_plugins::registry::approved(plugin),
             }
         }
@@ -449,6 +480,380 @@ impl Session {
             take(dir, &format!("{}.{PLUGIN_EXT}", file_stem(id)));
         }
     }
+
+    /// Keep the settings and cache of plug-in `id` in the attached plug-in store from now on; without
+    /// one, nowhere (its storage calls then fail as unavailable).
+    pub(crate) fn attach_plugin_storage(&self, id: &str) {
+        vectorcraft_plugins::registry::set_storage(id, plugin_storage(self.plugin_dir.as_deref(), id));
+    }
+
+    /// Does the attached plug-in store have a folder of settings and cache for plug-in `id`? A
+    /// folder behind a `storage` folder that is a link is not counted: the plug-in's storage calls
+    /// can't reach it and removing the plug-in leaves it.
+    pub(crate) fn has_plugin_storage(&self, id: &str) -> bool {
+        self.plugin_dir
+            .as_deref()
+            .is_some_and(|dir| !is_link(&dir.join(PLUGIN_DATA_DIR)) && std::fs::symlink_metadata(plugin_data_dir(dir, id)).is_ok())
+    }
+
+    /// Delete the settings and cache of plug-in `id` from the store, and stop keeping any for it.
+    /// The folder is first renamed out of the way (`<folder>.removed`), and that fails, leaving it
+    /// as it was, when the rename does; what the deletion then leaves stays under that name, with a
+    /// log record, and is deleted at the plug-in's next removal.
+    pub(crate) fn remove_plugin_storage(&self, id: &str) -> Result<(), StorageError> {
+        vectorcraft_plugins::registry::set_storage(id, None);
+        let Some(dir) = &self.plugin_dir else { return Ok(()) };
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        let path = plugin_data_dir(dir, id);
+        // Every storage handed out for the folder, including those runs still hold, is closed once
+        // the folder is out of the way; until then they keep working.
+        let close = || {
+            if let Some(closed) = PLUGIN_DATA_OPEN.lock().unwrap_or_else(|e| e.into_inner()).remove(&path) {
+                closed.store(true, Ordering::Release);
+            }
+        };
+        // A `storage` folder that is a link leads out of the store: nothing there is deleted. A link
+        // in place of the plug-in's own folder is removed itself (`remove_dir_all` doesn't follow it).
+        let data = dir.join(PLUGIN_DATA_DIR);
+        if is_link(&data) {
+            log::warn!("{} is a link: the plug-in settings and cache it leads to are left", data.display());
+            close();
+            return Ok(());
+        }
+        let mut aside = path.clone().into_os_string();
+        aside.push(".removed");
+        let aside = PathBuf::from(aside);
+        let _ = std::fs::remove_dir_all(&aside);
+        match std::fs::rename(&path, &aside) {
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+            Err(e) => return Err(StorageError::Io(format!("{}: {e}", path.display()))),
+            Ok(()) => {}
+        }
+        close();
+        if std::fs::symlink_metadata(&aside).is_ok()
+            && let Err(e) = std::fs::remove_dir_all(&aside)
+        {
+            log::warn!("can't delete {}: {e}", aside.display());
+        }
+        Ok(())
+    }
+}
+
+/// `name` (a plug-in id or a cache entry name, ASCII) written for a file name that no other name
+/// gets on a file system that ignores case: `_` is written `__`, each capital letter `_` and the
+/// letter in lower case, and `.` `_0`.
+fn case_safe(name: &str) -> String {
+    let mut file = String::with_capacity(name.len() * 2);
+    for c in name.chars() {
+        match c {
+            '_' => file.push_str("__"),
+            '.' => file.push_str("_0"),
+            c if c.is_ascii_uppercase() => {
+                file.push('_');
+                file.push(c.to_ascii_lowercase());
+            }
+            c => file.push(c),
+        }
+    }
+    file
+}
+
+/// The folder of plug-in `id`'s settings and cache in the plug-in store `dir`. The `id-` in front
+/// keeps an id such as `con` from naming a device on Windows.
+pub(crate) fn plugin_data_dir(dir: &Path, id: &str) -> PathBuf {
+    dir.join(PLUGIN_DATA_DIR).join(format!("id-{}", case_safe(id)))
+}
+
+/// Where plug-in `id` keeps its settings and cache in the plug-in store `dir`.
+fn plugin_storage(dir: Option<&Path>, id: &str) -> Option<Arc<dyn Storage>> {
+    let dir = dir?;
+    let data = plugin_data_dir(dir, id);
+    let closed = PLUGIN_DATA_OPEN.lock().unwrap_or_else(|e| e.into_inner()).entry(data.clone()).or_default().clone();
+    Some(Arc::new(PluginStorage { root: dir.to_path_buf(), dir: data, closed }))
+}
+
+/// The settings and cache of one plug-in, in its folder of the plug-in store (see the module docs).
+/// Keys and entry names are [`storage::valid_name`]s; an entry's file name is its name as
+/// [`case_safe`] writes it, so that names differing only in case get different files. A link
+/// anywhere in the folder's path below the store is refused, and so is a cache file that is not a
+/// plain file.
+pub(crate) struct PluginStorage {
+    /// The plug-in store, and the plug-in's folder in it.
+    root: PathBuf,
+    dir: PathBuf,
+    /// Set, under [`PLUGIN_DATA_LOCK`], once the plug-in is removed; shared by every storage of the
+    /// folder ([`PLUGIN_DATA_OPEN`]).
+    closed: Arc<AtomicBool>,
+}
+
+/// The sizes of `files` added up, at most `u64::MAX`: the sizes come from the file system.
+fn sum_sizes(files: &[(PathBuf, u64)]) -> u64 {
+    files.iter().fold(0, |sum, (_, n)| sum.saturating_add(*n))
+}
+
+/// Is `name` the file name of a cache entry? Entry files end in `.bin` and never start with a `.`
+/// ([`case_safe`] writes no `.`), while the temporary files of `write_atomic` do.
+fn is_entry_file(name: &std::ffi::OsStr) -> bool {
+    name.to_str().is_some_and(|n| !n.starts_with('.') && n.ends_with(&format!(".{CACHE_EXT}")))
+}
+
+/// What a storage call is told when the file system fails.
+fn io(e: &std::io::Error) -> StorageError {
+    StorageError::Io(e.to_string())
+}
+
+/// Does grant `g` cover `plugin`: was it given to this module (the same id and SHA-256) for every
+/// permission the module lists? A module with other bytes under the id needs the user's approval
+/// again, and so doesn't get the settings and cache kept for the id without it. A grant whose hash
+/// is missing or not a valid SHA-256 covers no module.
+fn grant_covers(g: &vectorcraft_plugins::permissions::Grant, plugin: &vectorcraft_plugins::Plugin) -> bool {
+    let m = plugin.manifest();
+    g.covers(&m.id, plugin.hash(), &m.permissions())
+}
+
+/// Is `path` a link (a symbolic link or, on Windows, a junction)?
+fn is_link(path: &Path) -> bool {
+    std::fs::symlink_metadata(path).is_ok_and(|m| m.file_type().is_symlink() || reparse_point(&m))
+}
+
+#[cfg(windows)]
+fn reparse_point(m: &std::fs::Metadata) -> bool {
+    use std::os::windows::fs::MetadataExt;
+    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x400;
+    m.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+}
+
+#[cfg(not(windows))]
+fn reparse_point(_: &std::fs::Metadata) -> bool {
+    false
+}
+
+impl PluginStorage {
+    fn settings_path(&self) -> PathBuf {
+        self.dir.join(SETTINGS_FILE)
+    }
+
+    fn cache_dir(&self) -> PathBuf {
+        self.dir.join(CACHE_DIR)
+    }
+
+    /// The file of the cache entry `name`.
+    fn entry_path(&self, name: &str) -> PathBuf {
+        self.cache_dir().join(format!("{}.{CACHE_EXT}", case_safe(name)))
+    }
+
+    /// Checks that no folder between the store and `path`, nor `path` itself, is a link.
+    fn no_links(&self, path: &Path) -> Result<(), StorageError> {
+        let mut at = path;
+        while at != self.root {
+            if is_link(at) {
+                return Err(StorageError::Unavailable);
+            }
+            match at.parent() {
+                Some(up) => at = up,
+                None => break,
+            }
+        }
+        Ok(())
+    }
+
+    /// The settings, by key. A file that is too large or doesn't parse is moved aside
+    /// ([`BAD_SETTINGS_FILE`]) with a log record, and the settings are empty. `meter` is charged the
+    /// file's size before it is read.
+    fn read_settings(&self, meter: &mut Meter) -> Result<BTreeMap<String, Vec<u8>>, StorageError> {
+        let path = self.settings_path();
+        self.no_links(&path)?;
+        let size = match std::fs::metadata(&path) {
+            Ok(m) => m.len(),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeMap::new()),
+            Err(e) => return Err(io(&e)),
+        };
+        let readable = size <= storage::MAX_SETTINGS_BYTES as u64;
+        if readable {
+            meter.take(size)?;
+        }
+        let parsed = readable
+            .then(|| read_capped(&path, storage::MAX_SETTINGS_BYTES as u64).ok())
+            .flatten()
+            .and_then(|bytes| serde_json::from_slice::<BTreeMap<String, String>>(&bytes).ok())
+            .and_then(|stored| {
+                let decode =
+                    |(k, v): (String, String)| if storage::valid_name(&k) { vectorcraft_format::base64_decode(&v).map(|v| (k, v)) } else { None };
+                let settings: Option<BTreeMap<String, Vec<u8>>> = stored.into_iter().map(decode).collect();
+                settings.filter(|s| s.len() <= storage::MAX_SETTINGS && s.values().all(|v| v.len() <= storage::MAX_SETTING_BYTES))
+            });
+        match parsed {
+            Some(settings) => Ok(settings),
+            None => {
+                let aside = self.dir.join(BAD_SETTINGS_FILE);
+                log::warn!("the plug-in settings {} don't read: moved to {} and started empty", path.display(), aside.display());
+                std::fs::rename(&path, &aside).map_err(|e| io(&e))?;
+                Ok(BTreeMap::new())
+            }
+        }
+    }
+
+    /// Writes `settings` as the settings file, or removes it when there are none. `meter` is charged
+    /// the new file's size before it is written.
+    fn write_settings(&self, settings: &BTreeMap<String, Vec<u8>>, meter: &mut Meter) -> Result<(), StorageError> {
+        let path = self.settings_path();
+        if settings.is_empty() {
+            return match std::fs::remove_file(&path) {
+                Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(io(&e)),
+                _ => Ok(()),
+            };
+        }
+        let stored: BTreeMap<&str, String> = settings.iter().map(|(k, v)| (k.as_str(), vectorcraft_format::base64_encode(v))).collect();
+        let bytes = serde_json::to_vec(&stored).map_err(|e| StorageError::Io(e.to_string()))?;
+        if bytes.len() > storage::MAX_SETTINGS_BYTES {
+            return Err(StorageError::Full);
+        }
+        meter.take(bytes.len() as u64)?;
+        std::fs::create_dir_all(&self.dir).map_err(|e| io(&e))?;
+        self.no_links(&path)?;
+        write_atomic(&path, &bytes).map_err(|e| io(&e))
+    }
+
+    /// Fails with [`StorageError::Unavailable`] once the storage is closed.
+    fn open(&self) -> Result<(), StorageError> {
+        if self.closed.load(Ordering::Acquire) { Err(StorageError::Unavailable) } else { Ok(()) }
+    }
+
+    /// The entries of the cache folder (plain files named as [`Self::entry_path`] names them, which
+    /// leaves out the temporary files of writes) and their sizes, and whether the folder holds more
+    /// than [`MAX_CACHE_SCAN`] items, in which case only the entries among the first that many are
+    /// listed.
+    fn cache_files(&self) -> Result<(Vec<(PathBuf, u64)>, bool), StorageError> {
+        let dir = self.cache_dir();
+        self.no_links(&dir)?;
+        let entries = match std::fs::read_dir(&dir) {
+            Ok(entries) => entries,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok((vec![], false)),
+            Err(e) => return Err(io(&e)),
+        };
+        let mut files = Vec::new();
+        for (seen, e) in entries.enumerate() {
+            if seen == MAX_CACHE_SCAN {
+                return Ok((files, true));
+            }
+            let e = e.map_err(|e| io(&e))?;
+            if is_entry_file(&e.file_name())
+                && let Ok(m) = std::fs::symlink_metadata(e.path())
+                && m.is_file()
+                && !reparse_point(&m)
+            {
+                files.push((e.path(), m.len()));
+            }
+        }
+        Ok((files, false))
+    }
+}
+
+impl Storage for PluginStorage {
+    fn setting(&self, key: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        Ok(self.read_settings(meter)?.remove(key))
+    }
+
+    fn set_setting(&self, key: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let mut settings = self.read_settings(meter)?;
+        if value.len() > storage::MAX_SETTING_BYTES || (!settings.contains_key(key) && settings.len() >= storage::MAX_SETTINGS) {
+            return Err(StorageError::Full);
+        }
+        settings.insert(key.to_string(), value.to_vec());
+        self.write_settings(&settings, meter)
+    }
+
+    fn delete_setting(&self, key: &str, meter: &mut Meter) -> Result<bool, StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let mut settings = self.read_settings(meter)?;
+        if settings.remove(key).is_none() {
+            return Ok(false);
+        }
+        self.write_settings(&settings, meter).map(|()| true)
+    }
+
+    fn cache_entry(&self, name: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let path = self.entry_path(name);
+        self.no_links(&path)?;
+        match std::fs::symlink_metadata(&path) {
+            Ok(m) if m.is_file() && m.len() <= storage::MAX_CACHE_ENTRY as u64 => meter.take(m.len())?,
+            Ok(_) => return Err(StorageError::Unavailable),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+            Err(e) => return Err(io(&e)),
+        }
+        read_capped(&path, storage::MAX_CACHE_ENTRY as u64).map(Some).map_err(StorageError::Io)
+    }
+
+    fn set_cache_entry(&self, name: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let path = self.entry_path(name);
+        let (files, overfull) = self.cache_files()?;
+        if overfull {
+            return Err(StorageError::Full);
+        }
+        let old = files.iter().find(|(p, _)| *p == path).map(|(_, n)| *n);
+        let total = sum_sizes(&files).saturating_sub(old.unwrap_or(0)).saturating_add(value.len() as u64);
+        let too_many = old.is_none() && files.len() >= storage::MAX_CACHE_ENTRIES;
+        if value.len() > storage::MAX_CACHE_ENTRY || total > storage::MAX_CACHE_BYTES || too_many {
+            return Err(StorageError::Full);
+        }
+        meter.take(value.len() as u64)?;
+        std::fs::create_dir_all(self.cache_dir()).map_err(|e| io(&e))?;
+        self.no_links(&path)?;
+        write_atomic(&path, value).map_err(|e| io(&e))
+    }
+
+    fn remove_cache_entry(&self, name: &str) -> Result<bool, StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let path = self.entry_path(name);
+        self.no_links(&path)?;
+        match std::fs::remove_file(&path) {
+            Ok(()) => Ok(true),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false),
+            Err(e) => Err(io(&e)),
+        }
+    }
+
+    fn clear_cache(&self) -> Result<u64, StorageError> {
+        let _held = PLUGIN_DATA_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+        self.open()?;
+        let dir = self.cache_dir();
+        self.no_links(&dir)?;
+        let entries = match std::fs::read_dir(&dir) {
+            Ok(entries) => entries,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(0),
+            Err(e) => return Err(io(&e)),
+        };
+        // Every plain file, one at a time as the folder is read, past the ones a write looks at too.
+        let mut freed = 0_u64;
+        for e in entries {
+            let path = e.map_err(|e| io(&e))?.path();
+            if let Ok(m) = std::fs::symlink_metadata(&path)
+                && m.is_file()
+                && !reparse_point(&m)
+            {
+                std::fs::remove_file(&path).map_err(|e| io(&e))?;
+                freed = freed.saturating_add(m.len());
+            }
+        }
+        Ok(freed)
+    }
+
+    fn cache_bytes(&self) -> u64 {
+        if self.open().is_err() {
+            return 0;
+        }
+        self.cache_files().map(|(files, _)| sum_sizes(&files)).unwrap_or(0)
+    }
 }
 
 /// What the grants file of a plug-in store holds.
diff --git a/crates/engine/src/tests/colormgmt.rs b/crates/engine/src/tests/colormgmt.rs
index f841efedc..d0901f30a 100644
--- a/crates/engine/src/tests/colormgmt.rs
+++ b/crates/engine/src/tests/colormgmt.rs
@@ -374,7 +374,7 @@ fn rgb_art_separates_with_gcr() {
         RenderOptions { proof: Some(ProofSetup { separations: Some(vec!["Black".into()]), ..Default::default() }), ..Default::default() },
     )
     .pixel(50, 50);
-    assert!(k[0] < 20, "RGB black is mostly K: {k:?}");
+    assert!((20..=30).contains(&k[0]), "RGB black carries 90% black: {k:?}");
     let c = render(
         &doc,
         RenderOptions { proof: Some(ProofSetup { separations: Some(vec!["Cyan".into()]), ..Default::default() }), ..Default::default() },
diff --git a/crates/engine/src/tests/eyedropper.rs b/crates/engine/src/tests/eyedropper.rs
index 786c492da..f8363fe93 100644
--- a/crates/engine/src/tests/eyedropper.rs
+++ b/crates/engine/src/tests/eyedropper.rs
@@ -333,8 +333,8 @@ fn an_rgb_image_sampled_in_a_cmyk_document_separates_through_the_color_settings(
     let got = node(&s, dst).appearance.fill_paint().color().unwrap();
     assert_eq!(got, managed_cmyk(Color::rgb8(83, 170, 223)));
     let Color::Cmyk { c, m, y, k } = got else { panic!("{got:?}") };
-    // Generic CMYK: about C59 M12 Y3 K0, with no black, where the formula gave K13.
-    assert!((0.5..0.75).contains(&c) && (0.05..0.2).contains(&m) && y < 0.05 && k < 0.02, "{c} {m} {y} {k}");
+    // Generic CMYK: about C62 M19 Y0 K0, with no black, where the formula gave K13.
+    assert!((0.5..0.75).contains(&c) && (0.1..0.25).contains(&m) && y < 0.05 && k < 0.02, "{c} {m} {y} {k}");
     // A light blue shows close to the color it was picked from; the formula's C12 M7 showed duller.
     click(&mut s, 450.0, 50.0, Mods::default());
     let got = node(&s, dst).appearance.fill_paint().color().unwrap();
diff --git a/crates/engine/src/tests/fontlist.rs b/crates/engine/src/tests/fontlist.rs
index d0804b7d0..6202a8ce7 100644
--- a/crates/engine/src/tests/fontlist.rs
+++ b/crates/engine/src/tests/fontlist.rs
@@ -14,7 +14,11 @@ fn names(v: &Value) -> Vec<String> {
 fn the_font_list_names_every_available_family_with_its_styles() {
     let mut s = Session::new();
     let fams = names(&s.execute("text.fontList", &json!({})).unwrap()["families"]);
-    assert_eq!(fams, *FontDb::global().menu_family_list());
+    // Other tests running at the same time add and remove composite fonts, which the lists show
+    // first; the installed families are compared.
+    let db = FontDb::global();
+    let installed_only = |list: &[String]| list.iter().filter(|f| db.has_installed_family(f)).cloned().collect::<Vec<_>>();
+    assert_eq!(installed_only(&fams), installed_only(&db.menu_family_list()));
     for f in ["Source Sans 3", "Source Serif 4", "Inter", "JetBrains Mono"] {
         assert!(fams.iter().any(|x| x == f), "{f}");
     }
diff --git a/crates/engine/src/tests/history_document.rs b/crates/engine/src/tests/history_document.rs
index 0c78b1109..3c2c9b9eb 100644
--- a/crates/engine/src/tests/history_document.rs
+++ b/crates/engine/src/tests/history_document.rs
@@ -1,5 +1,6 @@
 //! History panel › New Document from State (`edit.newDocumentFromState`).
 
+use std::path::Path;
 use std::sync::Arc;
 
 use serde_json::{Value, json};
@@ -262,7 +263,72 @@ fn a_file_the_source_finds_in_its_folder_is_found_from_the_new_document() {
     s.execute(CMD, &json!({})).unwrap();
     assert_eq!(s.active_index(), Some(1), "the new document");
     let c = check(&mut s);
-    assert_eq!((&c["links"][0]["status"], &c["links"][0]["path"]), (&json!("ok"), &json!(moved)), "{c}");
+    assert_eq!((&c["links"][0]["status"], c["links"][0]["path"].as_str().map(Path::new)), (&json!("ok"), Some(Path::new(&moved))), "{c}");
+}
+
+/// A linked file missing from the moved source keeps the place its relative path names from the
+/// source's folder: the new document, saved beside the source, writes the same relative path.
+#[test]
+fn a_missing_file_keeps_its_relative_path_in_the_new_document() {
+    let a = Folder::new("history-document-missing-a");
+    let b = Folder::new("history-document-missing-b");
+    let away = Folder::new("history-document-missing-away");
+    write(&a.file("art/photo.png"), &png(60, 30, RED));
+    let mut s = session();
+    place(&mut s, &a.file("art/photo.png"));
+    s.execute("document.save", &json!({"path": a.file("poster.vectorcraft")})).unwrap();
+    std::fs::remove_dir_all(&b.0).unwrap();
+    std::fs::rename(&a.0, &b.0).unwrap();
+    std::fs::rename(b.0.join("art"), away.0.join("art")).unwrap();
+    let r = s.execute("document.open", &json!({"path": b.file("poster.vectorcraft")})).unwrap();
+    assert_eq!(r["missingLinks"][0]["name"], "photo.png", "{r}");
+    s.execute(CMD, &json!({})).unwrap();
+    let copy = b.file("copy.vectorcraft");
+    s.execute("document.save", &json!({"path": copy})).unwrap();
+    let saved: Value = serde_json::from_slice(&std::fs::read(&copy).unwrap()).unwrap();
+    let link = &saved["document"]["layers"][0]["kind"]["children"][0]["kind"]["link"];
+    assert_eq!(link["relative"].as_str(), Some("art/photo.png"), "{link}");
+}
+
+/// A linked file that comes back beside the document the source was read from, after the source
+/// was saved in another folder, is found from the new document.
+#[test]
+fn a_file_back_beside_the_source_it_was_read_from_is_found_from_the_new_document() {
+    let a = Folder::new("history-document-back-a");
+    let b = Folder::new("history-document-back-b");
+    let away = Folder::new("history-document-back-away");
+    write(&a.file("art/photo.png"), &png(60, 30, RED));
+    let mut s = session();
+    place(&mut s, &a.file("art/photo.png"));
+    s.execute("document.save", &json!({"path": a.file("poster.vectorcraft")})).unwrap();
+    std::fs::remove_dir_all(&b.0).unwrap();
+    std::fs::rename(&a.0, &b.0).unwrap();
+    std::fs::rename(b.0.join("art"), away.0.join("art")).unwrap();
+    s.execute("document.open", &json!({"path": b.file("poster.vectorcraft")})).unwrap();
+    std::fs::create_dir_all(b.0.join("saved")).unwrap();
+    s.execute("document.save", &json!({"path": b.file("saved/poster.vectorcraft")})).unwrap();
+    std::fs::rename(away.0.join("art"), b.0.join("art")).unwrap();
+    let source = s.active_index().unwrap();
+    s.execute(CMD, &json!({})).unwrap();
+    let c = s.execute("links.check", &json!({})).unwrap();
+    let moved = b.file("art/photo.png");
+    assert_eq!((&c["links"][0]["status"], c["links"][0]["path"].as_str().map(Path::new)), (&json!("ok"), Some(Path::new(&moved))), "{c}");
+    // A file beside the folder the source was last saved in is found too.
+    std::fs::create_dir_all(b.0.join("saved/art")).unwrap();
+    std::fs::rename(&moved, b.file("saved/art/photo.png")).unwrap();
+    s.execute("document.activate", &json!({"index": source})).unwrap();
+    s.execute(CMD, &json!({})).unwrap();
+    let c = s.execute("links.check", &json!({})).unwrap();
+    let saved = b.file("saved/art/photo.png");
+    assert_eq!((&c["links"][0]["status"], c["links"][0]["path"].as_str().map(Path::new)), (&json!("ok"), Some(Path::new(&saved))), "{c}");
+    // Missing again when the new document is saved, the file keeps the place it was found.
+    std::fs::rename(&saved, away.file("photo.png")).unwrap();
+    std::fs::create_dir_all(b.0.join("new")).unwrap();
+    let copy = b.file("new/copy.vectorcraft");
+    s.execute("document.save", &json!({"path": copy})).unwrap();
+    let file: Value = serde_json::from_slice(&std::fs::read(&copy).unwrap()).unwrap();
+    let link = &file["document"]["layers"][0]["kind"]["children"][0]["kind"]["link"];
+    assert_eq!(link["relative"].as_str(), Some("../saved/art/photo.png"), "{link}");
 }
 
 /// The same holds for a linked image only a symbol shows.
diff --git a/crates/engine/src/tests/ids_without_selection.rs b/crates/engine/src/tests/ids_without_selection.rs
index f8449c104..8e26577f9 100644
--- a/crates/engine/src/tests/ids_without_selection.rs
+++ b/crates/engine/src/tests/ids_without_selection.rs
@@ -135,8 +135,9 @@ fn id_does_what_ids_of_one_does_with_nothing_selected() {
 
 /// Every command that takes `id` as `ids` of one ([`cmd::params::id_stands_for_ids`]), with an
 /// object selected: an `id` that is malformed (a string, negative, a fraction, an object) or names
-/// no object is refused under the command's id, as the same value in `ids` is, and the document
-/// and the selection stay as they were. It never stands for the selection instead. (A string `id`
+/// no object is refused under the command's id, as the same value in `ids` is (whose error for a
+/// malformed entry also names the key and the entry), and the document and the selection stay as
+/// they were. It never stands for the selection instead. (A string `id`
 /// given to `effect.apply` without `effect` names the effect, which "bad" isn't: refused too.)
 #[test]
 fn a_bad_id_is_refused_as_the_same_ids_are_and_changes_nothing() {
@@ -158,7 +159,10 @@ fn a_bad_id_is_refused_as_the_same_ids_are_and_changes_nothing() {
                 let st = s.doc().unwrap();
                 (r, st.doc == before && st.selection.objects == vec![NodeId(d)])
             };
-            let (with_id, with_ids) = (run("id", bad.clone()), run("ids", json!([bad.clone()])));
+            let (with_id, mut with_ids) = (run("id", bad.clone()), run("ids", json!([bad.clone()])));
+            // The error for an `ids` entry names the key and the entry; the one for `id` names the value.
+            let entry = format!("`ids` entry 0 is {bad}, not a non-negative integer object id");
+            with_ids.0 = with_ids.0.map_err(|e| e.replace(&entry, &format!("invalid object id {bad}: expected a non-negative integer")));
             let effect_named = spec.id == "effect.apply" && bad.is_string();
             if with_id.0.is_ok() || !with_id.1 || (with_id != with_ids && !effect_named) {
                 failures.push(format!(
@@ -301,3 +305,205 @@ fn ids_of_an_object_and_a_group_that_holds_it_do_what_that_selection_does() {
     assert!(failures.is_empty(), "{} differ:\n{}", failures.len(), failures.join("\n"));
     assert!(succeeded >= 150, "only {succeeded} runs succeeded");
 }
+
+/// What `ids` (or `slices`) left out or null gives a command: the selection, or the command's own
+/// default.
+enum Unset {
+    /// The selected objects: a result, the same as the list of the selection gives.
+    Selected,
+    /// The selected objects, which the command refuses with this error, as it refuses the list of
+    /// the selection.
+    SelectionRefused(&'static str),
+    /// This error, which the list of the selection does not give.
+    Fails(&'static str),
+    /// This result, which the list of the selection does not give.
+    Gives(serde_json::Value),
+}
+
+/// The commands that read their `ids` (or `slices`) list themselves or pass it to a colour pass,
+/// with the rectangle apart (`d`): the key, the other params, and what leaving the key out gives.
+fn ids_cases(d: u64) -> Vec<(&'static str, &'static str, serde_json::Value, Unset)> {
+    use Unset::*;
+    vec![
+        ("appearance.copyFrom", "ids", json!({ "source": d }), Selected),
+        ("edit.colors.invert", "ids", json!({}), Selected),
+        ("edit.colors.toCMYK", "ids", json!({}), Selected),
+        ("edit.colors.toGrayscale", "ids", json!({}), Selected),
+        ("edit.colors.toRGB", "ids", json!({}), Selected),
+        ("edit.colors.saturate", "ids", json!({"intensity": 50}), Selected),
+        ("edit.colors.adjustBalance", "ids", json!({"r": 20}), Selected),
+        ("paint.invert", "ids", json!({}), Selected),
+        ("paint.complement", "ids", json!({}), Selected),
+        ("addon.color.filter", "ids", json!({"effect": "addon.color.invert"}), Selected),
+        ("addon.color.applyNearestSwatch", "ids", json!({}), Selected),
+        ("edit.colors.overprintBlack", "ids", json!({}), Selected),
+        ("edit.findReplace", "ids", json!({"find": "A", "replace": "B"}), Gives(json!({"count": 1}))),
+        ("layer.highlight", "ids", json!({}), Fails("missing ids")),
+        ("layer.move", "ids", json!({ "target": d }), Fails("missing ids")),
+        ("library.add", "ids", json!({"kind": "graphic"}), Selected),
+        ("library.add", "ids", json!({"kind": "fillColor"}), Selected),
+        ("links.check", "ids", json!({}), Selected),
+        ("links.update", "ids", json!({}), Selected),
+        ("links.relink", "ids", json!({"path": "missing.png"}), Fails("select the images to relink, or pass ids")),
+        ("links.embed", "ids", json!({}), Fails("select the linked images or placed documents, or pass ids")),
+        ("links.placementOptions", "ids", json!({}), Fails("select the images, or pass ids")),
+        ("object.transform", "ids", json!({"matrix": [1, 0, 0, 1, 10, 0]}), Selected),
+        ("object.pattern.make", "ids", json!({"name": "P"}), Selected),
+        ("object.repeat.radial", "ids", json!({}), Selected),
+        ("object.repeat.grid", "ids", json!({}), Selected),
+        ("object.repeat.mirror", "ids", json!({}), Selected),
+        ("object.slice.make", "ids", json!({}), Selected),
+        ("object.slice.move", "slices", json!({"dx": 1, "dy": 1}), Selected),
+        ("object.slice.delete", "slices", json!({}), Selected),
+        ("object.slice.select", "slices", json!({}), Gives(json!({"selected": []}))),
+        ("path.join", "ids", json!({}), SelectionRefused("path is already closed")),
+        ("path.averageJoin", "ids", json!({"to": "corner"}), SelectionRefused("select two open path ends, or two open paths, to average and join")),
+        ("symbol.edit", "ids", json!({}), Fails("the document has no symbols")),
+        ("transparency.makeOpacityMask", "ids", json!({}), Selected),
+    ]
+}
+
+/// What `cmd` does in a fresh [`doc_with_type`] with `selected` selected (made an object slice
+/// first when `slice`): its result or error, the document, the selection and the undo history's
+/// length.
+fn outcome(
+    cmd: &str,
+    p: &serde_json::Value,
+    selected: &[u64],
+    slice: bool,
+) -> (std::result::Result<serde_json::Value, String>, vectorcraft_doc::Document, vectorcraft_doc::Selection, usize) {
+    let (mut s, ..) = doc_with_type();
+    if slice {
+        s.execute("object.slice.make", &json!({ "ids": selected })).unwrap();
+    }
+    s.execute("select.set", &json!({ "ids": selected })).unwrap();
+    let r = s.execute(cmd, p).map_err(|e| e.to_string());
+    let st = s.doc().unwrap();
+    (r, (*st.doc).clone(), st.selection.clone(), st.history.undo.len())
+}
+
+/// With the rectangle apart (`d`) selected and with nothing selected, a list with an entry that is
+/// not a non-negative integer (a string, true, an object) is refused with an error naming the key,
+/// the entry and its value, a value that is not a list with an error naming the key, and the
+/// document, the selection and the undo history stay as they were. No entry is dropped. A list of
+/// the rectangle is not refused.
+#[test]
+fn an_ids_entry_that_is_not_an_id_is_refused_and_changes_nothing() {
+    let (_, [.., d], _) = doc_with_type();
+    let mut failures = vec![];
+    for (cmd, key, params, _) in &ids_cases(d) {
+        let bads = [json!(["abc"]), json!([d, true]), json!([{}]), json!("abc")];
+        for (bad, selected) in bads.iter().flat_map(|b| [(b, true), (b, false)]) {
+            // A fresh document each time, so no mode one case enters carries into the next.
+            let (mut s, ..) = doc_with_type();
+            if selected {
+                s.execute("select.set", &json!({ "ids": [d] })).unwrap();
+            }
+            let st = s.doc().unwrap();
+            let before = (st.doc.clone(), st.selection.clone(), st.history.undo.len());
+            let mut p = params.clone();
+            p[*key] = bad.clone();
+            let r = s.execute(cmd, &p);
+            let want = match bad.as_array() {
+                Some(a) => {
+                    let (index, value) = a.iter().enumerate().find(|(_, v)| !v.is_u64()).unwrap();
+                    format!("`{key}` entry {index} is {value}, not a non-negative integer object id")
+                }
+                None => format!("{key} must be an array of non-negative integer object ids"),
+            };
+            match &r {
+                Err(EngineError::BadParams { cmd: c, msg }) if c == cmd && *msg == want => {}
+                r => failures.push(format!("{cmd} {key}: {bad} (selected: {selected}): {r:.160?}")),
+            }
+            let st = s.doc().unwrap();
+            if (st.doc.clone(), st.selection.clone(), st.history.undo.len()) != before {
+                failures.push(format!("{cmd} {key}: {bad} (selected: {selected}): the document, the selection or the undo history changed"));
+            }
+        }
+        let (mut s, ..) = doc_with_type();
+        s.execute("select.set", &json!({ "ids": [d] })).unwrap();
+        let mut p = params.clone();
+        p[*key] = json!([d]);
+        if let Err(EngineError::BadParams { msg, .. }) = s.execute(cmd, &p)
+            && (msg.starts_with(&format!("`{key}` entry ")) || msg.starts_with(&format!("{key} must be an array")))
+        {
+            failures.push(format!("{cmd} {key}: [{d}] is refused: {msg}"));
+        }
+    }
+    assert!(failures.is_empty(), "{} fail:\n{}", failures.len(), failures.join("\n"));
+}
+
+/// With the rectangle apart (`d`) selected, the same commands with `ids` (or `slices`) left out and
+/// with it null do the same: what the selection's list does for the commands that take the
+/// selection, and the command's own default for the others (`object.slice.select` deselects the
+/// slices). `addon.color.filter` and `addon.color.applyNearestSwatch` read `ids` through
+/// [`cmd::checked_ids_or_selection`], which refuses null as a value that is not a list and changes
+/// nothing.
+#[test]
+fn ids_left_out_or_null_take_the_selection_or_the_default() {
+    let (_, [.., d], _) = doc_with_type();
+    let mut failures = vec![];
+    for (cmd, key, params, unset) in ids_cases(d) {
+        // The commands on `slices` act on the selected object once it is an object slice.
+        let slice = key == "slices";
+        let left_out = outcome(cmd, &params, &[d], slice);
+        let mut null = params.clone();
+        null[key] = serde_json::Value::Null;
+        let with_null = outcome(cmd, &null, &[d], slice);
+        if matches!(cmd, "addon.color.filter" | "addon.color.applyNearestSwatch") {
+            let (mut s, ..) = doc_with_type();
+            s.execute("select.set", &json!({ "ids": [d] })).unwrap();
+            let st = s.doc().unwrap();
+            let refused = with_null.0.as_ref().is_err_and(|e| e.ends_with("ids must be an array of non-negative integer object ids"));
+            if !refused || (&with_null.1, &with_null.2, with_null.3) != (&*st.doc, &st.selection, st.history.undo.len()) {
+                failures.push(format!("{cmd} {key}: null is not refused with nothing changed ({:.160?})", with_null.0));
+            }
+        } else if with_null != left_out {
+            failures.push(format!("{cmd} {key}: null does not do what leaving it out does ({:.160?})", left_out.0));
+        }
+        let mut listed = params.clone();
+        listed[key] = json!([d]);
+        let listed = outcome(cmd, &listed, &[d], slice);
+        let ok = match &unset {
+            Unset::Selected => left_out.0.is_ok() && listed == left_out,
+            Unset::SelectionRefused(want) => left_out.0.as_ref().is_err_and(|e| e.ends_with(want)) && listed == left_out,
+            Unset::Fails(want) => left_out.0.as_ref().is_err_and(|e| e.ends_with(want)) && listed.0 != left_out.0,
+            Unset::Gives(want) => left_out.0.as_ref() == Ok(want) && listed.0 != left_out.0,
+        };
+        if !ok {
+            failures.push(format!("{cmd} {key}: left out: {:.200?}; listed: {:.200?}", left_out.0, listed.0));
+        }
+    }
+    assert!(failures.is_empty(), "{} fail:\n{}", failures.len(), failures.join("\n"));
+}
+
+/// With no document open, every command that takes `ids` refuses a list with an entry that is not
+/// a non-negative integer, and a value that is not a list, with the same error as with a document
+/// open (`effect.list` and `links.findFiles` run without a document).
+#[test]
+fn an_ids_entry_that_is_not_an_id_is_refused_with_no_document() {
+    let (mut failures, mut checked) = (vec![], 0);
+    for spec in command_specs() {
+        if !cmd::params::takes_key(spec.params, "ids") {
+            continue;
+        }
+        checked += 1;
+        for bad in [json!(["abc"]), json!([1, true]), json!("abc")] {
+            let mut s = Session::new();
+            let r = s.execute(spec.id, &json!({ "ids": bad }));
+            let want = match bad.as_array() {
+                Some(a) => {
+                    let (index, value) = a.iter().enumerate().find(|(_, v)| !v.is_u64()).unwrap();
+                    format!("`ids` entry {index} is {value}, not a non-negative integer object id")
+                }
+                None => "ids must be an array of non-negative integer object ids".to_string(),
+            };
+            match &r {
+                Err(EngineError::BadParams { cmd: c, msg }) if c == spec.id && *msg == want => {}
+                r => failures.push(format!("{} ids: {bad}: {r:.160?}", spec.id)),
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{} fail:\n{}", failures.len(), failures.join("\n"));
+    assert!(checked >= 100, "only {checked} commands take ids");
+}
diff --git a/crates/engine/src/tests/link_paths.rs b/crates/engine/src/tests/link_paths.rs
index 76bd7168a..e39cf6689 100644
--- a/crates/engine/src/tests/link_paths.rs
+++ b/crates/engine/src/tests/link_paths.rs
@@ -85,6 +85,21 @@ fn linked_files_on_other_computers_are_never_read() {
     assert!(s.link_stamps.keys().all(|(_, p)| !far.contains(p)), "{:?}", s.link_stamps.keys());
 }
 
+/// A place a link names from the file the document was read from is followed only when the
+/// document's own file follows it too: after a document read from a network share is saved on
+/// this computer, its links are not looked for on that share.
+#[test]
+fn places_named_from_a_share_are_not_followed_after_a_save_elsewhere() {
+    use crate::cmd::links::follow_from;
+    let resolve =
+        |stored: &str, doc: Option<&str>| craft_docpath::resolve(stored, doc.map(std::path::Path::new)).map(|p| p.to_string_lossy().into_owned());
+    let (link, on_share) = (r"\\server\share\a\art\photo.png", Some(r"\\server\share\a\poster.vectorcraft"));
+    assert_eq!(follow_from(link, on_share, on_share, resolve).as_deref(), Some(link));
+    assert_eq!(follow_from(link, on_share, Some(r"\\server\share\b\poster.vectorcraft"), resolve).as_deref(), Some(link));
+    assert_eq!(follow_from(link, on_share, Some("/local/b/poster.vectorcraft"), resolve), None);
+    assert_eq!(follow_from(link, on_share, Some(r"C:\b\poster.vectorcraft"), resolve), None);
+}
+
 /// The final path Windows gives a folder of the drive `Z:` mapped to `\\server\share`. The
 /// share's root folder has no trailing separator (`\\?\UNC\server\share`).
 fn on_share(folder: &str) -> Option<std::path::PathBuf> {
diff --git a/crates/engine/src/tests/links.rs b/crates/engine/src/tests/links.rs
index cfe43ee8e..f0a0674f0 100644
--- a/crates/engine/src/tests/links.rs
+++ b/crates/engine/src/tests/links.rs
@@ -244,6 +244,141 @@ fn the_relative_path_finds_the_file_after_the_folder_moves() {
     assert!(near(centre_colour(&s.doc().unwrap().doc), RED));
 }
 
+/// A document moved to another folder while its linked file is missing keeps the file's relative
+/// path when it is saved again, there or in a subfolder, so the file is found once it is back
+/// beside the document.
+#[test]
+fn a_missing_link_keeps_its_relative_path_when_the_moved_document_is_saved() {
+    let a = Folder::new("missing-save-a");
+    let b = Folder::new("missing-save-b");
+    let away = Folder::new("missing-save-away");
+    let pic = a.file("art/photo.png");
+    write(&pic, &png(600, 300, RED));
+    let mut s = session();
+    let id = place(&mut s, &pic);
+    save(&mut s, &a.file("poster.vectorcraft"));
+    // Move the document and its links, then take the links away.
+    std::fs::remove_dir_all(&b.0).unwrap();
+    std::fs::rename(&a.0, &b.0).unwrap();
+    std::fs::rename(b.0.join("art"), away.0.join("art")).unwrap();
+    let r = open(&mut s, &b.file("poster.vectorcraft"));
+    assert_eq!(r["missingLinks"][0]["name"].as_str(), Some("photo.png"), "{r}");
+    save(&mut s, &b.file("poster.vectorcraft"));
+    std::fs::create_dir_all(b.0.join("copies")).unwrap();
+    save(&mut s, &b.file("copies/poster.vectorcraft"));
+    let relative = |path: &str| {
+        let mut saved: Value = serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap();
+        saved_image(&mut saved)["link"]["relative"].as_str().map(str::to_string)
+    };
+    assert_eq!(relative(&b.file("poster.vectorcraft")).as_deref(), Some("art/photo.png"));
+    assert_eq!(relative(&b.file("copies/poster.vectorcraft")).as_deref(), Some("../art/photo.png"));
+    // Saved again where the last save put it, the file is still named from the folder it was read from.
+    s.execute("document.save", &json!({})).unwrap();
+    assert_eq!(relative(&b.file("copies/poster.vectorcraft")).as_deref(), Some("../art/photo.png"));
+    // The links come back: both saved documents find the file.
+    std::fs::rename(away.0.join("art"), b.0.join("art")).unwrap();
+    let moved = b.file("art/photo.png");
+    for doc in [b.file("poster.vectorcraft"), b.file("copies/poster.vectorcraft")] {
+        let r = open(&mut s, &doc);
+        assert_eq!(&r["missingLinks"], &json!([]), "{doc}: {r}");
+        assert_eq!(Path::new(&image(&s, id).link.unwrap().path), Path::new(&moved), "{doc}");
+    }
+}
+
+/// A file found by name in the document's folder, then missing before the next save, keeps the
+/// place it was last found: the saved relative path names that place, not the folder its old
+/// relative path named.
+#[test]
+fn a_file_found_elsewhere_then_missing_keeps_the_place_it_was_found() {
+    let dir = Folder::new("found-then-missing");
+    let pic = dir.file("art/photo.png");
+    write(&pic, &png(600, 300, RED));
+    let mut s = session();
+    let id = place(&mut s, &pic);
+    let doc = dir.file("poster.vectorcraft");
+    save(&mut s, &doc);
+    let beside = dir.file("photo.png");
+    std::fs::rename(&pic, &beside).unwrap();
+    let r = open(&mut s, &doc);
+    assert_eq!(&r["missingLinks"], &json!([]), "{r}");
+    assert_eq!(Path::new(&image(&s, id).link.unwrap().path), Path::new(&beside));
+    let away = dir.file("away.png");
+    std::fs::rename(&beside, &away).unwrap();
+    save(&mut s, &doc);
+    let mut saved: Value = serde_json::from_slice(&std::fs::read(&doc).unwrap()).unwrap();
+    assert_eq!(saved_image(&mut saved)["link"]["relative"].as_str(), Some("photo.png"));
+}
+
+/// After a save in another folder, a file Update Links finds by name beside the saved document,
+/// then missing before the next save, keeps the place it was found.
+#[test]
+fn a_file_update_links_finds_after_a_save_elsewhere_keeps_its_place() {
+    let a = Folder::new("update-after-save-as-a");
+    let b = Folder::new("update-after-save-as-b");
+    let pic = a.file("art/photo.png");
+    write(&pic, &png(600, 300, RED));
+    let mut s = session();
+    let id = place(&mut s, &pic);
+    save(&mut s, &a.file("poster.vectorcraft"));
+    open(&mut s, &a.file("poster.vectorcraft"));
+    let doc = b.file("poster.vectorcraft");
+    save(&mut s, &doc);
+    let beside = b.file("photo.png");
+    std::fs::rename(&pic, &beside).unwrap();
+    let r = s.execute("links.update", &json!({"ids": [id.0]})).unwrap();
+    assert_eq!(&r["missing"], &json!([]), "{r}");
+    assert_eq!(Path::new(&image(&s, id).link.unwrap().path), Path::new(&beside));
+    std::fs::remove_file(&beside).unwrap();
+    s.execute("document.save", &json!({})).unwrap();
+    let mut saved: Value = serde_json::from_slice(&std::fs::read(&doc).unwrap()).unwrap();
+    assert_eq!(saved_image(&mut saved)["link"]["relative"].as_str(), Some("photo.png"));
+}
+
+/// A file found at its relative path from the folder of the last save, away from its path and from
+/// the folder the document was read from, is written relative to where it was found.
+#[test]
+fn a_file_found_beside_the_last_save_is_written_where_it_was_found() {
+    let a = Folder::new("found-beside-save-a");
+    let b = Folder::new("found-beside-save-b");
+    let c = Folder::new("found-beside-save-c");
+    write(&a.file("art/photo.png"), &png(600, 300, RED));
+    let mut s = session();
+    place(&mut s, &a.file("art/photo.png"));
+    save(&mut s, &a.file("poster.vectorcraft"));
+    open(&mut s, &a.file("poster.vectorcraft"));
+    save(&mut s, &b.file("poster.vectorcraft"));
+    std::fs::rename(a.0.join("art"), b.0.join("art")).unwrap();
+    save(&mut s, &c.file("poster.vectorcraft"));
+    let r = open(&mut s, &c.file("poster.vectorcraft"));
+    assert_eq!(&r["missingLinks"], &json!([]), "{r}");
+}
+
+/// After a moved document with a missing link is saved in another folder, `links.check` finds the
+/// file once it is back at the place its relative path names from the folder the document was
+/// read from, which is where the saved file looks for it too.
+#[test]
+fn a_missing_link_comes_back_where_the_document_saved_elsewhere_looks_for_it() {
+    let a = Folder::new("check-after-save-as-a");
+    let b = Folder::new("check-after-save-as-b");
+    let c = Folder::new("check-after-save-as-c");
+    let away = Folder::new("check-after-save-as-away");
+    write(&a.file("art/photo.png"), &png(600, 300, RED));
+    let mut s = session();
+    place(&mut s, &a.file("art/photo.png"));
+    save(&mut s, &a.file("poster.vectorcraft"));
+    std::fs::remove_dir_all(&b.0).unwrap();
+    std::fs::rename(&a.0, &b.0).unwrap();
+    std::fs::rename(b.0.join("art"), away.0.join("art")).unwrap();
+    open(&mut s, &b.file("poster.vectorcraft"));
+    save(&mut s, &c.file("poster.vectorcraft"));
+    std::fs::rename(away.0.join("art"), b.0.join("art")).unwrap();
+    let r = s.execute("links.check", &json!({})).unwrap();
+    let found = r["links"][0]["found"].as_str().map(Path::new);
+    assert_eq!((r["missing"].as_u64(), found), (Some(0), Some(Path::new(&b.file("art/photo.png")))), "{r}");
+    let r = open(&mut s, &c.file("poster.vectorcraft"));
+    assert_eq!(&r["missingLinks"], &json!([]), "{r}");
+}
+
 /// Links in symbols, graph designs, patterns and opacity masks are saved with their relative
 /// paths, as links in the layers are: after the folder moves, each file is found and its link takes
 /// the new path, which the next save writes relative to the document again.
@@ -781,7 +916,7 @@ fn low_res_proxy_eps_export_uses_full_resolution_from_the_linked_file() {
     assert_eq!((r["modifiedLinks"].clone(), r["updatedLinks"].clone()), (json!([]), json!([])), "{r}");
     let key = image(&s, id).key;
     assert!(s.doc().unwrap().doc.images[&key].is_proxy());
-    let (full, warnings) = cmd::links::full_linked_images(&s.doc().unwrap().doc, None);
+    let (full, warnings) = cmd::links::full_linked_images(&s.doc().unwrap().doc, Default::default());
     assert!(warnings.is_empty(), "{warnings:?}");
     assert!(!full.images[&key].is_proxy());
     let dim =
@@ -812,7 +947,7 @@ fn export_reads_a_found_svg_link_into_its_own_images_only() {
 
     let bytes = png(20, 20, RED);
     write(&dir.file("a.png"), &bytes);
-    let (full, warnings) = cmd::links::full_linked_images(&s.doc().unwrap().doc, None);
+    let (full, warnings) = cmd::links::full_linked_images(&s.doc().unwrap().doc, Default::default());
     assert_eq!(warnings.len(), 1, "b.png is still missing: {warnings:?}");
     assert_eq!(*full.images[&a.key].bytes, bytes, "a.png's pixels");
     assert_eq!(full.images[&b.key].bytes, placeholder, "b.png keeps its placeholder");
@@ -845,7 +980,7 @@ fn export_reads_a_changed_svg_link_into_its_own_images_only() {
     let doc = &s.doc().unwrap().doc;
     assert!(doc.images[&a.key].is_proxy() && doc.images[&b.key].is_proxy(), "previews");
     let preview = doc.images[&a.key].bytes.clone();
-    let (full, warnings) = cmd::links::full_linked_images(doc, None);
+    let (full, warnings) = cmd::links::full_linked_images(doc, Default::default());
     assert_eq!(warnings.len(), 1, "a.png is missing: {warnings:?}");
     assert_eq!(*full.images[&b.key].bytes, blue, "b.png's new pixels");
     assert_eq!(full.images[&a.key].bytes, preview, "a.png keeps its preview");
@@ -1002,7 +1137,7 @@ fn relative_paths_are_written_against_the_saved_file() {
     };
     d.insert(Some(lid), 0, vectorcraft_doc::Node::new(nid, NodeKind::Image(Box::new(im)))).unwrap();
     let rel = |dest: String| {
-        let d = cmd::links::with_relative_paths(&d, &dest).unwrap_or_else(|| d.clone());
+        let d = cmd::links::with_relative_paths(&d, Default::default(), &dest).unwrap_or_else(|| d.clone());
         match &d.node(nid).unwrap().kind {
             NodeKind::Image(im) => im.link.as_ref().unwrap().relative.clone(),
             _ => None,
@@ -1083,15 +1218,11 @@ fn links_of_an_imported_file_are_read_where_they_are_found() {
     assert!((im.width, im.height) == (600, 300) && !s.doc().unwrap().doc.images[&im.key].is_proxy(), "{im:?}");
 }
 
-/// A placed file of a `.ai` file whose folder moved with the document is found by the folder the
-/// file keeps relative to the document's (`src/`), and its link takes the size, modification time
-/// and hash of the file found there. Not found, the link keeps no such details.
-#[test]
-fn links_of_an_imported_file_are_found_by_their_relative_folder() {
+/// `poster.ai` in `dir`, a `.ai` file another app wrote, placing `src/photo.png` (relative to it)
+/// under a path that no longer exists → its path.
+fn imported_with_placed_file(dir: &Folder) -> String {
     use vectorcraft_testkit::ai;
-    let dir = Folder::new("imported-relative");
     std::fs::create_dir_all(dir.0.join("src")).unwrap();
-    let pic = dir.file("src/photo.png").replace('\\', "/");
     let place = "%AI5_BeginPlace\n%%FileType: 1\n[0.1 0 0 -0.1 20 80] 0 0 600 300 4 4 0\n(/no/such/folder/src/photo.png)`\n\
          %%IncludeFile:/no/such/folder/src/photo.png\n%AI17_Begin_Content_if_version_gt:24 12\n%AI28_BeginPlacedRelativePath\n(src/)\n\
          %AI28_EndPlacedRelativePath\n%AI17_Alternate_Content\n%AI17_End_Versioned_Content\n%AI26_BeginPlacedObjectPreview\n\
@@ -1099,6 +1230,17 @@ fn links_of_an_imported_file_are_found_by_their_relative_folder() {
     let doc_path = dir.file("poster.ai");
     let data = ai::editing_data(200.0, 100.0, &ai::layer("Art", place));
     write(&doc_path, &ai::ai(data.as_bytes(), "0.56 0.56 0.87 rg 20 50 60 30 re f"));
+    doc_path
+}
+
+/// A placed file of a `.ai` file whose folder moved with the document is found by the folder the
+/// file keeps relative to the document's (`src/`), and its link takes the size, modification time
+/// and hash of the file found there. Not found, the link keeps no such details.
+#[test]
+fn links_of_an_imported_file_are_found_by_their_relative_folder() {
+    let dir = Folder::new("imported-relative");
+    let pic = dir.file("src/photo.png").replace('\\', "/");
+    let doc_path = imported_with_placed_file(&dir);
     let link = |s: &Session| {
         let mut found = vec![];
         s.doc().unwrap().doc.visit_images(|_, im| found.push(im.clone()));
@@ -1112,9 +1254,16 @@ fn links_of_an_imported_file_are_found_by_their_relative_folder() {
     let (l, proxy) = link(&s);
     assert_eq!((l.path.as_str(), l.relative.as_deref()), ("/no/such/folder/src/photo.png", Some("src/photo.png")));
     assert!(proxy && l.size.is_none() && l.modified.is_none() && l.hash.is_none(), "{l:?}");
+    // Saved beside it while the file is missing, the document keeps the folder the file is in.
+    let native = dir.file("poster.vectorcraft");
+    save(&mut s, &native);
+    let mut saved: Value = serde_json::from_slice(&std::fs::read(&native).unwrap()).unwrap();
+    assert_eq!(saved_image(&mut saved)["link"]["relative"].as_str(), Some("src/photo.png"));
 
     let bytes = png(600, 300, RED);
     write(&pic, &bytes);
+    let r = open(&mut s, &native);
+    assert_eq!(&r["missingLinks"], &json!([]), "the native copy finds the file: {r}");
     let r = open(&mut s, &doc_path);
     assert_eq!(&r["missingLinks"], &json!([]), "{r}");
     let (l, proxy) = link(&s);
@@ -1123,3 +1272,27 @@ fn links_of_an_imported_file_are_found_by_their_relative_folder() {
     assert_eq!((l.size, l.hash.clone()), (Some(bytes.len() as u64), Some(vectorcraft_doc::links::hash_bytes(&bytes))));
     assert!(l.modified.is_some(), "{l:?}");
 }
+
+/// A Data Recovery copy of such a document keeps the file its links' relative paths name places
+/// from: restored and saved beside the `.ai` file, it keeps the folder the placed file is in.
+#[test]
+fn a_recovered_copy_of_an_imported_file_keeps_its_links_folder() {
+    let dir = Folder::new("imported-recovered");
+    let doc_path = imported_with_placed_file(&dir);
+    let store = std::sync::Arc::new(crate::cmd::recovery::MemoryStore::default());
+    let mut s = session();
+    s.recovery.set_store(store.clone());
+    open(&mut s, &doc_path);
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+    let r = s.execute("file.recovery.save", &json!({})).unwrap();
+    assert_eq!(r["saved"].as_array().map(Vec::len), Some(1), "{r}");
+    drop(s);
+    let mut s = Session::new();
+    s.recovery.set_store(store);
+    let r = s.execute("file.recovery.restore", &json!({})).unwrap();
+    assert_eq!(r["restored"].as_array().map(Vec::len), Some(1), "{r}");
+    let native = dir.file("poster.vectorcraft");
+    save(&mut s, &native);
+    let mut saved: Value = serde_json::from_slice(&std::fs::read(&native).unwrap()).unwrap();
+    assert_eq!(saved_image(&mut saved)["link"]["relative"].as_str(), Some("src/photo.png"));
+}
diff --git a/crates/engine/src/tests/menucmds.rs b/crates/engine/src/tests/menucmds.rs
index 4e6100df9..1bc75a82a 100644
--- a/crates/engine/src/tests/menucmds.rs
+++ b/crates/engine/src/tests/menucmds.rs
@@ -2104,7 +2104,7 @@ fn type_menu_and_find_commands_refuse_a_param_of_the_wrong_type() {
     let switch = |k: &str| format!("`{k}` must be true or false");
     let scope = "`scope` must be one of selection, document".to_string();
     let not_a_list = "ids must be an array of non-negative integer object ids".to_string();
-    let not_an_id = "invalid object id \"x\": expected a non-negative integer".to_string();
+    let not_an_id = |entry: usize| format!("`ids` entry {entry} is \"x\", not a non-negative integer object id");
     for (cmd, p, want) in [
         ("edit.findReplace", json!({"find": "cat", "replace": 5}), string("replace")),
         ("edit.findReplace", json!({"find": 5, "replace": "dog"}), string("find")),
@@ -2112,7 +2112,8 @@ fn type_menu_and_find_commands_refuse_a_param_of_the_wrong_type() {
         ("edit.findReplace", json!({"find": "cat", "replace": "dog", "wholeWord": "yes"}), switch("wholeWord")),
         ("edit.findReplace", json!({"find": "cat", "replace": "dog", "ids": t.0}), not_a_list),
         ("edit.findReplace", json!({"find": "cat", "replace": "dog", "ids": [t.0, 999_999]}), "no such object id 999999".to_string()),
-        ("edit.findReplace", json!({"find": "cat", "replace": "dog", "ids": ["x"]}), not_an_id),
+        ("edit.findReplace", json!({"find": "cat", "replace": "dog", "ids": ["x"]}), not_an_id(0)),
+        ("edit.findReplace", json!({"find": "cat", "replace": "dog", "ids": [t.0, "x"]}), not_an_id(1)),
         ("edit.findNext", json!({"find": ["cat"]}), string("find")),
         ("edit.findNext", json!({"find": "cat", "matchCase": 1}), switch("matchCase")),
         ("edit.findNext", json!({"find": "cat", "wholeWord": "false"}), switch("wholeWord")),
@@ -4462,7 +4463,7 @@ fn k_only(c: Color) -> f32 {
 fn document_color_mode_separates_rgb_greys_through_the_profile() {
     let (mut s, ids, _, _) = greys_document();
     s.execute("file.documentColorMode", &json!({"mode": "cmyk"})).unwrap();
-    // As Illustrator converts them: four-colour greys and a rich black.
+    // Through the profile: a mid gray in four inks and a rich black.
     let Color::Cmyk { c, m, y, k } = fill_of(&s, ids[2]) else { panic!("not CMYK") };
     assert!(c > 0.05 && m > 0.05 && y > 0.05 && k > 0.0, "a four-colour mid grey: {c} {m} {y} {k}");
     let Color::Cmyk { c, k, .. } = fill_of(&s, ids[0]) else { panic!("not CMYK") };
diff --git a/crates/engine/src/tests/objexpand.rs b/crates/engine/src/tests/objexpand.rs
index 4210a1d96..6c5c05572 100644
--- a/crates/engine/src/tests/objexpand.rs
+++ b/crates/engine/src/tests/objexpand.rs
@@ -925,11 +925,12 @@ fn a_freeform_gradient_expands_with_the_inks_of_its_points() {
     for c in expanded(&mut s, 1.0) {
         assert!(close_inks(inks(c), [0.5, 0.2, 0.0, 0.1]), "{c:?}");
     }
-    // Cyan and black points mix as inks: cyan and black only, adding up to one.
+    // Cyan and black points mix as inks: cyan and black only, adding up to one. The gradient blends
+    // the points' display colors and the mesh blends their inks, so the two draw a little apart in between.
     let mut s = session();
     let (cyan, black) = (ink(1.0, 0.0, 0.0, 0.0), ink(0.0, 0.0, 0.0, 1.0));
     freeform_rect(&mut s, Rect::new(20.0, 20.0, 180.0, 180.0), [cyan.clone(), cyan.clone(), black.clone(), black]);
-    for c in expanded(&mut s, 5.0) {
+    for c in expanded(&mut s, 7.5) {
         let [c, m, y, k] = inks(c);
         assert!(m.abs() < 1e-5 && y.abs() < 1e-5 && (c + k - 1.0).abs() < 1e-5, "C{c} M{m} Y{y} K{k}");
     }
diff --git a/crates/engine/src/tests/package.rs b/crates/engine/src/tests/package.rs
index dcf3c6217..e15258bec 100644
--- a/crates/engine/src/tests/package.rs
+++ b/crates/engine/src/tests/package.rs
@@ -253,6 +253,103 @@ fn a_missing_link_is_reported_not_copied() {
     assert!(report.contains("blue.png: not found"), "{report}");
 }
 
+/// 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");
diff --git a/crates/engine/src/tests/placed_document.rs b/crates/engine/src/tests/placed_document.rs
index 5f989db78..5871b85a3 100644
--- a/crates/engine/src/tests/placed_document.rs
+++ b/crates/engine/src/tests/placed_document.rs
@@ -489,7 +489,7 @@ fn a_placed_document_without_its_bytes_or_a_hash_is_reported_not_read() {
     let Some(NodeKind::PlacedDocument(p)) = d.node_mut(id).map(|n| &mut n.kind) else { panic!("a placed document") };
     p.link.hash = None;
     p.link.size = None;
-    let r = crate::cmd::links::resolve(&mut d, None, false, false).to_json();
+    let r = crate::cmd::links::resolve(&mut d, crate::cmd::links::LinkBase::file(None), false, false).to_json();
     assert_eq!(r["modifiedLinks"].as_array().map(Vec::len), Some(1), "{r}");
     assert!(!d.images.contains_key(&key), "not read");
 }
diff --git a/crates/engine/src/tests/plugins.rs b/crates/engine/src/tests/plugins.rs
index 2dbcccb2b..61d864142 100644
--- a/crates/engine/src/tests/plugins.rs
+++ b/crates/engine/src/tests/plugins.rs
@@ -17,8 +17,9 @@ fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
     s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
 }
 
+/// Installs `wasm`, in place of any module installed with its id (`replace: true`).
 fn install(s: &mut Session, wasm: &[u8]) -> Value {
-    run(s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(wasm)}))
+    run(s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(wasm), "replace": true}))
 }
 
 fn install_wat(s: &mut Session, src: &str) -> Value {
@@ -74,6 +75,52 @@ fn object_filter_recolours_the_selection_as_one_undo_step() {
     assert!(matches!(s.execute("plugin.run", &json!({"id": DESATURATE_ID, "amount": "all"})), Err(EngineError::BadParams { .. })));
 }
 
+/// `plugin.run` refuses an `ids` list with an entry that is not an object id, with an error naming
+/// the key, the entry and its value, and changes nothing. With `ids` left out or null the filter
+/// runs on the selection, as it does on the list of the selection.
+#[test]
+fn object_filter_ids_entries_must_be_ids_and_ids_left_out_take_the_selection() {
+    // A session with the plug-in, a red and a blue rectangle, and the red one selected. The
+    // document has no creation date, so documents made in different seconds compare equal.
+    let fresh = || {
+        let mut s = Session::new();
+        run(&mut s, "file.new", json!({"width": 400, "height": 200, "created": null}));
+        install(&mut s, DESATURATE);
+        let a = rect(&mut s, 10.0, "#ff0000");
+        let b = rect(&mut s, 40.0, "#0000ff");
+        run(&mut s, "select.set", json!({"ids": [a.0]}));
+        (s, a, b)
+    };
+    let (_, a, b) = fresh();
+    for (bad, entry) in [(json!(["abc"]), r#"entry 0 is "abc""#), (json!([a.0, true]), "entry 1 is true"), (json!([{}]), "entry 0 is {}")] {
+        let (mut s, ..) = fresh();
+        let st = s.doc().unwrap();
+        let before = (st.doc.clone(), st.selection.clone(), st.history.undo.len());
+        let r = s.execute("plugin.run", &json!({"id": DESATURATE_ID, "amount": 100, "ids": bad}));
+        let want = format!("`ids` {entry}, not a non-negative integer object id");
+        assert!(matches!(&r, Err(EngineError::BadParams { cmd, msg }) if cmd == "plugin.run" && *msg == want), "{bad}: {r:?}");
+        let st = s.doc().unwrap();
+        assert!((st.doc.clone(), st.selection.clone(), st.history.undo.len()) == before, "{bad}: something changed");
+    }
+    let gray = |s: &Session, id: NodeId| {
+        let [r, g, b] = node(s, id).appearance.fill_paint().color().unwrap().to_rgb_uncalibrated();
+        (r - g).abs() < 1e-6 && (g - b).abs() < 1e-6
+    };
+    let mut docs = vec![];
+    for ids in [None, Some(Value::Null), Some(json!([a.0]))] {
+        let (mut s, ..) = fresh();
+        let mut p = json!({"id": DESATURATE_ID, "amount": 100});
+        if let Some(ids) = &ids {
+            p["ids"] = ids.clone();
+        }
+        let r = run(&mut s, "plugin.run", p);
+        assert_eq!(r["ids"], json!([a.0]), "{ids:?}");
+        assert!(gray(&s, a) && !gray(&s, b), "{ids:?}: only the selected rectangle turns gray");
+        docs.push(s.doc().unwrap().doc.clone());
+    }
+    assert!(docs.windows(2).all(|w| w[0] == w[1]), "left out, null and the selection's list give the same document");
+}
+
 #[test]
 fn object_filters_add_replace_and_generate_objects() {
     let mut s = session();
@@ -532,9 +579,9 @@ fn asking(id: &str, permissions: &str, output: &Value) -> Vec<u8> {
 
 /// A plug-in whose manifest lists permissions installs only once they are all granted (`grant`),
 /// which `plugin.inspect` tells beforehand (`needsApproval`) with the permissions and the module's
-/// hash. The grant is recorded with that hash and covers only that module: one with other bytes
-/// needs a new grant. Removing it forgets the grant. A plug-in without `permissions` installs as
-/// before, with the ones its kind implies.
+/// hash. The grant is recorded with that hash and covers only that module: replacing the plug-in
+/// (`replace: true`) with one with other bytes needs a new grant. Removing it forgets the grant. A
+/// plug-in without `permissions` installs as before, with the ones its kind implies.
 #[test]
 fn a_plugin_that_lists_permissions_installs_once_they_are_granted() {
     let mut s = session();
@@ -573,15 +620,16 @@ fn a_plugin_that_lists_permissions_installs_once_they_are_granted() {
     // Replaced with another module that lists the same permissions: granted again, the grant now
     // records the new module's hash.
     let other = asking(id, r#"["doc.read"]"#, &json!({"objects": [], "error": null}));
-    run(&mut s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&other), "grant": ["doc.read"]}));
+    assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": vectorcraft_format::base64_encode(&other)}))["needsApproval"], true);
+    run(&mut s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&other), "grant": ["doc.read"], "replace": true}));
     assert_eq!(vectorcraft_plugins::registry::granted(id).unwrap().hash, vectorcraft_plugins::permissions::sha256_hex(&other));
     // One that asks for more is refused until it is granted all of them.
     let more = data(r#"["doc.read","doc.write"]"#);
     assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": more}))["needsApproval"], true);
-    let e = s.execute("plugin.install", &json!({"dataBase64": more})).unwrap_err().to_string();
+    let e = s.execute("plugin.install", &json!({"dataBase64": more, "replace": true})).unwrap_err().to_string();
     assert!(e.contains("doc.read, doc.write") && e.contains("`grant`"), "{e}");
     assert_eq!(vectorcraft_plugins::registry::get(id).unwrap().manifest().permissions().len(), 1, "the one installed stays");
-    run(&mut s, "plugin.install", json!({"dataBase64": more, "grant": ["doc.write", "doc.read", "state"]}));
+    run(&mut s, "plugin.install", json!({"dataBase64": more, "grant": ["doc.write", "doc.read", "state"], "replace": true}));
     assert_eq!(vectorcraft_plugins::registry::granted(id).unwrap().permissions.len(), 2, "only what it lists is recorded");
     // Removed, it is asked again.
     run(&mut s, "plugin.remove", json!({"id": id}));
@@ -608,9 +656,9 @@ fn a_grant_covers_only_the_module_that_was_approved() {
     let (first_hash, changed_hash) = (sha256_hex(&first), sha256_hex(&changed));
     run(&mut s, "plugin.install", json!({"dataBase64": first_data, "grant": ["doc.read"]}));
     assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": changed_data}))["needsApproval"], true);
-    let e = s.execute("plugin.install", &json!({"dataBase64": changed_data})).unwrap_err().to_string();
+    let e = s.execute("plugin.install", &json!({"dataBase64": changed_data, "replace": true})).unwrap_err().to_string();
     assert!(e.contains("doc.read") && e.contains("`grant`"), "{e}");
-    let e = s.execute("plugin.install", &json!({"dataBase64": changed_data, "hash": changed_hash})).unwrap_err().to_string();
+    let e = s.execute("plugin.install", &json!({"dataBase64": changed_data, "replace": true, "hash": changed_hash})).unwrap_err().to_string();
     assert!(e.contains("`grant`"), "`hash` is not an approval: {e}");
     assert_eq!(vectorcraft_plugins::registry::get(id).unwrap().hash(), first_hash, "the installed module stays");
     assert_eq!(vectorcraft_plugins::registry::granted(id).unwrap().hash, first_hash, "its grant stays");
@@ -618,7 +666,7 @@ fn a_grant_covers_only_the_module_that_was_approved() {
     assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": first_data}))["needsApproval"], false);
     run(&mut s, "plugin.install", json!({"dataBase64": first_data}));
     // A new grant installs the changed module, and the old bytes are no longer covered.
-    run(&mut s, "plugin.install", json!({"dataBase64": changed_data, "grant": ["doc.read"], "hash": changed_hash}));
+    run(&mut s, "plugin.install", json!({"dataBase64": changed_data, "grant": ["doc.read"], "hash": changed_hash, "replace": true}));
     assert_eq!(vectorcraft_plugins::registry::get(id).unwrap().hash(), changed_hash);
     assert_eq!(vectorcraft_plugins::registry::granted(id).unwrap().hash, changed_hash);
     assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": first_data}))["needsApproval"], true);
@@ -629,7 +677,7 @@ fn a_grant_covers_only_the_module_that_was_approved() {
     for (permissions, out) in [("null", json!({"objects": []})), ("null", json!({"objects": [], "error": null})), ("[]", json!({"objects": []}))] {
         let data = vectorcraft_format::base64_encode(&asking(exempt, permissions, &out));
         assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": data}))["needsApproval"], false, "{permissions}");
-        run(&mut s, "plugin.install", json!({"dataBase64": data}));
+        run(&mut s, "plugin.install", json!({"dataBase64": data, "replace": true}));
     }
     run(&mut s, "plugin.remove", json!({"id": exempt}));
 }
@@ -640,7 +688,7 @@ fn a_grant_covers_only_the_module_that_was_approved() {
 #[test]
 fn a_stored_grant_covers_only_the_stored_module_it_recorded() {
     use vectorcraft_plugins::permissions::{Grant, Permission, sha256_hex};
-    let folder = crate::tests_links::Folder::new("plugin-store-grant-hash");
+    let folder = crate::tests_links::Folder::new("plugin-store-recorded-module");
     let id = "test.engine.permissions.storedbytes";
     let first = asking(id, r#"["doc.read"]"#, &json!({"objects": []}));
     let changed = asking(id, r#"["doc.read"]"#, &json!({"objects": [], "error": null}));
@@ -702,7 +750,7 @@ fn a_failed_store_write_keeps_the_stored_module_with_its_grant() {
     let first = asking(id, r#"["doc.read"]"#, &json!({"objects": []}));
     let changed = asking(id, r#"["doc.read","doc.write"]"#, &json!({"objects": []}));
     let first_data = vectorcraft_format::base64_encode(&first);
-    let update = json!({"dataBase64": vectorcraft_format::base64_encode(&changed), "grant": ["doc.read", "doc.write"]});
+    let update = json!({"dataBase64": vectorcraft_format::base64_encode(&changed), "grant": ["doc.read", "doc.write"], "replace": true});
     let mut s = session();
     s.attach_plugin_store(folder.0.clone());
     run(&mut s, "plugin.install", json!({"dataBase64": first_data, "grant": ["doc.read"]}));
@@ -781,7 +829,7 @@ fn a_plugin_folder_skips_a_changed_module_until_it_is_approved() {
     let plain = "test.engine.permissions.folderplain";
     let first = asking(id, r#"["doc.read"]"#, &json!({"objects": []}));
     let changed = asking(id, r#"["doc.read"]"#, &json!({"objects": [], "error": null}));
-    let dir = crate::tests_links::Folder::new("plugin-folder-grant-hash");
+    let dir = crate::tests_links::Folder::new("plugin-folder-changed-module");
     let file = dir.0.join("asks.wasm");
     std::fs::write(&file, &first).unwrap();
     std::fs::write(dir.0.join("plain.wasm"), asking(plain, "null", &json!({"objects": []}))).unwrap();
@@ -801,7 +849,7 @@ fn a_plugin_folder_skips_a_changed_module_until_it_is_approved() {
     let hash = vectorcraft_plugins::permissions::sha256_hex(&first);
     assert_eq!(vectorcraft_plugins::registry::get(id).unwrap().hash(), hash, "the module installed earlier stays");
 
-    run(&mut s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&changed), "grant": ["doc.read"]}));
+    run(&mut s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&changed), "grant": ["doc.read"], "replace": true}));
     let r = run(&mut s, "plugin.reload", path);
     assert_eq!(r["failed"], json!([]), "approved on its own, it loads: {r}");
     run(&mut s, "plugin.remove", json!({"id": id}));
@@ -817,7 +865,7 @@ fn a_filter_does_only_what_its_permissions_allow() {
     let id = rect(&mut s, 10.0, "#ff0000");
     let filter = |s: &mut Session, pid: &str| s.execute("plugin.run", &json!({"id": pid, "ids": [id.0]}));
     let grant = |s: &mut Session, wasm: &[u8], perms: Value| {
-        run(s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(wasm), "grant": perms}));
+        run(s, "plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(wasm), "grant": perms, "replace": true}));
     };
     // Denied `doc.write`: renaming the object is refused, and the document and history stay.
     let reader = "test.engine.permissions.reader";
@@ -961,6 +1009,59 @@ fn granted_permissions_are_kept_and_folders_skip_the_rest() {
     run(&mut granted, "plugin.remove", json!({"id": id}));
 }
 
+/// A grant covers the module it was given to: another module under the id, listing the same
+/// permissions, isn't installed from the store at the next start, a folder load reports it as
+/// needing approval, and `plugin.install` asks for `grant` again, even with `replace: true`. It
+/// doesn't get the settings kept for the id until the user grants it. A kept grant without a hash
+/// covers no module.
+#[test]
+fn a_grant_covers_only_the_module_it_was_given_to() {
+    let folder = crate::tests_links::Folder::new("plugin-store-grant-hash");
+    let id = "test.engine.granthash";
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, WRITES);
+    run(&mut s, "plugin.run", json!({"id": id, "ids": []}));
+    // The stored module is replaced on disk by one that reads the settings.
+    let other = storing(id, READS);
+    let stored: Vec<_> =
+        std::fs::read_dir(&folder.0).unwrap().map(|e| e.unwrap().path()).filter(|p| p.extension().is_some_and(|x| x == "wasm")).collect();
+    assert_eq!(stored.len(), 1, "{stored:?}");
+    std::fs::write(&stored[0], &other).unwrap();
+    vectorcraft_plugins::registry::remove(id);
+    vectorcraft_plugins::registry::revoke(id);
+    let mut next = session();
+    next.attach_plugin_store(folder.0.clone());
+    assert!(vectorcraft_plugins::registry::get(id).is_none(), "another module isn't loaded under the grant");
+    let dir = crate::tests_links::Folder::new("plugin-folder-grant-hash");
+    std::fs::write(dir.0.join("other.wasm"), &other).unwrap();
+    let r = run(&mut next, "plugin.reload", json!({"path": dir.0.display().to_string()}));
+    assert_eq!(r["loaded"], json!([]));
+    let why = r["failed"][0]["error"].as_str().unwrap();
+    assert!(why.contains("needs approval"), "{why}");
+    let data = vectorcraft_format::base64_encode(&other);
+    let e = next.execute("plugin.install", &json!({"dataBase64": data, "replace": true})).unwrap_err().to_string();
+    assert!(e.contains("`grant`"), "{e}");
+    // Granted, it reads the settings the first module set.
+    run(&mut next, "plugin.install", json!({"dataBase64": data, "grant": ["settings", "cache"], "replace": true}));
+    run(&mut next, "plugin.run", json!({"id": id, "ids": []}));
+
+    // A kept grant that records no hash, or an empty one, covers no module: the stored module isn't
+    // installed at the next start and `plugin.inspect` asks for approval.
+    for entry in [json!({"id": id, "permissions": ["settings", "cache"]}), json!({"id": id, "hash": "", "permissions": ["settings", "cache"]})] {
+        std::fs::write(folder.0.join("grants.json"), serde_json::to_vec(&json!([entry])).unwrap()).unwrap();
+        vectorcraft_plugins::registry::remove(id);
+        vectorcraft_plugins::registry::revoke(id);
+        let mut again = session();
+        again.attach_plugin_store(folder.0.clone());
+        assert!(vectorcraft_plugins::registry::get(id).is_none(), "a grant without a hash doesn't load the module: {entry}");
+        assert_eq!(run(&mut again, "plugin.inspect", json!({"dataBase64": data}))["needsApproval"], json!(true), "{entry}");
+        next = again;
+    }
+    run(&mut next, "plugin.install", json!({"dataBase64": data, "grant": ["settings", "cache"], "replace": true}));
+    run(&mut next, "plugin.remove", json!({"id": id}));
+}
+
 /// A grants file entry this version can't use (a permission it doesn't know, an invalid id) is
 /// skipped without dropping the other grants, and recording a grant writes it back as it was,
 /// except an entry for the plug-in being granted or removed. A grants file that doesn't parse as a
@@ -1102,7 +1203,7 @@ fn a_filter_run_made_elsewhere_keeps_its_document_data() {
     let manifest = format!(r#"{{"id":"{id}","name":"Test {id}","version":"1","kind":"filter","budget":"heavy"}}"#);
     let install = |s: &mut Session, src: String| {
         let data = vectorcraft_format::base64_encode(&wat::parse_str(src).unwrap());
-        run(s, "plugin.install", json!({"dataBase64": data, "allowHeavy": true}));
+        run(s, "plugin.install", json!({"dataBase64": data, "allowHeavy": true, "replace": true}));
     };
     // It first keeps the pens it found with the document.
     install(&mut s, tpl::returning(&manifest, &json!({"objects": [], "documentData": {"pens": 2}}).to_string()));
@@ -1168,3 +1269,379 @@ fn a_cancelled_filter_run_changes_nothing() {
     assert!(matches!(r, Err(EngineError::Cancelled)), "{r:?}");
     assert_eq!(s.doc().unwrap().doc, before);
 }
+
+/// A filter `id` of API level 2 that lists `settings` and `cache`, whose `vc_run` runs `first`
+/// (instructions that trap unless each storage call returns what it should), with the keys "zoom"
+/// at 0x2000 and "tile" at 0x2004 and the value "hello" at 0x2100.
+fn storing(id: &str, first: &str) -> Vec<u8> {
+    let manifest = format!(r#"{{"id":"{id}","name":"Test {id}","kind":"filter","api":2,"permissions":["settings","cache"]}}"#);
+    let data = format!(r#"{} (data (i32.const 0x2000) "zoomtile") (data (i32.const 0x2100) "hello")"#, tpl::STORAGE_IMPORTS);
+    wat::parse_str(tpl::with_imports(&manifest, &data, first, r#"{"objects":[]}"#)).unwrap()
+}
+
+/// Sets "zoom" to "hello" and writes "hel" to the cache entry "tile".
+const WRITES: &str = "(if (call $vc_settings_set (i32.const 0x2000) (i32.const 4) (i32.const 0x2100) (i32.const 5)) (then unreachable))
+    (if (call $vc_cache_write (i32.const 0x2004) (i32.const 4) (i32.const 0x2100) (i32.const 3)) (then unreachable))";
+
+/// Traps unless "zoom" is "hello".
+const READS: &str =
+    "(if (i32.ne (call $vc_settings_get (i32.const 0x2000) (i32.const 4) (i32.const 0x3000) (i32.const 16)) (i32.const 5)) (then unreachable))
+    (if (i32.ne (i32.load (i32.const 0x3000)) (i32.load (i32.const 0x2100))) (then unreachable))";
+
+fn install_storing(s: &mut Session, id: &str, first: &str) -> Value {
+    let data = vectorcraft_format::base64_encode(&storing(id, first));
+    run(s, "plugin.install", json!({"dataBase64": data, "grant": ["settings", "cache"]}))
+}
+
+/// [`install_storing`] in place of another module with the same id (`replace: true`).
+fn replace_storing(s: &mut Session, id: &str, first: &str) -> Value {
+    let data = vectorcraft_format::base64_encode(&storing(id, first));
+    run(s, "plugin.install", json!({"dataBase64": data, "grant": ["settings", "cache"], "replace": true}))
+}
+
+/// A plug-in's settings and cache are kept in the plug-in store under its id: the next session
+/// has them, replacing the plug-in keeps them, another plug-in can't read them, `plugin.clearCache`
+/// empties the cache alone and `plugin.remove` deletes both. The caps and the bytes each call is
+/// charged follow ([`plugin_storage_is_capped_and_survives_a_damaged_settings_file`],
+/// [`plugin_storage_calls_are_charged_the_files_they_read_and_write`]) in the same test, since
+/// clearing every plug-in's cache would empty theirs.
+#[test]
+fn plugins_keep_settings_and_a_cache_of_their_own_in_the_store() {
+    let folder = crate::tests_links::Folder::new("plugin-storage");
+    let (id, other) = ("test.engine.storing", "test.engine.storing.other");
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, WRITES);
+    run(&mut s, "plugin.run", json!({"id": id, "ids": []}));
+    let dir = crate::store::plugin_data_dir(&folder.0, id);
+    assert!(dir.join("settings.json").is_file());
+    assert_eq!(run(&mut s, "plugin.info", json!({"id": id}))["cacheBytes"], json!(3));
+
+    // A restart: installed again from the store, and replaced by a module that reads.
+    vectorcraft_plugins::registry::remove(id);
+    let mut next = session();
+    next.attach_plugin_store(folder.0.clone());
+    let listed = run(&mut next, "plugin.list", json!({}));
+    let entry = listed["plugins"].as_array().unwrap().iter().find(|p| p["id"] == id).cloned().unwrap();
+    assert_eq!(entry["cacheBytes"], json!(3));
+    assert_eq!(replace_storing(&mut next, id, READS)["cacheBytes"], json!(3));
+    run(&mut next, "plugin.run", json!({"id": id, "ids": []}));
+
+    // Another plug-in has settings of its own: "zoom" isn't set there.
+    install_storing(&mut next, other, READS);
+    assert!(next.execute("plugin.run", &json!({"id": other, "ids": []})).is_err());
+
+    // Clearing the cache leaves the settings.
+    assert_eq!(run(&mut next, "plugin.clearCache", json!({"id": id})), json!({"cleared": [id], "bytesFreed": 3}));
+    assert_eq!(run(&mut next, "plugin.info", json!({"id": id}))["cacheBytes"], json!(0));
+    run(&mut next, "plugin.run", json!({"id": id, "ids": []}));
+    replace_storing(&mut next, other, WRITES);
+    run(&mut next, "plugin.run", json!({"id": other, "ids": []}));
+    let all = run(&mut next, "plugin.clearCache", json!({}));
+    let cleared = all["cleared"].as_array().unwrap();
+    assert!(cleared.contains(&json!(id)) && cleared.contains(&json!(other)) && all["bytesFreed"] == json!(3), "{all}");
+    assert_eq!(run(&mut next, "plugin.info", json!({"id": other}))["cacheBytes"], json!(0));
+    assert!(next.execute("plugin.clearCache", &json!({"id": "test.engine.storing.missing"})).is_err());
+
+    run(&mut next, "plugin.remove", json!({"id": id}));
+    assert!(!dir.exists(), "removed with the plug-in");
+    run(&mut next, "plugin.remove", json!({"id": other}));
+    plugin_storage_is_capped_and_survives_a_damaged_settings_file();
+    plugin_storage_calls_are_charged_the_files_they_read_and_write();
+}
+
+/// A `storage` folder in the plug-in store that is a link leads out of the store: the plug-in
+/// installs without `replace` although a folder for its id is there, its storage calls fail as
+/// unavailable, and removing the plug-in deletes nothing the link leads to.
+#[test]
+fn plugin_storage_behind_a_link_is_left_alone() {
+    let folder = crate::tests_links::Folder::new("plugin-storage-link");
+    let outside = crate::tests_links::Folder::new("plugin-storage-outside");
+    #[cfg(unix)]
+    let made = std::os::unix::fs::symlink(&outside.0, folder.0.join("storage")).is_ok();
+    // Without Developer Mode or elevation Windows makes no symbolic link, but a junction.
+    #[cfg(windows)]
+    let made = std::os::windows::fs::symlink_dir(&outside.0, folder.0.join("storage")).is_ok()
+        || std::process::Command::new("cmd")
+            .args(["/C", "mklink", "/J"])
+            .arg(folder.0.join("storage"))
+            .arg(&outside.0)
+            .output()
+            .is_ok_and(|o| o.status.success());
+    #[cfg(not(any(unix, windows)))]
+    let made = false;
+    if !made {
+        eprintln!("skipped: symbolic links can't be made here");
+        return;
+    }
+    let id = "test.engine.storagelink";
+    let kept = crate::store::plugin_data_dir(&folder.0, id).join("settings.json");
+    std::fs::create_dir_all(kept.parent().unwrap()).unwrap();
+    std::fs::write(&kept, b"{}").unwrap();
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, "");
+    let st = vectorcraft_plugins::registry::storage(id).unwrap();
+    let m = &mut vectorcraft_plugins::storage::Meter::unlimited();
+    assert_eq!(st.set_setting("zoom", b"hello", m), Err(vectorcraft_plugins::storage::StorageError::Unavailable));
+    run(&mut s, "plugin.remove", json!({"id": id}));
+    assert!(kept.is_file(), "left where the link leads");
+}
+
+/// `plugin.remove` with the id of a plug-in that isn't installed deletes the settings and cache the
+/// plug-in store still keeps for it; with neither, it fails as before.
+#[test]
+fn removing_an_id_that_is_not_installed_deletes_its_storage() {
+    let folder = crate::tests_links::Folder::new("plugin-storage-orphan");
+    let id = "test.engine.storageorphan";
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    let dir = crate::store::plugin_data_dir(&folder.0, id);
+    std::fs::create_dir_all(dir.join("cache")).unwrap();
+    std::fs::write(dir.join("settings.json"), b"{}").unwrap();
+    std::fs::write(dir.join("cache").join("tile.bin"), b"abc").unwrap();
+    assert!(vectorcraft_plugins::registry::get(id).is_none());
+    assert_eq!(run(&mut s, "plugin.remove", json!({"id": id})), json!({"removed": id}));
+    assert!(!dir.exists(), "the storage of an id that isn't installed is deleted");
+    assert!(s.execute("plugin.remove", &json!({"id": id})).is_err(), "nothing left to remove");
+}
+
+/// The settings file and the cache are checked: a file that doesn't read is moved aside and the
+/// settings start empty; a write past a cap fails and changes nothing; cache entries whose names
+/// differ only in case are two files; a removed plug-in's storage takes no more writes.
+fn plugin_storage_is_capped_and_survives_a_damaged_settings_file() {
+    use vectorcraft_plugins::storage::{self, Meter, StorageError};
+    let folder = crate::tests_links::Folder::new("plugin-storage-caps");
+    let id = "test.engine.storagecaps";
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, "");
+    let st = vectorcraft_plugins::registry::storage(id).unwrap();
+    let dir = crate::store::plugin_data_dir(&folder.0, id);
+    std::fs::create_dir_all(&dir).unwrap();
+    let m = &mut Meter::unlimited();
+
+    // A truncated settings file.
+    std::fs::write(dir.join("settings.json"), br#"{"zoom": "aGVsbG"#).unwrap();
+    assert_eq!(st.setting("zoom", m).unwrap(), None);
+    assert!(dir.join("settings.unreadable.json").is_file() && !dir.join("settings.json").exists());
+    st.set_setting("zoom", b"hello", m).unwrap();
+    assert_eq!(st.setting("zoom", m).unwrap(), Some(b"hello".to_vec()));
+    // Damaged again, it replaces the file moved aside before.
+    std::fs::write(dir.join("settings.json"), b"[").unwrap();
+    assert_eq!(st.setting("zoom", m).unwrap(), None);
+    assert_eq!(std::fs::read(dir.join("settings.unreadable.json")).unwrap(), b"[");
+    st.set_setting("zoom", b"hello", m).unwrap();
+    plugin_storage_writes_are_atomic(&*st, &dir, &folder.0);
+
+    // At most 256 keys: a new one is refused, an existing one still changes.
+    let keys: std::collections::BTreeMap<String, String> = (0..storage::MAX_SETTINGS).map(|i| (format!("k{i}"), "eA==".to_string())).collect();
+    std::fs::write(dir.join("settings.json"), serde_json::to_vec(&keys).unwrap()).unwrap();
+    assert_eq!(st.set_setting("one-more", b"x", m), Err(StorageError::Full));
+    st.set_setting("k0", b"y", m).unwrap();
+    assert_eq!(st.setting("k0", m).unwrap(), Some(b"y".to_vec()));
+    plugin_storage_skips_oversize_files(&*st, &dir);
+
+    // At most 1 MiB in all: eleven values of 64 KiB fit, a twelfth doesn't, and nothing changes.
+    let big = vec![7_u8; storage::MAX_SETTING_BYTES];
+    let keys: std::collections::BTreeMap<String, String> = (0..11).map(|i| (format!("k{i}"), vectorcraft_format::base64_encode(&big))).collect();
+    std::fs::write(dir.join("settings.json"), serde_json::to_vec(&keys).unwrap()).unwrap();
+    assert_eq!(st.set_setting("k11", &big, m), Err(StorageError::Full));
+    assert_eq!((st.setting("k11", m).unwrap(), st.setting("k0", m).unwrap()), (None, Some(big.clone())));
+
+    // The cache: entry size, then the total, here nearly reached by a file already there.
+    assert_eq!(st.set_cache_entry("big", &vec![0; storage::MAX_CACHE_ENTRY + 1], m), Err(StorageError::Full));
+    std::fs::create_dir_all(dir.join("cache")).unwrap();
+    std::fs::File::create(dir.join("cache").join("filler.bin")).unwrap().set_len(storage::MAX_CACHE_BYTES - 2).unwrap();
+    // A temporary file a failed write left behind counts toward no cap, and clearing removes it.
+    let leftover = dir.join("cache").join(".tile.bin.1-0.tmp");
+    std::fs::write(&leftover, b"tmp").unwrap();
+    assert_eq!(st.set_cache_entry("tile", b"abc", m), Err(StorageError::Full));
+    assert_eq!(st.cache_entry("tile", m).unwrap(), None);
+    st.set_cache_entry("tile", b"ab", m).unwrap();
+    assert_eq!(st.cache_bytes(), storage::MAX_CACHE_BYTES);
+    assert_eq!(st.clear_cache().unwrap(), storage::MAX_CACHE_BYTES + 3);
+    assert!(!leftover.exists());
+
+    // Names differing in case are two entries.
+    st.set_cache_entry("Tile", b"1", m).unwrap();
+    st.set_cache_entry("tile", b"22", m).unwrap();
+    assert_eq!((st.cache_entry("Tile", m).unwrap(), st.cache_entry("tile", m).unwrap()), (Some(b"1".to_vec()), Some(b"22".to_vec())));
+    assert_eq!(st.cache_bytes(), 3);
+
+    // More items in the cache folder than a write looks at: the write is refused whatever the
+    // items it looked at hold, and clearing still reaches every entry.
+    let cache = dir.join("cache");
+    for i in 0..crate::store::MAX_CACHE_SCAN {
+        std::fs::create_dir(cache.join(format!("d{i:05}"))).unwrap();
+    }
+    std::fs::File::create(cache.join("z.bin")).unwrap().set_len(storage::MAX_CACHE_BYTES).unwrap();
+    assert_eq!(st.set_cache_entry("more", b"1", m), Err(StorageError::Full));
+    assert_eq!(st.clear_cache().unwrap(), storage::MAX_CACHE_BYTES + 3);
+    assert!(!cache.join("z.bin").exists());
+
+    // An id that differs only in case has storage of its own, which removing this one leaves.
+    let upper_id = "test.engine.StorageCaps";
+    s.attach_plugin_storage(upper_id);
+    let upper = vectorcraft_plugins::registry::storage(upper_id).unwrap();
+    assert_eq!(upper.setting("k0", m).unwrap(), None);
+    upper.set_setting("k0", b"upper", m).unwrap();
+    assert_eq!(st.setting("k0", m).unwrap(), Some(big));
+    // So do ids whose `_` and `.` could be read as each other's escapes.
+    let folders: std::collections::BTreeSet<_> =
+        ["a.b", "a_0b", "a_b", "A.b", "a__b", "a._b", "a_.b"].iter().map(|id| crate::store::plugin_data_dir(&folder.0, id)).collect();
+    assert_eq!(folders.len(), 7, "{folders:?}");
+
+    // Removing the plug-in closes the storage a run still holds, even one from before the plug-in
+    // was replaced, so nothing is written back.
+    s.attach_plugin_storage(id);
+    run(&mut s, "plugin.remove", json!({"id": id}));
+    assert_eq!(st.set_setting("zoom", b"again", m), Err(StorageError::Unavailable));
+    assert_eq!(st.set_cache_entry("tile", b"again", m), Err(StorageError::Unavailable));
+    assert!(!dir.exists());
+    assert_eq!(upper.setting("k0", m).unwrap(), Some(b"upper".to_vec()));
+    s.remove_plugin_storage(upper_id).unwrap();
+}
+
+/// Files larger than the storage reads are not read: a settings file larger than 1 MiB, although
+/// each of its values would fit, is moved aside and the settings start empty; a cache entry file
+/// larger than an entry may be fails as unavailable. `st` is the storage in `dir`.
+fn plugin_storage_skips_oversize_files(st: &dyn vectorcraft_plugins::storage::Storage, dir: &std::path::Path) {
+    use vectorcraft_plugins::storage::{self, Meter, StorageError};
+    let m = &mut Meter::unlimited();
+    let value = vectorcraft_format::base64_encode(&vec![7_u8; storage::MAX_SETTING_BYTES]);
+    let keys: std::collections::BTreeMap<String, String> = (0..13).map(|i| (format!("k{i}"), value.clone())).collect();
+    let oversize = serde_json::to_vec(&keys).unwrap();
+    assert!(oversize.len() > storage::MAX_SETTINGS_BYTES);
+    std::fs::write(dir.join("settings.json"), &oversize).unwrap();
+    assert_eq!(st.setting("k0", m).unwrap(), None);
+    assert!(dir.join("settings.unreadable.json").is_file() && !dir.join("settings.json").exists());
+    std::fs::create_dir_all(dir.join("cache")).unwrap();
+    let huge = dir.join("cache").join("huge.bin");
+    std::fs::File::create(&huge).unwrap().set_len(storage::MAX_CACHE_ENTRY as u64 + 1).unwrap();
+    assert_eq!(st.cache_entry("huge", m), Err(StorageError::Unavailable));
+    std::fs::remove_file(&huge).unwrap();
+}
+
+/// Writes are atomic: a new file takes the old one's name, so another name for the old file (a hard
+/// link) keeps its content. `st` is the storage in `dir` and holds the setting "zoom"; `outside` is
+/// a folder outside it.
+fn plugin_storage_writes_are_atomic(st: &dyn vectorcraft_plugins::storage::Storage, dir: &std::path::Path, outside: &std::path::Path) {
+    let m = &mut vectorcraft_plugins::storage::Meter::unlimited();
+    let settings_copy = outside.join("settings-copy.json");
+    let before = std::fs::read(dir.join("settings.json")).unwrap();
+    std::fs::hard_link(dir.join("settings.json"), &settings_copy).unwrap();
+    st.set_setting("zoom", b"world", m).unwrap();
+    assert_eq!(std::fs::read(&settings_copy).unwrap(), before);
+    assert_eq!(st.setting("zoom", m).unwrap(), Some(b"world".to_vec()));
+    st.set_cache_entry("tile", b"abc", m).unwrap();
+    let entry_copy = outside.join("tile-copy.bin");
+    let entry = std::fs::read_dir(dir.join("cache")).unwrap().map(|e| e.unwrap().path()).find(|p| p.is_file()).unwrap();
+    std::fs::hard_link(&entry, &entry_copy).unwrap();
+    st.set_cache_entry("tile", b"xyz", m).unwrap();
+    assert_eq!(std::fs::read(&entry_copy).unwrap(), b"abc");
+    assert_eq!(st.cache_entry("tile", m).unwrap(), Some(b"xyz".to_vec()));
+    assert!(st.remove_cache_entry("tile").unwrap());
+    std::fs::remove_file(&settings_copy).unwrap();
+    std::fs::remove_file(&entry_copy).unwrap();
+}
+
+/// Each storage call is charged the bytes it reads and writes, before it does: a settings call the
+/// whole settings file it reads and the whole file it writes, a cache call the entry it reads or
+/// writes. A call that would pass what its meter has left fails and changes nothing.
+fn plugin_storage_calls_are_charged_the_files_they_read_and_write() {
+    use vectorcraft_plugins::storage::{Meter, StorageError};
+    let folder = crate::tests_links::Folder::new("plugin-storage-meter");
+    let id = "test.engine.storagemeter";
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, "");
+    let st = vectorcraft_plugins::registry::storage(id).unwrap();
+    let file = crate::store::plugin_data_dir(&folder.0, id).join("settings.json");
+    let size = || std::fs::metadata(&file).unwrap().len();
+    st.set_setting("big", &[7; 60_000], &mut Meter::unlimited()).unwrap();
+    st.set_setting("small", b"x", &mut Meter::unlimited()).unwrap();
+
+    // Reading a one-byte setting reads the whole file.
+    let before = size();
+    let mut m = Meter::unlimited();
+    assert_eq!(st.setting("small", &mut m).unwrap(), Some(b"x".to_vec()));
+    assert_eq!(m.used(), before);
+    // Setting it reads the file and writes it again, and so does deleting one.
+    let mut m = Meter::unlimited();
+    st.set_setting("small", b"yz", &mut m).unwrap();
+    assert_eq!(m.used(), before + size());
+    let (before, mut m) = (size(), Meter::unlimited());
+    assert!(st.delete_setting("small", &mut m).unwrap());
+    assert_eq!(m.used(), before + size());
+    st.set_setting("small", b"y", &mut Meter::unlimited()).unwrap();
+
+    // Less left than the file: nothing is read. Enough to read it but not to write it again:
+    // nothing changes.
+    let mut m = Meter::new(size() - 1);
+    assert_eq!(st.setting("small", &mut m), Err(StorageError::Budget));
+    assert_eq!(m.used(), 0);
+    assert_eq!(st.set_setting("small", b"z", &mut Meter::new(size())), Err(StorageError::Budget));
+    assert_eq!(st.setting("small", &mut Meter::unlimited()).unwrap(), Some(b"y".to_vec()));
+
+    // A cache write is charged the entry it writes, a read the entry it reads.
+    let mut m = Meter::unlimited();
+    st.set_cache_entry("tile", &[1; 1000], &mut m).unwrap();
+    assert_eq!(m.used(), 1000);
+    let mut m = Meter::unlimited();
+    assert_eq!(st.cache_entry("tile", &mut m).unwrap().map(|v| v.len()), Some(1000));
+    assert_eq!(m.used(), 1000);
+    assert_eq!(st.cache_entry("tile", &mut Meter::new(999)), Err(StorageError::Budget));
+    assert_eq!(st.set_cache_entry("tile", &[2; 10], &mut Meter::new(9)), Err(StorageError::Budget));
+    assert_eq!(st.cache_entry("tile", &mut Meter::unlimited()).unwrap().map(|v| v.len()), Some(1000));
+    run(&mut s, "plugin.remove", json!({"id": id}));
+}
+
+/// A module with other bytes than the plug-in installed with its id, or, with none installed, one
+/// whose id has settings and a cache in the plug-in store, installs only with `replace: true`, and
+/// then keeps them; the same module installs again without it, and `replace` must be true or false.
+#[test]
+fn another_module_under_an_id_with_settings_needs_replace() {
+    let folder = crate::tests_links::Folder::new("plugin-storage-replace");
+    let id = "test.engine.storingreplace";
+    let mut s = session();
+    s.attach_plugin_store(folder.0.clone());
+    install_storing(&mut s, id, WRITES);
+    run(&mut s, "plugin.run", json!({"id": id, "ids": []}));
+    let hash = run(&mut s, "plugin.info", json!({"id": id}))["hash"].clone();
+    // The same module again.
+    install_storing(&mut s, id, WRITES);
+
+    let reads = vectorcraft_format::base64_encode(&storing(id, READS));
+    let install = |s: &mut Session, extra: Value| {
+        let mut p = json!({"dataBase64": reads, "grant": ["settings", "cache"]});
+        p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        s.execute("plugin.install", &p)
+    };
+    let Err(e) = install(&mut s, json!({})) else { panic!("another module took the plug-in's place") };
+    assert!(e.to_string().contains(&format!("“Test {id}” is another module than the plug-in with id \"{id}\"")), "{e}");
+    assert!(e.to_string().contains("`replace: true`"), "{e}");
+    assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": reads}))["needsReplace"], json!(true));
+    assert_eq!(run(&mut s, "plugin.info", json!({"id": id}))["hash"], hash);
+    for bad in [json!({"replace": "yes"}), json!({"replace": 1})] {
+        let Err(e) = install(&mut s, bad) else { panic!("a bad `replace` was taken") };
+        assert!(e.to_string().contains("`replace` must be true or false"), "{e}");
+    }
+    assert!(install(&mut s, json!({"replace": false})).is_err());
+    install(&mut s, json!({"replace": true})).unwrap();
+    // It reads what the one it replaced set.
+    run(&mut s, "plugin.run", json!({"id": id, "ids": []}));
+    assert_eq!(run(&mut s, "plugin.info", json!({"id": id}))["cacheBytes"], json!(3));
+
+    // Not installed, but with settings in the store: another module needs `replace` too.
+    vectorcraft_plugins::registry::remove(id);
+    let writes = vectorcraft_format::base64_encode(&storing(id, WRITES));
+    assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": writes}))["needsReplace"], json!(true));
+    assert!(s.execute("plugin.install", &json!({"dataBase64": writes, "grant": ["settings", "cache"]})).is_err());
+    run(&mut s, "plugin.install", json!({"dataBase64": writes, "grant": ["settings", "cache"], "replace": true}));
+    run(&mut s, "plugin.remove", json!({"id": id}));
+    // Once removed, with its settings and cache, it installs as a first install does.
+    assert_eq!(run(&mut s, "plugin.inspect", json!({"dataBase64": reads}))["needsReplace"], json!(false));
+    install(&mut s, json!({})).unwrap();
+    run(&mut s, "plugin.remove", json!({"id": id}));
+}
diff --git a/crates/engine/src/tests/select_ids_first.rs b/crates/engine/src/tests/select_ids_first.rs
index da6c83c87..35d5165cd 100644
--- a/crates/engine/src/tests/select_ids_first.rs
+++ b/crates/engine/src/tests/select_ids_first.rs
@@ -208,7 +208,7 @@ fn id_errors_name_the_command_run() {
         for (given, want) in [
             (json!([999]), "no such object id 999".to_string()),
             (json!([999, layer]), "no such object id 999".to_string()),
-            (json!([ids[0], ids[1], -1]), "invalid object id -1: expected a non-negative integer".to_string()),
+            (json!([ids[0], ids[1], -1]), "`ids` entry 2 is -1, not a non-negative integer object id".to_string()),
             (json!(ids[0]), "ids must be an array of non-negative integer object ids".to_string()),
         ] {
             let mut p = match *cmd {
diff --git a/crates/engine/src/tests/swatchcmds.rs b/crates/engine/src/tests/swatchcmds.rs
index 2a74e194d..cbf595d6d 100644
--- a/crates/engine/src/tests/swatchcmds.rs
+++ b/crates/engine/src/tests/swatchcmds.rs
@@ -503,7 +503,7 @@ fn a_cmyk_document_starts_with_cmyk_swatches_and_stores_new_colours_as_cmyk() {
     // A swatch made from a hex colour is CMYK as well; the document round-trips natively.
     let name = run(&mut s, "swatch.new", json!({"color": "#00ff00"}))["name"].as_str().unwrap().to_string();
     assert_eq!(doc(&s).swatch(&name).and_then(|w| w.paint.color()), Some(managed(Color::rgb(0.0, 1.0, 0.0))));
-    assert_eq!(name, "C=61 M=0 Y=100 K=0");
+    assert_eq!(name, "C=65 M=0 Y=100 K=0");
     let json = serde_json::to_string(doc(&s)).unwrap();
     assert_eq!(serde_json::from_str::<vectorcraft_doc::Document>(&json).unwrap(), *doc(&s));
 }
diff --git a/crates/engine/tests/import_fuzz.rs b/crates/engine/tests/import_fuzz.rs
index 5499dfd88..d46688bdf 100644
--- a/crates/engine/tests/import_fuzz.rs
+++ b/crates/engine/tests/import_fuzz.rs
@@ -4819,6 +4819,16 @@ fn arb_ai_token() -> impl Strategy<Value = String> {
             "\n%AI5_BeginRaster\n",
             "\n%AI5_EndRaster\n",
             "\n%%BeginData: 12\rXI\n",
+            // Image operands past 2^25 pixels, of odd 1-bit rows, and past the hard limits: as
+            // many pixels as a u32 side allows, more samples than the bytes allowed, sizes that
+            // overflow when multiplied out, and a matrix that maps the box to nothing.
+            "[1 0 0 1 0 0] 0 0 6000 6000 6000 6000 1 1 0 0 1 0 4 4 0 0 ",
+            "[1 0 0 1 0 0] 0 0 17 13 17 13 1 1 0 0 1 0 4 4 0 0 ",
+            "[1 0 0 1 0 0] 0 0 9 9 65536 32769 1 1 0 0 1 0 4 4 0 0 ",
+            "[1 0 0 1 0 0] 0 0 9 9 23171 23171 8 4 1 0 1 0 4 4 0 0 ",
+            "[1 0 0 1 0 0] 0 0 9 9 4294967295 4294967295 8 4 1 0 1 0 4 4 0 0 ",
+            "[1 0 0 1 0 0] 0 0 9 9 1e308 1e308 8 3 1 0 0 0 4 4 0 0 ",
+            "[0 0 0 0 0 0] 0 0 9 9 46341 46341 1 1 0 0 1 0 4 4 0 0 ",
             "\n%%EndData\n",
             "\n%AI5_BeginGradient: (G)\n",
             "\n%AI14_BeginSymbol\n",
diff --git a/crates/engine/tests/plugin_fuzz.rs b/crates/engine/tests/plugin_fuzz.rs
index 514118cf3..a7e45f690 100644
--- a/crates/engine/tests/plugin_fuzz.rs
+++ b/crates/engine/tests/plugin_fuzz.rs
@@ -30,8 +30,9 @@ fn config() -> ProptestConfig {
     c
 }
 
+/// Installs `wasm`, in place of any module installed with its id before (`replace: true`).
 fn install(s: &mut Session, wasm: &[u8]) -> Result<Value, String> {
-    s.execute("plugin.install", &json!({"dataBase64": vectorcraft_format::base64_encode(wasm)})).map_err(|e| e.to_string())
+    s.execute("plugin.install", &json!({"dataBase64": vectorcraft_format::base64_encode(wasm), "replace": true})).map_err(|e| e.to_string())
 }
 
 /// The document renders and exports without panicking.
@@ -658,4 +659,66 @@ proptest! {
             prop_assert!(total == 0 || done <= total);
         }
     }
+
+    /// A plug-in that calls the storage imports with hostile keys (`..`, separators, device names,
+    /// control characters, too long), values, lengths and pointers in and out of its memory runs to
+    /// an output, never a panic; every call returns a length or a storage code, and the settings and
+    /// cache of another plug-in in the same store stay as they were.
+    #[test]
+    fn hostile_storage_arguments_never_crash(
+        calls in prop::collection::vec(
+            (
+                0..6usize,
+                prop_oneof![any::<i32>(), 0x1ff00..0x20100i32, Just(0x2000)],
+                prop_oneof![any::<i32>(), 0..80i32],
+                prop_oneof![any::<i32>(), 0x1ff00..0x20100i32, Just(0x3000)],
+                prop_oneof![any::<i32>(), 0..5000i32],
+            ),
+            0..16,
+        ),
+        key in prop::collection::vec(prop_oneof![Just(b'a'), Just(b'.'), Just(b'/'), Just(b'\\'), Just(b'_'), any::<u8>()], 0..80),
+    ) {
+        use vectorcraft_plugins::host::STORAGE_BUDGET;
+        use vectorcraft_plugins::storage::Meter;
+        const FUNCS: [&str; 6] = ["vc_settings_get", "vc_settings_set", "vc_cache_read", "vc_cache_write", "vc_settings_delete", "vc_cache_clear"];
+        let folder = std::env::temp_dir().join(format!("vectorcraft-plugin-fuzz-storage-{}", std::process::id()));
+        let mut s = Session::new();
+        s.attach_plugin_store(folder.clone());
+        let storing = |id: &str| format!(r#"{{"id":"{id}","name":"F","kind":"filter","api":2,"permissions":["settings","cache"]}}"#);
+        let grant = json!(["settings", "cache"]);
+        let other = wat::parse_str(tpl::returning(&storing("fuzz.storage.other"), r#"{"objects":[]}"#)).unwrap();
+        s.execute("plugin.install", &json!({"dataBase64": vectorcraft_format::base64_encode(&other), "grant": grant})).unwrap();
+        let theirs = vectorcraft_plugins::registry::storage("fuzz.storage.other").unwrap();
+        let m = &mut Meter::unlimited();
+        theirs.set_setting("mine", b"kept", m).unwrap();
+        theirs.set_cache_entry("mine", b"kept", m).unwrap();
+        // Each call's result is checked: a length (0 or more) or one of the storage codes.
+        let check = |call: String| format!("(local.set $r {call}) (if (i32.lt_s (local.get $r) (i32.const {STORAGE_BUDGET})) (then unreachable))");
+        let body: String = calls
+            .iter()
+            .map(|&(f, kp, kl, vp, vl)| match f {
+                0..4 => check(format!("(call ${} (i32.const {kp}) (i32.const {kl}) (i32.const {vp}) (i32.const {vl}))", FUNCS[f])),
+                _ => check(format!("(call ${} (i32.const {kp}) (i32.const {kl}))", FUNCS[f])),
+            })
+            .collect();
+        let text: String = key.iter().map(|b| format!("\\{b:02x}")).collect();
+        let imports = format!(r#"{} (data (i32.const 0x2000) "{text}")"#, tpl::STORAGE_IMPORTS);
+        let wasm = wat::parse_str(tpl::with_imports(&storing("fuzz.storage"), &imports, &format!("(local $r i32) {body}"), r#"{"objects":[]}"#)).unwrap();
+        let r = catch_quiet(|| {
+            s.execute("plugin.install", &json!({"dataBase64": vectorcraft_format::base64_encode(&wasm), "grant": grant})).map_err(|e| e.to_string())?;
+            let p = vectorcraft_plugins::registry::get("fuzz.storage").ok_or("not installed")?;
+            p.run(b"{\"objects\":[]}", b"{}").map_err(|e| e.to_string())
+        });
+        let out = r.map_err(|msg| TestCaseError::fail(format!("panicked on {calls:?}: {msg}")))?;
+        prop_assert!(out.is_ok(), "{:?}", out);
+        prop_assert_eq!(theirs.setting("mine", m).unwrap(), Some(b"kept".to_vec()));
+        prop_assert_eq!(theirs.cache_entry("mine", m).unwrap(), Some(b"kept".to_vec()));
+        prop_assert_eq!(theirs.cache_bytes(), 4);
+        // The host names every file: the store holds the two modules, their grants and their folders.
+        let names = |dir: &std::path::Path| std::fs::read_dir(dir).unwrap().filter_map(Result::ok).map(|e| e.file_name()).collect::<Vec<_>>();
+        prop_assert!(names(&folder).len() <= 4, "{:?}", names(&folder));
+        prop_assert!(names(&folder.join("storage")).len() <= 2, "{:?}", names(&folder.join("storage")));
+        let _ = s.execute("plugin.remove", &json!({"id": "fuzz.storage"}));
+        let _ = s.execute("plugin.remove", &json!({"id": "fuzz.storage.other"}));
+    }
 }
diff --git a/crates/engine/tests/plugin_safe_mode.rs b/crates/engine/tests/plugin_safe_mode.rs
index fc9bfed29..7fe54fb53 100644
--- a/crates/engine/tests/plugin_safe_mode.rs
+++ b/crates/engine/tests/plugin_safe_mode.rs
@@ -211,7 +211,7 @@ fn a_disabled_plug_in_whose_new_grant_cant_be_stored_stays_disabled() {
     let grants = dir.join("grants.json");
     std::fs::remove_file(&grants).unwrap();
     std::fs::create_dir_all(grants.join("block")).unwrap();
-    s.execute("plugin.install", &json!({"dataBase64": module(r#"{"objects":[],"error":null}"#), "grant": ["doc.read"]})).unwrap();
+    s.execute("plugin.install", &json!({"dataBase64": module(r#"{"objects":[],"error":null}"#), "grant": ["doc.read"], "replace": true})).unwrap();
     assert_eq!(safe_mode::disabled().len(), 1, "the module the update could not replace stays disabled");
     safe_mode::set_disabled(vec![]);
     let _ = std::fs::remove_dir_all(&dir);
diff --git a/crates/eps/src/import/ai.rs b/crates/eps/src/import/ai.rs
index b0359e172..c29301583 100644
--- a/crates/eps/src/import/ai.rs
+++ b/crates/eps/src/import/ai.rs
@@ -40,11 +40,13 @@ pub(crate) use envelope::MAX_CHECKED;
 pub(crate) use envelope::{WARPED_TYPE_DRAWN, WarpedType};
 pub(crate) use frames::text_frames;
 pub(crate) use paint::MAX_STOPS as MAX_GRADIENT_STOPS;
+#[cfg(test)]
+pub(crate) use read::with_image_limits;
 pub use read::{
-    BindingRef, Brushes, IMAGE_TOO_LARGE, PaletteSwatches, PlacedPage, Structure, active_artboard, artboards, bindings_note, brushes, graphic_styles,
-    palette, read, read_beside, variables,
+    BindingRef, Brushes, PaletteSwatches, PlacedPage, Structure, active_artboard, artboards, bindings_note, brushes, graphic_styles, palette, read,
+    read_beside, variables,
 };
-pub(crate) use read::{MAX_SYMBOLS, join_and, read_art_style, slot_frame, slot_of, symbol_art_member};
+pub(crate) use read::{MAX_SYMBOLS, join_and, read_art_style, read_over_page, slot_frame, slot_of, symbol_art_member};
 
 pub(crate) use read::is_look_slot;
 
diff --git a/crates/eps/src/import/ai/read.rs b/crates/eps/src/import/ai/read.rs
index f49c598dc..b98a79abd 100644
--- a/crates/eps/src/import/ai/read.rs
+++ b/crates/eps/src/import/ai/read.rs
@@ -34,7 +34,9 @@
 //! - Images: `%AI5_BeginRaster`, the colour space `XN`, `[matrix] bounds w h bits type alpha …`
 //!   and the samples after `XI`. 8-bit CMYK samples keep their ink amounts in a CMYK TIFF, and
 //!   an alpha channel that hides part of such an image becomes its opacity mask; other samples
-//!   become an RGBA PNG.
+//!   become an RGBA PNG. Images larger than 2^25 pixels keep their samples' channels (1-bit gray as
+//!   a 1-bit PNG), and are averaged down past a target size ([`raster`]); past the hard limits, one
+//!   is a box that the page's art replaces when there is a page ([`read_over_page`]).
 //! - Linked images in the version 7 form (§8.2, §8.3): `(path) modified XG`, then `XF` with the
 //!   operands `XI` takes and no samples. Each is a linked image of that file showing a placeholder
 //!   over the image's place until its file is found. An `XF` without a file name before it, or
@@ -134,6 +136,7 @@ mod document;
 mod masks;
 mod on_path;
 mod ops;
+mod raster;
 mod types;
 
 pub(crate) use art::join_and;
@@ -143,10 +146,12 @@ pub use document::{
 };
 pub(crate) use document::{slot_frame, slot_of};
 pub(crate) use ops::read_art_style;
+#[cfg(test)]
+pub(crate) use raster::with_image_limits;
+pub use types::PlacedPage;
 use types::{BLEND_BUDGET, BrushArtColors, FLIP, Frame, GState, Graph, Kind, PatternHead, PendingEnvelope, Place, PlacedTail, Raster, SymbolHead};
 #[cfg(test)]
 pub use types::{GRAPH_PLAIN, GRAPH_UNENDED, LINKED_PLACEHOLDERS, NON_NATIVE_ART, NON_NATIVE_ART_UNREAD, VERSIONED_UNENDED};
-pub use types::{IMAGE_TOO_LARGE, PlacedPage};
 pub(super) use types::{blend_mode, blend_name};
 
 #[path = "legacy_text.rs"]
@@ -235,19 +240,32 @@ pub(super) fn remember_xml_id(xml_ids: &mut HashMap<String, Option<NodeId>>, byt
 /// when `large_canvas` is set: an EPS's page is drawn at the full size, but a `.ai`'s PDF part may
 /// keep the reduced one, which the PDF import reads as it is (#2031).
 pub fn read(data: &[u8], large_canvas: bool) -> Result<Structure, String> {
+    read_with(data, large_canvas, false)
+}
+
+/// [`read`] for a file whose page art replaces the objects the reader doesn't read (see
+/// [`Reader::unread_box`]): an image past the hard limits ([`raster::Limits`]) is then such an
+/// object, where [`read`] leaves it out with a note.
+pub(crate) fn read_over_page(data: &[u8], large_canvas: bool) -> Result<Structure, String> {
+    read_with(data, large_canvas, true)
+}
+
+fn read_with(data: &[u8], large_canvas: bool, page_art: bool) -> Result<Structure, String> {
     let mut r = Reader::with_names(data);
     r.large_canvas = large_canvas.then_some(1.0);
+    r.page_art = page_art;
     r.run()?;
     r.finish()
 }
 
 /// [`read`] for editing data kept apart from the program `ps` it came with (an EPS's private
 /// data): the program's header gives the author and the custom colors the editing data's header
-/// doesn't.
-pub fn read_beside(data: &[u8], large_canvas: bool, ps: &[u8]) -> Result<Structure, String> {
+/// doesn't. `page_art`: as [`read_over_page`] reads a file.
+pub fn read_beside(data: &[u8], large_canvas: bool, ps: &[u8], page_art: bool) -> Result<Structure, String> {
     let header = Reader::header_of(ps);
     let mut r = Reader::with_names(data);
     r.large_canvas = large_canvas.then_some(1.0);
+    r.page_art = page_art;
     // The program's custom colors have swatches of their names, which no gradient or pattern takes.
     for n in &header.custom_colors {
         r.global_names.reserve(&n.name);
@@ -587,6 +605,8 @@ struct Reader<'a> {
     /// (see [`Reader::ensure_space`]); 1 (no scaling) when the file doesn't declare one, `None`
     /// when the declared factor is not applied ([`read`]).
     large_canvas: Option<f64>,
+    /// The file has page art to replace the objects that aren't read ([`read_over_page`]).
+    page_art: bool,
     /// The declared `%AI24_LargeCanvasScale` (1 without one), applied or not.
     canvas_scale: f64,
     /// `%AI5_RulerUnits` from the header (Illustrator 7 spec table 3, plus centimeters and pixels).
@@ -756,6 +776,7 @@ impl<'a> Reader<'a> {
             art_size: None,
             template_center: None,
             large_canvas: None,
+            page_art: false,
             canvas_scale: 1.0,
             ruler_units: None,
             pattern: None,
diff --git a/crates/eps/src/import/ai/read/art.rs b/crates/eps/src/import/ai/read/art.rs
index 7f0b75823..7d2565172 100644
--- a/crates/eps/src/import/ai/read/art.rs
+++ b/crates/eps/src/import/ai/read/art.rs
@@ -1,8 +1,9 @@
 use super::containers::close;
 use super::document::TEXT_SLOT;
+use super::raster::{self, Limits, Shape};
 use super::types::{
-    FLIP, Frame, IMAGE_TOO_LARGE, Kind, LINKED_PLACEHOLDERS, LINKED_PREVIEWS, MAX_PIXELS, MAX_PLACED_ELSEWHERE, MAX_POINTS, MAX_SIDE, NON_NATIVE_ART,
-    NON_NATIVE_ART_UNREAD, PLACED_CROP, PLACED_PAGE, Place, PlacedPage, PlacedTail,
+    FLIP, Frame, IMAGE_TOO_LARGE, Kind, LARGE_IMAGES, LINKED_PLACEHOLDERS, LINKED_PREVIEWS, MAX_PIXELS, MAX_PLACED_ELSEWHERE, MAX_POINTS, MAX_SIDE,
+    NON_NATIVE_ART, NON_NATIVE_ART_UNREAD, PLACED_CROP, PLACED_PAGE, Place, PlacedPage, PlacedTail,
 };
 use super::{
     Affine, AnchorKind, Appearance, AppearanceItem, Arc, BezPath, CANVAS_CENTRE, FillLayer, ImageBlob, ImageObject, Inks, Instance, LinkInfo, Node,
@@ -377,7 +378,7 @@ impl<'a> Reader<'a> {
             Some(before) if !vals.iter().any(|v| matches!(v, V::Arr(_))) => before,
             _ => vals,
         };
-        self.image_from(vals, data)
+        self.image_from(vals, data, false)
     }
 
     /// The matrix and the numbers of an image's operands (`[a b c d tx ty] llx lly urx ury w h bits
@@ -411,8 +412,22 @@ impl<'a> Reader<'a> {
         }
     }
 
-    /// An image of operands `vals` and samples `data`.
-    pub(super) fn image_from(&mut self, vals: Vec<V>, data: &[u8]) -> Result<(), String> {
+    /// The bytes of samples (colour and alpha) that the image of `XI` operands `vals` reads: 0 when
+    /// it isn't read (operands missing, or past the hard limits).
+    pub(super) fn sample_bytes(&self, vals: &[V]) -> usize {
+        let space = self.raster.as_ref().and_then(|r| r.space.clone()).unwrap_or_default();
+        let n = Self::nums(vals);
+        let [_, _, _, _, w, h, bits, kind, alpha, ..] = n.as_slice() else { return 0 };
+        let shape = Shape { w: *w as u64, h: *h as u64, channels: channels(&space, *kind) as u64, bits: *bits as u64, alpha: *alpha > 0.0 };
+        match (shape.step(&Limits::get()), shape.lens()) {
+            (Some(_), Some((colour, alpha))) => usize::try_from(colour + alpha).unwrap_or(0),
+            _ => 0,
+        }
+    }
+
+    /// An image of operands `vals` and samples `data` (`decoded`: bytes already, whatever the
+    /// operands say).
+    pub(super) fn image_from(&mut self, vals: Vec<V>, data: &[u8], decoded: bool) -> Result<(), String> {
         // A file `XG` named before this image isn't the file of a later `XF`.
         self.image_link = None;
         let space = self.raster.as_ref().and_then(|r| r.space.clone()).unwrap_or_default();
@@ -427,41 +442,42 @@ impl<'a> Reader<'a> {
         // ImageMask 1: the image is transparent and takes a color (version 7 specification §8.1).
         let image_mask = rest.first() == Some(&1.0);
         let (w, h) = (*w as u64, *h as u64);
-        if w.saturating_mul(h) > MAX_PIXELS {
-            self.image_left_out(IMAGE_TOO_LARGE);
-            return Ok(());
-        }
         if w == 0 || h == 0 || ![1.0, 8.0].contains(bits) {
             self.image_left_out("an image VectorCraft can't read was left out");
             return Ok(());
         }
-        let channels: usize = match space.as_str() {
-            "DeviceGray" => 1,
-            "DeviceCMYK" => 4,
-            "DeviceRGB" => 3,
-            _ => match *kind as i64 {
-                1 => 1,
-                4 => 4,
-                _ => 3,
-            },
+        let channels = channels(&space, *kind);
+        // The size is checked before anything is decoded or allocated.
+        let shape = Shape { w, h, channels: channels as u64, bits: *bits as u64, alpha: *alpha > 0.0 };
+        let (Some(k), Some((need, alpha_len))) = (shape.step(&Limits::for_channels(channels)), shape.lens()) else {
+            return self.too_large_image(&m, w, h);
         };
-        let decoded;
-        let data = if *binary == 0.0 {
-            let digits: Vec<u8> = data.iter().copied().filter(|b| b.is_ascii_hexdigit()).collect();
-            decoded = crate::import::lex::hex_decode(&digits).unwrap_or_default();
-            decoded.as_slice()
+        // Within the limits, these fit in memory (see `Limits::bytes`).
+        let (need, alpha_len) = (need as usize, alpha_len as usize);
+        let hex;
+        let data = if *binary == 0.0 && !decoded {
+            let (max, mut half) = (need + alpha_len, None);
+            let mut out = Vec::with_capacity(max.min(data.len() / 2));
+            raster::push_hex(&mut out, &mut half, data, max);
+            raster::end_hex(&mut out, half, max);
+            hex = out;
+            hex.as_slice()
         } else {
             data
         };
-        let row = if *bits == 1.0 { (w as usize * channels).div_ceil(8) } else { w as usize * channels };
-        let need = row.saturating_mul(h as usize);
+        let row = shape.row().unwrap_or(0) as usize;
         // An alpha channel follows the colour samples, one byte a pixel.
-        let alpha_len = if *alpha > 0.0 { (w * h) as usize } else { 0 };
         let (Some(samples), opacity) = (data.get(..need), data.get(need..need.saturating_add(alpha_len))) else {
             self.image_left_out("an image whose data is cut short was left out");
             return Ok(());
         };
         let opacity = opacity.filter(|_| alpha_len > 0);
+        let gray1 = *bits == 1.0 && channels == 1 && opacity.is_none();
+        if k > 1 || w * h > raster::SMALL || (gray1 && !image_mask) {
+            // An image mask keeps the color that colorizes it.
+            let colorize = (image_mask && channels == 1 && *bits == 1.0).then(|| self.mask_paint());
+            return self.large_image(samples, opacity, shape, k, &m, colorize);
+        }
         // CMYK samples keep their ink amounts as a CMYK TIFF, as the PDF importer keeps a CMYK
         // image's, and an alpha channel that hides part of the image becomes its opacity mask.
         if channels == 4
@@ -595,6 +611,67 @@ impl<'a> Reader<'a> {
         self.add_image_colorized(im, None, colorize, hidden)
     }
 
+    /// An image of `s` past [`raster::SMALL`] pixels, or reduced by the step `k`, or 1-bit gray:
+    /// 1-bit gray at full size is a 1-bit PNG of its rows as they are; other images keep their
+    /// channels a byte each (gray or RGB in a PNG with the alpha channel, CMYK in a TIFF with the
+    /// alpha channel as its opacity mask), averaged over blocks of `k` × `k` pixels. The matrix
+    /// `m` places the image where its full size would be.
+    fn large_image(&mut self, samples: &[u8], opacity: Option<&[u8]>, s: Shape, k: u64, m: &[f64], colorize: Option<Paint>) -> Result<(), String> {
+        let (ow, oh) = (s.w.div_ceil(k) as u32, s.h.div_ceil(k) as u32);
+        if k == 1 && s.bits == 1 && s.channels == 1 && opacity.is_none() {
+            let Some(png) = raster::gray1_png(samples, ow, oh, s.row().unwrap_or(0) as usize) else {
+                return self.too_large_image(m, s.w, s.h);
+            };
+            return self.add_raster(ImageBlob::new("image/png", png), None, m, (ow, oh), colorize);
+        }
+        let cmyk = s.channels == 4;
+        let (pixels, mask) = raster::reduce(samples, opacity, s, k, !cmyk);
+        let blob = if cmyk {
+            Inks::new(ow, oh, pixels).and_then(|i| ImageBlob::cmyk_tiff(&i))
+        } else {
+            use image::ImageEncoder as _;
+            let colour = match (s.channels, opacity.is_some()) {
+                (1, false) => image::ExtendedColorType::L8,
+                (1, true) => image::ExtendedColorType::La8,
+                (_, false) => image::ExtendedColorType::Rgb8,
+                (_, true) => image::ExtendedColorType::Rgba8,
+            };
+            let mut png = vec![];
+            image::codecs::png::PngEncoder::new(&mut png).write_image(&pixels, ow, oh, colour).ok().map(|()| ImageBlob::new("image/png", png))
+        };
+        // One that can't be encoded is left to the page's art, as one past the hard limits.
+        let Some(blob) = blob else {
+            return self.too_large_image(m, s.w, s.h);
+        };
+        // Each pixel as read stands for a block of the full size's.
+        let (sx, sy) = (s.w as f64 / f64::from(ow), s.h as f64 / f64::from(oh));
+        let m: Vec<f64> = match m {
+            [a, b, c, d, tx, ty] => vec![a * sx, b * sx, c * sy, d * sy, *tx, *ty],
+            other => other.to_vec(),
+        };
+        if k > 1 {
+            self.warn(&format!("an embedded image of {} × {} pixels was reduced to {ow} × {oh} pixels to keep the layers", s.w, s.h));
+        }
+        self.add_raster(blob, mask.as_deref(), &m, (ow, oh), colorize)
+    }
+
+    /// An image of `w` × `h` pixels past the hard limits, which matrix `m` maps into art space: a
+    /// box for the page's art to replace ([`Reader::unread_box`]), or, without page art, left out
+    /// with a note.
+    fn too_large_image(&mut self, m: &[f64], w: u64, h: u64) -> Result<(), String> {
+        if !self.page_art {
+            self.image_left_out(IMAGE_TOO_LARGE);
+            return Ok(());
+        }
+        let [a, b, c, d, tx, ty] = m else {
+            self.image_left_out("an image VectorCraft can't read was left out");
+            return Ok(());
+        };
+        let xf = self.space() * Affine::new([*a, *b, *c, *d, *tx, *ty]) * FLIP;
+        let bounds = xf.transform_rect_bbox(Rect::new(0.0, 0.0, w as f64, h as f64));
+        self.unread_box(LARGE_IMAGES, bounds, false).map(|_| ())
+    }
+
     /// Add the image `blob` (`w` × `h` pixels), which the matrix `m` maps into art space, with
     /// `alpha` (its alpha channel, one byte a pixel) as its opacity mask when it hides part of the
     /// image, and `colorize` as the color that colorizes it.
@@ -978,6 +1055,20 @@ fn cmyk_rgb([c, m, y, k]: [u8; 4]) -> [u8; 3] {
     [rgb[0], rgb[1], rgb[2]]
 }
 
+/// The colour channels of an image in the colour space `space` (`XN`), else of image type `kind`.
+fn channels(space: &str, kind: f64) -> usize {
+    match space {
+        "DeviceGray" => 1,
+        "DeviceCMYK" => 4,
+        "DeviceRGB" => 3,
+        _ => match kind as i64 {
+            1 => 1,
+            4 => 4,
+            _ => 3,
+        },
+    }
+}
+
 /// `a`, `a and b`, `a, b and c`.
 pub(crate) fn join_and(items: &[&str]) -> String {
     match items {
diff --git a/crates/eps/src/import/ai/read/directives.rs b/crates/eps/src/import/ai/read/directives.rs
index dfc55aa7a..68f981751 100644
--- a/crates/eps/src/import/ai/read/directives.rs
+++ b/crates/eps/src/import/ai/read/directives.rs
@@ -3,8 +3,9 @@ use std::collections::HashMap;
 use super::super::brush;
 use super::art::{four, sane, two};
 use super::ops::Dictionaries;
+use super::raster::{end_hex, push_hex};
 use super::types::{
-    FLIP, GState, Kind, MAX_DEPTH, MAX_HEX, MAX_LISTED, MAX_NODES, MAX_NOTE, MAX_PATTERNS, MAX_PLACED_FOLDER, MAX_STACK, MAX_SUBREADERS, MAX_SYMBOLS,
+    FLIP, GState, Kind, MAX_DEPTH, MAX_LISTED, MAX_NODES, MAX_NOTE, MAX_PATTERNS, MAX_PLACED_FOLDER, MAX_STACK, MAX_SUBREADERS, MAX_SYMBOLS,
     PatternHead, Place, Raster, SKIPPED, SymbolHead, VERSIONED_UNENDED,
 };
 use super::{Arc, BrushArtColors, Global, Lexer, Node, NodeKind, PatternDef, Reader, Rect, Tok, V, marker, obj};
@@ -52,9 +53,7 @@ impl<'a> Reader<'a> {
             && !line.is_empty()
             && line.bytes().all(|b| b.is_ascii_hexdigit())
         {
-            if r.hex.len() < MAX_HEX {
-                r.hex.extend_from_slice(line.as_bytes());
-            }
+            push_hex(&mut r.samples, &mut r.half, line.as_bytes(), r.max);
             return Ok(());
         }
         // The header's comments (AI7 specification §2.1.1; DSC 3.0).
@@ -182,8 +181,9 @@ impl<'a> Reader<'a> {
         } else if line.starts_with("AI5_EndRaster") {
             // A file `XG` named in this raster object is no later one's.
             self.image_link = None;
-            if let Some(Raster { operands: Some(vals), hex, .. }) = self.raster.take() {
-                return self.image_from(vals, &hex);
+            if let Some(Raster { operands: Some(vals), mut samples, half, max, .. }) = self.raster.take() {
+                end_hex(&mut samples, half, max);
+                return self.image_from(vals, &samples, true);
             }
         } else if line.starts_with("AI5_BeginPlace") {
             // One that is still open (no `~` ended it) isn't read.
diff --git a/crates/eps/src/import/ai/read/ops.rs b/crates/eps/src/import/ai/read/ops.rs
index d5d28aab6..4861e342d 100644
--- a/crates/eps/src/import/ai/read/ops.rs
+++ b/crates/eps/src/import/ai/read/ops.rs
@@ -390,8 +390,10 @@ impl<'a> Reader<'a> {
             "TZ" => self.tz(&vals),
             // An image whose samples follow in comment lines (read at `%AI5_EndRaster`).
             "XI" if self.raster.is_some() => {
+                let max = self.sample_bytes(&vals);
                 if let Some(r) = self.raster.as_mut() {
                     r.operands = Some(vals);
+                    r.max = max;
                 }
             }
             // A linked image (§8.2, §8.3): `(path) modified XG` names the file of the `XF` image after
diff --git a/crates/eps/src/import/ai/read/raster.rs b/crates/eps/src/import/ai/read/raster.rs
new file mode 100644
index 000000000..da88fd144
--- /dev/null
+++ b/crates/eps/src/import/ai/read/raster.rs
@@ -0,0 +1,268 @@
+//! The size of an embedded image (`XI`), checked before its samples are decoded: read at full size
+//! up to a target number of pixels, averaged down in whole steps past it, and not read at all past
+//! the hard limits ([`Limits`]).
+
+use std::io::Write as _;
+
+/// Images up to this many pixels read as they always have: an RGBA PNG, or a CMYK TIFF.
+pub(super) const SMALL: u64 = 1 << 25;
+/// Most bytes of one image's samples, its alpha channel included.
+pub(super) const MAX_BYTES: u64 = 512 << 20;
+/// Most pixels of one image.
+pub(super) const MAX_PIXELS: u64 = 1 << 31;
+/// Longest side of an image as it comes in (pixels).
+const MAX_SIDE: u64 = 65_535;
+
+/// How large an image is read.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) struct Limits {
+    /// Most pixels of an image as it comes in; larger ones are reduced.
+    pub(super) target: u64,
+    /// Most pixels of an image read at all.
+    pub(super) pixels: u64,
+    /// Most bytes of an image's samples, its alpha channel included.
+    pub(super) bytes: u64,
+}
+
+#[cfg(test)]
+thread_local! {
+    static TEST_LIMITS: std::cell::Cell<Option<Limits>> = const { std::cell::Cell::new(None) };
+}
+
+impl Limits {
+    /// The limits on this machine: [`target`] pixels, [`MAX_PIXELS`] and [`MAX_BYTES`].
+    pub(super) fn get() -> Self {
+        #[cfg(test)]
+        if let Some(l) = TEST_LIMITS.with(std::cell::Cell::get) {
+            return l;
+        }
+        static TARGET: std::sync::OnceLock<u64> = std::sync::OnceLock::new();
+        let target = *TARGET.get_or_init(|| target(vectorcraft_render::installed_memory()));
+        Self { target, pixels: MAX_PIXELS, bytes: MAX_BYTES }
+    }
+
+    /// The limits for an image of `channels` colour channels: a CMYK image comes in at most as
+    /// large as a CMYK TIFF holds ([`vectorcraft_doc::cmyk::MAX_CMYK_PIXELS`]).
+    pub(super) fn for_channels(channels: usize) -> Self {
+        let mut l = Self::get();
+        if channels == 4 {
+            l.target = l.target.min(vectorcraft_doc::cmyk::MAX_CMYK_PIXELS);
+        }
+        l
+    }
+}
+
+/// `f` run with images read under `target` pixels, `pixels` and `bytes` in place of this machine's
+/// limits.
+#[cfg(test)]
+pub(crate) fn with_image_limits<T>(target: u64, pixels: u64, bytes: u64, f: impl FnOnce() -> T) -> T {
+    TEST_LIMITS.with(|l| l.set(Some(Limits { target, pixels, bytes })));
+    let out = f();
+    TEST_LIMITS.with(|l| l.set(None));
+    out
+}
+
+/// Most pixels of an image as it comes in, on a machine with `memory` bytes installed (`None`: not
+/// known): a thirty-second of it, from 2^26 to 2^28 pixels (an RGBA decode of at most 1 GiB); on the
+/// web, a quarter of the largest image the renderer decodes, at most 2^27.
+fn target(memory: Option<u64>) -> u64 {
+    if cfg!(target_arch = "wasm32") {
+        (1u64 << 27).min(vectorcraft_doc::MAX_RASTER_ALLOC / 4)
+    } else {
+        memory.map_or(1 << 26, |m| (m / 32).clamp(1 << 26, 1 << 28))
+    }
+}
+
+/// An image's layout from its `XI` operands.
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Shape {
+    pub(super) w: u64,
+    pub(super) h: u64,
+    /// Colour channels a pixel: 1, 3 or 4.
+    pub(super) channels: u64,
+    /// Bits a channel: 1 or 8.
+    pub(super) bits: u64,
+    /// An alpha channel, a byte a pixel, follows the colour samples.
+    pub(super) alpha: bool,
+}
+
+impl Shape {
+    /// Bytes in a row of colour samples (a 1-bit row is padded to a whole byte).
+    pub(super) fn row(&self) -> Option<u64> {
+        Some(self.w.checked_mul(self.channels)?.checked_mul(self.bits)?.div_ceil(8))
+    }
+
+    /// Bytes of colour samples, and of the alpha channel.
+    pub(super) fn lens(&self) -> Option<(u64, u64)> {
+        let colour = self.row()?.checked_mul(self.h)?;
+        let alpha = if self.alpha { self.w.checked_mul(self.h)? } else { 0 };
+        colour.checked_add(alpha)?;
+        Some((colour, alpha))
+    }
+
+    /// The step `k` the image is reduced by (1: full size): the smallest that brings it within
+    /// `limits.target` pixels and [`MAX_SIDE`] a side. `None` past `limits.pixels` or
+    /// `limits.bytes`.
+    pub(super) fn step(&self, limits: &Limits) -> Option<u64> {
+        let pixels = self.w.checked_mul(self.h)?;
+        let (colour, alpha) = self.lens()?;
+        if pixels > limits.pixels || colour + alpha > limits.bytes {
+            return None;
+        }
+        let fits = |k: u64| {
+            let (w, h) = (self.w.div_ceil(k), self.h.div_ceil(k));
+            w <= MAX_SIDE && h <= MAX_SIDE && w.saturating_mul(h) <= limits.target.max(1)
+        };
+        // No step below these brings it within the limits.
+        let mut k = ((pixels as f64 / limits.target.max(1) as f64).sqrt().floor() as u64)
+            .max(self.w.div_ceil(MAX_SIDE))
+            .max(self.h.div_ceil(MAX_SIDE))
+            .max(1);
+        while !fits(k) {
+            k += 1;
+        }
+        Some(k)
+    }
+}
+
+/// The samples of the image `s` (rows of [`Shape::row`] bytes; a set bit is the channel at full
+/// strength) and its `alpha` channel averaged over blocks of `k` × `k` pixels into a byte a channel,
+/// each block at the right and bottom edges over the pixels it has. With `inline`, the alpha follows
+/// each pixel's channels; otherwise it comes back on its own.
+pub(super) fn reduce(samples: &[u8], alpha: Option<&[u8]>, s: Shape, k: u64, inline: bool) -> (Vec<u8>, Option<Vec<u8>>) {
+    let (w, h, k) = (s.w as usize, s.h as usize, k.max(1) as usize);
+    let (ch, row) = (s.channels as usize, s.row().unwrap_or(0) as usize);
+    let (ow, oh) = (w.div_ceil(k), h.div_ceil(k));
+    let n = ch + usize::from(alpha.is_some());
+    let mut out = Vec::with_capacity(ow * oh * if inline { n } else { ch });
+    let mut alpha_out = (alpha.is_some() && !inline).then(|| Vec::with_capacity(ow * oh));
+    let mut sums = vec![0u64; ow * n];
+    for oy in 0..oh {
+        sums.fill(0);
+        let rows = oy * k..((oy + 1) * k).min(h);
+        let tall = rows.len() as u64;
+        for y in rows {
+            let line = samples.get(y * row..(y + 1) * row).unwrap_or_default();
+            let opacity = alpha.and_then(|a| a.get(y * w..(y + 1) * w));
+            for x in 0..w {
+                let at = x / k * n;
+                for c in 0..ch {
+                    let i = x * ch + c;
+                    let v =
+                        if s.bits == 1 { line.get(i / 8).map_or(0, |b| ((b >> (7 - i % 8)) & 1) * 255) } else { line.get(i).copied().unwrap_or(0) };
+                    sums[at + c] += u64::from(v);
+                }
+                if alpha.is_some() {
+                    sums[at + ch] += u64::from(opacity.and_then(|o| o.get(x)).copied().unwrap_or(255));
+                }
+            }
+        }
+        for ox in 0..ow {
+            let count = ((((ox + 1) * k).min(w) - ox * k) as u64 * tall).max(1);
+            let avg = |sum: u64| ((sum + count / 2) / count) as u8;
+            out.extend(sums[ox * n..ox * n + ch].iter().map(|v| avg(*v)));
+            if alpha.is_some() {
+                let a = avg(sums[ox * n + ch]);
+                match alpha_out.as_mut() {
+                    Some(o) => o.push(a),
+                    None => out.push(a),
+                }
+            }
+        }
+    }
+    (out, alpha_out)
+}
+
+/// A grayscale PNG of 1-bit rows as they are (`row` bytes each, a set bit white): `w` × `h`
+/// pixels without expanding them.
+pub(super) fn gray1_png(samples: &[u8], w: u32, h: u32, row: usize) -> Option<Vec<u8>> {
+    let mut z = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
+    for y in 0..h as usize {
+        // Filter type 0 (none), then the row.
+        z.write_all(&[0]).ok()?;
+        z.write_all(samples.get(y * row..(y + 1) * row)?).ok()?;
+    }
+    let data = z.finish().ok()?;
+    let mut png = b"\x89PNG\r\n\x1a\n".to_vec();
+    // Bit depth 1, colour type 0 (gray), deflate, filter method 0, no interlacing.
+    let ihdr = [&w.to_be_bytes()[..], &h.to_be_bytes(), &[1, 0, 0, 0, 0]].concat();
+    for (ty, body) in [(b"IHDR", ihdr.as_slice()), (b"IDAT", data.as_slice()), (b"IEND", &[])] {
+        png.extend_from_slice(&u32::try_from(body.len()).ok()?.to_be_bytes());
+        png.extend_from_slice(ty);
+        png.extend_from_slice(body);
+        let mut crc = flate2::Crc::new();
+        crc.update(ty);
+        crc.update(body);
+        png.extend_from_slice(&crc.sum().to_be_bytes());
+    }
+    Some(png)
+}
+
+/// Decode the hex digits in `text` onto `out`, `half` holding a digit that waits for its pair, up
+/// to `max` bytes; other characters are skipped.
+pub(super) fn push_hex(out: &mut Vec<u8>, half: &mut Option<u8>, text: &[u8], max: usize) {
+    for &b in text {
+        if out.len() >= max {
+            return;
+        }
+        let Some(v) = char::from(b).to_digit(16) else { continue };
+        match half.take() {
+            Some(high) => out.push(high << 4 | v as u8),
+            None => *half = Some(v as u8),
+        }
+    }
+}
+
+/// The last digit of [`push_hex`]'s, without its pair, as the byte it starts.
+pub(super) fn end_hex(out: &mut Vec<u8>, half: Option<u8>, max: usize) {
+    if let Some(high) = half
+        && out.len() < max
+    {
+        out.push(high << 4);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A CMYK image is reduced to the size a CMYK TIFF holds, whatever the target.
+    #[test]
+    fn cmyk_images_come_in_at_most_as_large_as_a_cmyk_tiff() {
+        let shape = |channels| Shape { w: 9000, h: 9000, channels, bits: 8, alpha: false };
+        let (rgb, cmyk) = with_image_limits(1 << 28, MAX_PIXELS, MAX_BYTES * 4, || {
+            (shape(3).step(&Limits::for_channels(3)), shape(4).step(&Limits::for_channels(4)))
+        });
+        assert_eq!(rgb, Some(1));
+        let k = cmyk.unwrap();
+        assert_eq!(k, 2);
+        assert!(9000u64.div_ceil(k).pow(2) <= vectorcraft_doc::cmyk::MAX_CMYK_PIXELS);
+    }
+
+    /// The step keeps each side within 65,535 pixels, and sizes past the limits or overflowing
+    /// aren't read.
+    #[test]
+    fn steps_keep_sides_within_the_limit() {
+        let limits = Limits { target: 1 << 28, pixels: MAX_PIXELS, bytes: MAX_BYTES };
+        let long = Shape { w: 200_000, h: 1, channels: 1, bits: 1, alpha: false };
+        assert_eq!(long.step(&limits), Some(4));
+        let huge = Shape { w: u64::MAX, h: 2, channels: 3, bits: 8, alpha: true };
+        assert_eq!(huge.step(&limits), None);
+        let many = Shape { w: 1 << 16, h: 1 << 16, channels: 1, bits: 1, alpha: false };
+        assert_eq!(many.step(&limits), None);
+    }
+
+    /// Hex digits are decoded across calls, other characters skipped, up to the bytes asked for.
+    #[test]
+    fn hex_is_decoded_up_to_the_bytes_asked_for() {
+        let (mut out, mut half) = (vec![], None);
+        push_hex(&mut out, &mut half, b"F f0 1", 8);
+        push_hex(&mut out, &mut half, b"2a", 8);
+        end_hex(&mut out, half, 8);
+        assert_eq!(out, [0xff, 0x01, 0x2a]);
+        let (mut out, mut half) = (vec![], None);
+        push_hex(&mut out, &mut half, b"0102030", 2);
+        end_hex(&mut out, half, 2);
+        assert_eq!(out, [1, 2]);
+    }
+}
diff --git a/crates/eps/src/import/ai/read/types.rs b/crates/eps/src/import/ai/read/types.rs
index 5fe93923a..5d34e248e 100644
--- a/crates/eps/src/import/ai/read/types.rs
+++ b/crates/eps/src/import/ai/read/types.rs
@@ -21,17 +21,18 @@ pub(super) const BLEND_BUDGET: usize = 50_000;
 /// Most points in one path.
 pub(super) const MAX_POINTS: usize = 4_000_000;
 
-/// Largest image read (pixels).
+/// Largest placed file's preview read (pixels).
 pub(super) const MAX_PIXELS: u64 = 1 << 25;
 /// Most placed files whose other placement ([`super::Structure::placed_elsewhere`]) is kept.
 pub(super) const MAX_PLACED_ELSEWHERE: usize = 4096;
 
-/// The note for an image past [`MAX_PIXELS`]: the file then opens from its PDF part, which reads
-/// larger images (#1479), unless that part can't be read either; then the image is left out.
-pub const IMAGE_TOO_LARGE: &str = "an image too large to read from the editing data was left out";
+/// The note for an image past the hard limits ([`super::raster::Limits`]) in a file without page
+/// art to replace it.
+pub(super) const IMAGE_TOO_LARGE: &str = "an image too large to read from the editing data was left out";
 
-/// Most hex digits of an image's samples read from comment lines (CMYK and alpha at the largest size).
-pub(super) const MAX_HEX: usize = (MAX_PIXELS as usize) * 10;
+/// What an image past the hard limits is, as the notes name it: with page art, its box becomes
+/// that art (#1479).
+pub(super) const LARGE_IMAGES: &str = "very large images";
 
 /// Largest side of the document and its artboards (points).
 pub(super) const MAX_SIDE: f64 = 1e6;
@@ -281,8 +282,12 @@ pub(super) struct Raster {
     /// `XI`'s operands when its samples follow as hex in comment lines (`%FF00…`) up to
     /// `%AI5_EndRaster`, the form the version 7 specification documents (§8).
     pub(super) operands: Option<Vec<V>>,
-    /// Those hex digits.
-    pub(super) hex: Vec<u8>,
+    /// The bytes of those hex digits, up to `max`.
+    pub(super) samples: Vec<u8>,
+    /// The bytes of samples the image reads (0 when it isn't read).
+    pub(super) max: usize,
+    /// A digit waiting for its pair.
+    pub(super) half: Option<u8>,
 }
 
 /// A placed file's operands, from `` ` `` and its preview, until `~`.
diff --git a/crates/eps/src/import/ai/tests.rs b/crates/eps/src/import/ai/tests.rs
index e5c927670..07236c2c6 100644
--- a/crates/eps/src/import/ai/tests.rs
+++ b/crates/eps/src/import/ai/tests.rs
@@ -783,7 +783,7 @@ fn pattern_names_are_shown_up_to_their_newline() {
     // Nor the name of a custom color the program of an EPS gives, or None's.
     let ps = b"%!PS-Adobe-3.0\n%%CMYKCustomColor: 0 0 1 0 (Outer Ink)\n%%EndComments\n";
     let data = stream(&format!("{}{}{}", def("Outer Ink\\n1", 8), def("[None]\\n1", 8), layer(&filled("Outer Ink\\n1"))));
-    let doc = super::read_beside(data.as_bytes(), true, ps).unwrap().doc;
+    let doc = super::read_beside(data.as_bytes(), true, ps, false).unwrap().doc;
     assert_eq!(doc.patterns.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(), ["Outer Ink 2", "[None] 2"]);
     assert!(matches!(doc.swatch("Outer Ink").unwrap().paint, Paint::Solid { .. }));
     assert!(matches!(fill(&art(&doc)[0]), Paint::Pattern { pattern, .. } if pattern == "Outer Ink 2"));
@@ -2613,6 +2613,29 @@ fn a_drawn_look_that_is_an_image_stands_for_its_object() {
     assert!(r.warnings.iter().any(|w| w.contains("drawn look (1)")), "{:?}", r.warnings);
 }
 
+/// Samples in hex comment lines after `XI` (the version 7 specification's form) are read up to the
+/// bytes the image needs; an image past the hard limits isn't read, whatever lines follow it.
+#[test]
+fn hex_comment_line_samples_are_read_up_to_the_image() {
+    let raster = |(w, h): (u32, u32), lines: &str| {
+        let s = format!(
+            "%AI5_BeginLayer\n1 1 1 1 0 0 1 0 79 128 255 0 50 0 Lb\n(L) Ln\n%AI5_File:\n%AI5_BeginRaster\n() 1 XG\n/DeviceRGB XN\n\
+             [ 1 0 0 1 0 100 ] {w} {h} 0 Xh\n[ 1 0 0 1 0 100 ] 0 0 {w} {h} {w} {h} 8 3 0 0 0 0 XI\n{lines}%AI5_EndRaster\nN\nLB\n%AI5_EndLayer--\n"
+        );
+        let mut out = stream("").into_bytes();
+        let at = out.windows(14).position(|w| w == b"%%PageTrailer\n").unwrap();
+        out.splice(at..at, s.into_bytes());
+        out
+    };
+    // 2 × 1: red, green, then digits past the image's six bytes.
+    let r = read(&raster((2, 1), "%FF00\n%0000FF\n%00FFFFFF\n")).unwrap();
+    let img = pixels(&r.doc).0;
+    assert_eq!((img.get_pixel(0, 0).0, img.get_pixel(1, 0).0), ([255, 0, 0, 255], [0, 255, 0, 255]));
+    let r = read(&raster((70_000, 70_000), "%FF0000\n%00FF00\n")).unwrap();
+    assert!(art(&r.doc).is_empty());
+    assert!(r.warnings.iter().any(|w| w == "an image too large to read from the editing data was left out"), "{:?}", r.warnings);
+}
+
 /// The name and opacity mask after an image follow the operators that end its raster: `XH`, the
 /// versioned `Xr` and the `N` after `%AI5_EndRaster`.
 #[test]
@@ -2911,7 +2934,7 @@ fn a_version_7_linked_image_without_its_file_name_is_left_out_with_a_warning() {
     let r = read(stream7(&layer7("L", &raster7("(a.tif) 0 XG\n", m, (100_000, 100_000), "XF", ""))).as_bytes()).unwrap();
     let a = art(&r.doc);
     assert!(matches!(&a[..], [n] if matches!(&n.kind, NodeKind::Image(im) if (im.width, im.height) == (100_000, 100_000))), "{a:?}");
-    assert!(!r.warnings.iter().any(|w| w == read::IMAGE_TOO_LARGE), "{:?}", r.warnings);
+    assert!(!r.warnings.iter().any(|w| w == "an image too large to read from the editing data was left out"), "{:?}", r.warnings);
     let twice = raster7("(a.tif) 0 XG\n(b.tif) 0 XG\n", m, (2, 2), "XF", "");
     let r = read(stream7(&layer7("L", &twice)).as_bytes()).unwrap();
     let a = art(&r.doc);
diff --git a/crates/eps/src/import/native/build.rs b/crates/eps/src/import/native/build.rs
index 7e6dd4cfc..57d961181 100644
--- a/crates/eps/src/import/native/build.rs
+++ b/crates/eps/src/import/native/build.rs
@@ -59,7 +59,9 @@ pub(super) fn build(
 ) -> Result<(Document, Vec<String>), String> {
     // An EPS (its page is its art) draws a Large Canvas page at full size; a `.ai` keeps its art
     // space, as its PDF part may (#2031).
-    build_from(ai::read(data, matches!(page, Page::Art))?, data, visible, page, outlined, trust, unit)
+    let large_canvas = matches!(page, Page::Art);
+    let structure = if visible.is_some() { ai::read_over_page(data, large_canvas)? } else { ai::read(data, large_canvas)? };
+    build_from(structure, data, visible, page, outlined, trust, unit)
 }
 
 /// [`build`] without a page, for a `.ai` whose PDF part can't be read, its first page `page`
diff --git a/crates/eps/src/import/native/layers.rs b/crates/eps/src/import/native/layers.rs
index 0575eebcc..597979855 100644
--- a/crates/eps/src/import/native/layers.rs
+++ b/crates/eps/src/import/native/layers.rs
@@ -24,7 +24,7 @@ pub(in super::super) fn layered(ps: &[u8], visible: Imported, trust: bool, illus
     // can't be used.
     // Private data kept apart from the program: the program's own header gives the author and
     // custom colors the private data's header may lack.
-    let read = |d: &[u8]| if matches!(data, Ok(Cow::Owned(_))) { ai::read_beside(d, true, ps) } else { ai::read(d, true) };
+    let read = |d: &[u8]| if matches!(data, Ok(Cow::Owned(_))) { ai::read_beside(d, true, ps, true) } else { ai::read_over_page(d, true) };
     let (tree, result) = match data.as_deref() {
         Ok(d) => match read(d) {
             Ok(s) => (layer_tree(&s.doc.layers), build_from(s, d, Some(&visible.document), Page::Art, false, trust, 1.0)),
@@ -160,14 +160,9 @@ pub fn layered_ai_from(
         (visible, all, false)
     };
     let built = structure
-        .unwrap_or_else(|| ai::read(&data, false).map(Box::new))
+        .unwrap_or_else(|| ai::read_over_page(&data, false).map(Box::new))
         .and_then(|structure| build_from(*structure, &data, Some(&visible), Page::Artboard, outlined, trust, unit));
     match built {
-        // An image too large for the editing data's reader would be missing from the layers, while
-        // the PDF part has it: the file comes in as its PDF part instead (#1479).
-        Ok((_, notes)) if notes.iter().any(|n| n == ai::IMAGE_TOO_LARGE) => {
-            from_pdf_part(visible, warnings, "an image is too large to read from them")
-        }
         Ok((mut done, notes)) => {
             done.setup.bleed = visible.setup.bleed;
             let mut all = warnings;
@@ -193,14 +188,13 @@ pub fn ai_layers_alone(private: &[u8], pages: &[(f64, f64)], unit: f64) -> Resul
     if !has_layers(&data) {
         return Err(AiLayers { data: Ok(data), structure: None });
     }
-    let structure = match ai::read(&data, false) {
+    // An image past the hard limits is read as an unread box, which the PDF part's art replaces.
+    let structure = match ai::read_over_page(&data, false) {
         Ok(structure) => structure,
         Err(why) => return Err(AiLayers { data: Ok(data), structure: Some(Err(why)) }),
     };
     match build_without_page(structure, &data, pages, unit) {
-        // An image too large for the editing data's reader is missing from the layers: the PDF
-        // part has it (as in `layered_ai`).
-        Ok(Ok((doc, notes))) if !notes.iter().any(|n| n == ai::IMAGE_TOO_LARGE) => Ok((doc, notes)),
+        Ok(Ok((doc, notes))) => Ok((doc, notes)),
         Ok(_) => Err(AiLayers { data: Ok(data), structure: None }),
         Err(structure) => Err(AiLayers { data: Ok(data), structure: Some(Ok(structure)) }),
     }
diff --git a/crates/eps/src/import/tests_native.rs b/crates/eps/src/import/tests_native.rs
index 32c4ff796..329c5fb86 100644
--- a/crates/eps/src/import/tests_native.rs
+++ b/crates/eps/src/import/tests_native.rs
@@ -1215,27 +1215,89 @@ fn in_points(mut d: Document, k: f64) -> Document {
     d
 }
 
-/// #1479: an image larger than the editing data's reader takes would be missing from the layers,
-/// while the PDF part has it (it reads larger images): the file comes in as its PDF part, with a
-/// note saying why, rather than without the image.
+/// A 1-bit gray image of `w` × `h` pixels in the format's operators, its samples `rows` (binary,
+/// rows padded to whole bytes, a set bit white), placed by the matrix `m`.
+fn raster_1bit(m: &str, (w, h): (u32, u32), rows: &str) -> String {
+    format!(
+        "%AI5_File:\n%AI5_BeginRaster\n() 1 XG\n/DeviceGray XN\n[ {m} ] {w} {h} 0 Xh\n\
+         [ {m} ] 0 0 {w} {h} {w} {h} 1 1 0 0 1 0 4 4 0 0\n%%BeginData: {}\rXI\n{rows}%%EndData\r\nXH\r\n%AI5_EndRaster\r\nN",
+        rows.len()
+    )
+}
+
+/// #1479: an image past 2^25 pixels keeps the layers, at full size; a 1-bit one is a 1-bit PNG of
+/// its rows.
 #[test]
-fn an_ai_file_with_an_image_too_large_for_its_editing_data_comes_in_as_its_pdf_part() {
-    let raster = |w: u32, h: u32| {
-        format!(
-            "%AI5_File:\n%AI5_BeginRaster\n() 1 XG\n/DeviceGray XN\n[ 1 0 0 1 0 100 ] {w} {h} 0 Xh\n\
-             [ 1 0 0 1 0 100 ] 0 0 {w} {h} {w} {h} 8 1 0 0 1 0 4 4 0 0\n%%BeginData: 1\rXI\n\u{0}%%EndData\r\nXH\r\n%AI5_EndRaster\r\nN"
-        )
-    };
-    // 6,000 × 6,000 pixels: past the reader's 2^25.
-    let art = native(&layer("Texture", true, &format!("{}\n{}", square(10, 10), raster(6000, 6000))));
+fn an_ai_file_with_an_image_past_2_25_pixels_keeps_its_layers() {
+    // 6,000 × 6,000 pixels, each row black and white in turn ('U' is 01010101).
+    let image = raster_1bit("0.0005 0 0 0.0005 50 14", (6000, 6000), &"U".repeat(750 * 6000));
+    let art = native(&(layer("Live", true, &square(10, 10)) + &layer("Texture", true, &image)));
     let (d, warnings, read) = crate::layered_ai(&private(&art), pdf_part(10.0, 86.0), vec![], false, true, 1.0);
-    assert!(!read, "the PDF part is used: {warnings:?}");
-    assert!(warnings.iter().any(|w| w.contains("an image is too large to read from them")), "{warnings:?}");
-    assert_eq!(d.layers[0].children().map_or(0, |c| c.len()), 1, "the PDF part's art");
-    // An image the reader takes keeps the layers.
-    let art = native(&layer("Texture", true, &format!("{}\n{}", square(10, 10), raster(1, 1))));
-    let (_, warnings, read) = crate::layered_ai(&private(&art), pdf_part(10.0, 86.0), vec![], false, true, 1.0);
     assert!(read, "{warnings:?}");
+    assert_eq!(names(&d), ["Live", "Texture"]);
+    assert_eq!(kinds(&d.layers[0]), ["path"]);
+    let [image] = d.layers[1].children().unwrap().as_slice() else { panic!("{:?}", d.layers[1]) };
+    let NodeKind::Image(im) = &image.kind else { panic!("{image:?}") };
+    assert_eq!((im.width, im.height), (6000, 6000));
+    let png = &d.images[&im.key].bytes;
+    // Bit depth 1, colour type 0 (gray).
+    assert_eq!(png.get(24..26), Some([1, 0].as_slice()));
+    let gray = image::load_from_memory(png).unwrap().to_luma8();
+    assert_eq!((gray.get_pixel(0, 0)[0], gray.get_pixel(1, 0)[0], gray.get_pixel(5999, 5999)[0]), (0, 255, 255));
+    assert!(warnings.iter().all(|w| !w.contains("image")), "{warnings:?}");
+}
+
+/// An image past the target size is averaged down by the smallest whole step that fits, a 1-bit
+/// one into gray coverage, the blocks at its edges over the pixels they have; it covers the box
+/// the full size would.
+#[test]
+fn an_ai_image_past_the_target_size_is_reduced_and_keeps_the_layers() {
+    // 17 × 13 pixels: rows black, and in turn (the first one) white but for columns 0, 8 and 16.
+    let rows: String = (0..13).map(|y| if y % 2 == 0 { "\u{7f}\u{7f}\0" } else { "\0\0\0" }).collect();
+    let image = raster_1bit("1 0 0 1 50 14", (17, 13), &rows);
+    let art = native(&(layer("Live", true, &square(10, 10)) + &layer("Texture", true, &image)));
+    let (d, warnings, read) = crate::import::ai::with_image_limits(20, 1 << 31, 512 << 20, || {
+        crate::layered_ai(&private(&art), pdf_part(10.0, 86.0), vec![], false, true, 1.0)
+    });
+    assert!(read, "{warnings:?}");
+    assert_eq!(names(&d), ["Live", "Texture"]);
+    assert!(warnings.contains(&"an embedded image of 17 × 13 pixels was reduced to 5 × 4 pixels to keep the layers".to_string()), "{warnings:?}");
+    let [image] = d.layers[1].children().unwrap().as_slice() else { panic!("{:?}", d.layers[1]) };
+    let NodeKind::Image(im) = &image.kind else { panic!("{image:?}") };
+    assert_eq!((im.width, im.height), (5, 4));
+    let full = im.xf.transform_rect_bbox(vectorcraft_geom::Rect::new(0.0, 0.0, 5.0, 4.0));
+    assert!(
+        (full.x0 - 50.0).abs() < 1e-9 && (full.x1 - 67.0).abs() < 1e-9 && (full.y0 - 86.0).abs() < 1e-9 && (full.y1 - 99.0).abs() < 1e-9,
+        "{full:?}"
+    );
+    let gray = image::load_from_memory(&d.images[&im.key].bytes).unwrap().to_luma8();
+    // Steps of 4: blocks of rows 0–11 are half white rows, the last block row 12 alone; blocks of
+    // columns 0–3 and 8–11 have 3 white columns of 4, and the last block column 16 alone.
+    let rows: Vec<Vec<u8>> = (0..4).map(|y| (0..5).map(|x| gray.get_pixel(x, y)[0]).collect()).collect();
+    assert_eq!(rows, [vec![96, 128, 96, 128, 0], vec![96, 128, 96, 128, 0], vec![96, 128, 96, 128, 0], vec![191, 255, 191, 255, 0]]);
+}
+
+/// An image past the hard limits is a box that the page's art inside it replaces, and the
+/// layers stay; without page art (the editing data alone), it is left out with a note.
+#[test]
+fn an_ai_image_past_the_hard_limits_comes_in_as_the_pages_art() {
+    let image = raster_1bit("1 0 0 1 50 14", (4, 4), &"\0".repeat(4));
+    let art = native(&(layer("Live", true, &square(10, 10)) + &layer("Texture", true, &image)));
+    let (d, notes, read) =
+        crate::import::ai::with_image_limits(20, 15, 512 << 20, || crate::layered_ai(&private(&art), pdf_two_squares(), vec![], false, false, 1.0));
+    assert!(read, "{notes:?}");
+    assert_eq!(names(&d), ["Live", "Texture"]);
+    assert_eq!(kinds(&d.layers[1]), ["group[1]"]);
+    replacement_is_cyan(&d, 1, 0);
+    assert!(notes.iter().any(|n| n.contains("very large images") && n.contains("they came in as the page's art")), "{notes:?}");
+    // Past the bytes the samples may take, too.
+    let (_, notes, read) =
+        crate::import::ai::with_image_limits(20, 1 << 31, 1, || crate::layered_ai(&private(&art), pdf_two_squares(), vec![], false, false, 1.0));
+    assert!(read && notes.iter().any(|n| n.contains("very large images")), "{notes:?}");
+    let (d, notes) = crate::import::ai::with_image_limits(20, 15, 512 << 20, || crate::ai_alone(&private(&art))).unwrap();
+    assert_eq!(names(&d), ["Live", "Texture"]);
+    assert!(d.layers[1].children().unwrap().is_empty());
+    assert!(notes.iter().any(|n| n == "an image too large to read from the editing data was left out"), "{notes:?}");
 }
 
 /// A `.ai` whose layers hold a placed PDF and no text object: its PDF part draws the placed file,
@@ -1322,7 +1384,9 @@ fn an_ai_file_that_comes_in_as_its_pdf_part_keeps_the_swatches_of_its_palette()
     let mut part = pdf_part(10.0, 86.0);
     let gold = vectorcraft_color::Paint::solid(vectorcraft_color::Color::cmyk(0.0, 0.2, 0.9, 0.1));
     part.swatches.push(vectorcraft_color::swatch::Swatch { name: "Gold ink".into(), paint: gold, global: true, spot: true });
-    let (d, warnings, read) = crate::layered_ai(&private(&art), part, vec![], false, true, 1.0);
+    // An image past 2^25 pixels isn't read here, and the page has no art of its own in its box.
+    let (d, warnings, read) =
+        crate::import::ai::with_image_limits(1 << 26, 1 << 25, 512 << 20, || crate::layered_ai(&private(&art), part, vec![], false, true, 1.0));
     assert!(!read, "the PDF part is used: {warnings:?}");
     let swatches: Vec<&str> = d.swatches.iter().map(|s| s.name.as_str()).collect();
     assert_eq!(swatches, ["[None]", "White", "Gold ink"], "{warnings:?}");
@@ -4434,6 +4498,56 @@ fn aligned_type_round_a_circle_runs_along_its_path_as_the_file_lays_it_out() {
     }
 }
 
+/// Type aligned to a circle by its ascender, center or descender, in the default face at 12 pt: the
+/// file's baselines lie inside the path by the top of the face's em box (its `BASE` table's
+/// `ideo` -170 plus one em), half the height of its H's top (656 units) or the bottom of its
+/// bounding box (-295), and laid out, the type's baselines lie where the file has them.
+#[test]
+fn aligned_type_lies_as_far_from_its_path_as_the_file_lays_it_out() {
+    let k = 40.0 * 0.552_284_75;
+    let points = [
+        (90.0, 50.0),
+        (90.0, 50.0 - k),
+        (50.0 + k, 10.0),
+        (50.0, 10.0),
+        (50.0 - k, 10.0),
+        (10.0, 50.0 - k),
+        (10.0, 50.0),
+        (10.0, 50.0 + k),
+        (50.0 - k, 90.0),
+        (50.0, 90.0),
+        (50.0 + k, 90.0),
+        (90.0, 50.0 + k),
+        (90.0, 50.0),
+    ];
+    let all: Vec<(f64, f64)> = points.iter().map(|(x, y)| canvas(*x, *y)).collect();
+    let segment = |i: usize| (0..4).map(|j| format!("{} {}", all[i * 3 + j].0, all[i * 3 + j].1)).collect::<Vec<_>>().join(" ");
+    for (key, align, inside) in [
+        (0, vectorcraft_doc::PathAlign::Ascender, 0.83 * 12.0),
+        (2, vectorcraft_doc::PathAlign::Center, 0.328 * 12.0),
+        (1, vectorcraft_doc::PathAlign::Descender, -0.295 * 12.0),
+    ] {
+        let frame = format!(
+            "<< /0 << /0 [ 0 0 ] /1 << /0 [ {} ] >> /2 << /0 2 /6 [ 2.0 5.99 ] /11 << /2 {key} >> >> >> >>",
+            (0..4).map(segment).collect::<Vec<_>>().join(" ")
+        );
+        let radius = 40.0 - inside;
+        let doc = document_of(&[frame], &[round_story_with("abcdefgh", 5.0, radius, radius / 48.0, &format!("/0 << /0 [ 0 {inside:.3} ] >>"))]);
+        let art = native_with_text(&(layer("Back", true, &square(10, 10)) + &layer("Spare", false, &text_object(0))), &doc);
+        let r = import(&eps(&page_square(10, 10), &art)).unwrap();
+        let texts = text_of(&r.document.layers[1]);
+        assert_eq!(texts.len(), 1, "{align:?}: {:?}", r.warnings);
+        assert_eq!(texts[0].path_align, align);
+        let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), texts[0]);
+        assert_eq!(layout.glyphs.len(), 8);
+        // The four cubics stray up to 0.011 from the circle.
+        for g in &layout.glyphs {
+            let (x, y) = (g.origin.x + g.angle.cos() * g.advance * 0.5 - 50.0, g.origin.y + g.angle.sin() * g.advance * 0.5 - 50.0);
+            assert!((x.hypot(y) - radius).abs() < 0.02, "{align:?}: {} from the center, want {radius}", x.hypot(y));
+        }
+    }
+}
+
 #[test]
 fn threaded_area_type_flows_through_its_frames() {
     let frames = [
diff --git a/crates/eps/src/legacy_ai.rs b/crates/eps/src/legacy_ai.rs
index de2c9b384..c5c1c4c26 100644
--- a/crates/eps/src/legacy_ai.rs
+++ b/crates/eps/src/legacy_ai.rs
@@ -65,8 +65,8 @@ use std::sync::Arc;
 use vectorcraft_color::cms::Cms;
 use vectorcraft_color::{BlendMode, Color, Gradient, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{
-    AppearanceItem, AreaOptions, CharPosition, CharStyle, Document, FillLayer, ImageBlob, Justify, LAYER_COLORS, LayerColor, Node, NodeKind,
-    ParaDirection, ParaStyle, PathAlign, PathEffect, StrokeLayer, TextKind, TextObject,
+    AppearanceItem, AreaOptions, CharPosition, CharStyle, CompositeFont, Document, FillLayer, ImageBlob, Justify, LAYER_COLORS, LayerColor, Node,
+    NodeKind, ParaDirection, ParaStyle, PathAlign, PathEffect, StrokeLayer, TextKind, TextObject,
 };
 use vectorcraft_effects::stroke;
 use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Rect, Shape, SubPath, Vec2};
@@ -180,6 +180,8 @@ pub fn export_legacy_ai(doc: &Document, o: &LegacyAiOptions) -> Result<LegacyAiO
     if !(board.is_finite() && board.width() > 0.0 && board.height() > 0.0) {
         return Err("the document has no artboard".into());
     }
+    // Type in the document's composite fonts is drawn in them, whether or not an app has the document open.
+    let _lent = vectorcraft_text::FontDb::global().lend_composite_fonts(&doc.composite_fonts);
     // The document is y down; art space y up from the artboard's left edge, its top on a whole point.
     let (width, height) = (board.width(), board.height());
     let top = if (height - height.round()).abs() < 1e-6 { height.round() } else { height.ceil() };
diff --git a/crates/eps/src/legacy_ai/encoding.rs b/crates/eps/src/legacy_ai/encoding.rs
index c2346cbb9..8ea787f8a 100644
--- a/crates/eps/src/legacy_ai/encoding.rs
+++ b/crates/eps/src/legacy_ai/encoding.rs
@@ -1,7 +1,7 @@
 use super::writer::Writer;
 use super::{
-    Affine, AreaOptions, BezPath, CharPosition, CharStyle, Gradient, GradientKind, Paint, ParaStyle, PathAlign, PathEffect, StrokeLayer, TextKind,
-    TextObject, Write, latin, ps, stroke,
+    Affine, AreaOptions, BezPath, CharPosition, CharStyle, CompositeFont, Document, Gradient, GradientKind, Paint, ParaStyle, PathAlign, PathEffect,
+    StrokeLayer, TextKind, TextObject, Write, latin, ps, stroke,
 };
 
 /// A gradient definition: `%AI5_BeginGradient: (name)`, `(name) type stops Bd`, `[`, the stops
@@ -78,10 +78,11 @@ pub(super) fn latin_string(name: &str) -> String {
     ps::bytes(&bytes)
 }
 
-/// Can type `t` be written as text: 8-bit text can hold it ([`holds_as_text`]) and no character
-/// is rotated ([`rotated`])?
-pub(super) fn writable(t: &TextObject) -> bool {
-    holds_as_text(t) && !rotated(t)
+/// Can type `t` of document `doc` be written as text: 8-bit text can hold it ([`holds_as_text`]),
+/// no character is rotated ([`rotated`]) and no run is set in one of the document's composite
+/// fonts, which a reader can't find by its name?
+pub(super) fn writable(doc: &Document, t: &TextObject) -> bool {
+    holds_as_text(t) && !rotated(t) && !t.runs.iter().any(|r| CompositeFont::named(&doc.composite_fonts, &r.style.font_family).is_some())
 }
 
 /// Has type `t` visible characters with Character Rotation? A legacy `.ai` text object's character
diff --git a/crates/eps/src/legacy_ai/tests.rs b/crates/eps/src/legacy_ai/tests.rs
index b34c127a7..c3ca85c08 100644
--- a/crates/eps/src/legacy_ai/tests.rs
+++ b/crates/eps/src/legacy_ai/tests.rs
@@ -136,9 +136,9 @@ fn as_printed(doc: &Document, o: &LegacyAiOptions) -> Document {
         nodes.extend(layout.glyphs.iter().filter_map(|g| g.placed_colour(t.xf)).map(Arc::new));
         Node::group(vectorcraft_doc::NodeId(0), nodes)
     }
-    fn plain(nodes: &mut Vec<Arc<Node>>, o: &LegacyAiOptions, images: &mut std::collections::BTreeMap<String, ImageBlob>) {
+    fn plain(doc: &Document, nodes: &mut Vec<Arc<Node>>, o: &LegacyAiOptions, images: &mut std::collections::BTreeMap<String, ImageBlob>) {
         nodes.retain(|n| match &n.kind {
-            NodeKind::Text(t) => o.outline_text || !writable(t),
+            NodeKind::Text(t) => o.outline_text || !writable(doc, t),
             NodeKind::Layer { printable, .. } => *printable,
             _ => true,
         });
@@ -160,13 +160,13 @@ fn as_printed(doc: &Document, o: &LegacyAiOptions) -> Document {
                 }
             }
             if let Some(c) = n.children_mut() {
-                plain(c, o, images);
+                plain(doc, c, o, images);
             }
         }
     }
     let mut d = doc.clone();
     let mut images = std::mem::take(&mut d.images);
-    plain(&mut d.layers, o, &mut images);
+    plain(doc, &mut d.layers, o, &mut images);
     d.images = images;
     d
 }
diff --git a/crates/eps/src/legacy_ai/writer.rs b/crates/eps/src/legacy_ai/writer.rs
index ae8fddc70..cf601e939 100644
--- a/crates/eps/src/legacy_ai/writer.rs
+++ b/crates/eps/src/legacy_ai/writer.rs
@@ -673,7 +673,7 @@ impl<'a> Writer<'a> {
         let resolved = vectorcraft_text::FontDb::global().font_heights_resolved(t);
         let t = &*resolved;
         if !self.outline_text {
-            if writable(t) {
+            if writable(self.doc, t) {
                 return self.text_object(t);
             }
             if !holds_as_text(t) {
diff --git a/crates/eps/src/lib.rs b/crates/eps/src/lib.rs
index bf515de66..e8fd85764 100644
--- a/crates/eps/src/lib.rs
+++ b/crates/eps/src/lib.rs
@@ -224,6 +224,8 @@ pub fn export(doc: &Document, opts: &EpsOptions, preview: Option<&Raster>, thumb
     if ![r.x0, r.y0, r.x1, r.y1, opts.origin.x, opts.origin.y].iter().all(|v| v.is_finite()) {
         return Err("the export region is not finite".into());
     }
+    // Type in the document's composite fonts is drawn in them, whether or not an app has the document open.
+    let _lent = vectorcraft_text::FontDb::global().lend_composite_fonts(&doc.composite_fonts);
     let baked = vectorcraft_effects::bake_document(doc);
     let doc = baked.as_ref().unwrap_or(doc);
     let page = scene::Scene::new(doc, opts).run();
diff --git a/crates/pdf/src/export/entry.rs b/crates/pdf/src/export/entry.rs
index 92607d5c5..c64d4a6f5 100644
--- a/crates/pdf/src/export/entry.rs
+++ b/crates/pdf/src/export/entry.rs
@@ -9,6 +9,8 @@ pub fn export(doc: &Document, opts: &PdfOptions) -> Result<Vec<u8>, PdfError> {
 /// Like [`export`], also returning warnings: options accepted but not applied yet (see
 /// [`crate::PdfSettings::warnings`]) and features approximated or dropped.
 pub fn export_with_report(doc: &Document, opts: &PdfOptions) -> Result<ExportReport, PdfError> {
+    // Type in the document's composite fonts is drawn in them, whether or not an app has the document open.
+    let _lent = vectorcraft_text::FontDb::global().lend_composite_fonts(&doc.composite_fonts);
     write::guard(|| leaving_out_undecodable(doc, |left_out| export_with_report_inner(doc, opts, left_out)))
 }
 
diff --git a/crates/plugins/src/host.rs b/crates/plugins/src/host.rs
index f47d8e69b..017df5a80 100644
--- a/crates/plugins/src/host.rs
+++ b/crates/plugins/src/host.rs
@@ -1,20 +1,28 @@
 //! What a plug-in may import from the host ([`IMPORTS`]), from plug-in API level 2 on:
 //! `vc_progress` reports how far a run has got, `vc_cancelled` tells it the user or a host limit
-//! asked it to stop, and `vc_log` writes a log line. A module may import them only when its
-//! manifest gives `api` 2 and lists the `progress` permission, and the host checks each import when
-//! the module is loaded ([`check_imports`], [`check_granted`]): one it doesn't offer, one with
-//! another signature and one the manifest doesn't allow are refused by name.
+//! asked it to stop, and `vc_log` writes a log line (the `progress` permission); `vc_settings_*`
+//! read and write its settings (`settings`) and `vc_cache_*` its cache (`cache`, [`crate::storage`]).
+//! A module may import one only when its manifest gives `api` 2 and lists the import's permission,
+//! and the host checks each import when the module is loaded ([`check_imports`], [`check_granted`]):
+//! one it doesn't offer, one with another signature and one the manifest doesn't allow are refused
+//! by name.
 //!
 //! Each call's arguments are checked: progress is clamped and passed on only when it changes (with
 //! a known total, to another tenth of a percent; past [`MAX_PROGRESS_REPORTS`], once per
 //! [`PROGRESS_STRIDE`] changes), log text must lie inside the module's memory and be UTF-8, and
 //! each line ([`MAX_LOG_LINE`]) and each run ([`MAX_LOG_LINES`], [`MAX_LOG_BYTES`],
-//! [`MAX_LOG_READ`]) are capped. Nothing a module passes can panic the host.
+//! [`MAX_LOG_READ`]) are capped. Keys and values must lie inside the module's memory, keys must be
+//! [`crate::storage::valid_name`]s, values are capped, and so are each run's storage calls
+//! ([`MAX_STORAGE_CALLS`]) and the bytes they move ([`MAX_STORAGE_BYTES`]). Nothing a module passes
+//! can panic the host.
+
+use std::sync::Arc;
 
 use wasmi::{Caller, Engine, Extern, ExternType, Linker, Module, StoreLimits, ValType};
 
 use crate::manifest::Manifest;
 use crate::permissions::{self, PROGRESS_API, Permission};
+use crate::storage::{self, Meter, Storage, StorageError};
 use crate::{Error, Result};
 
 /// The module a plug-in imports host functions from (the name a Rust or C toolchain gives
@@ -60,16 +68,51 @@ pub const LOG_NOT_UTF8: i32 = -2;
 /// What `vc_log` returns: the level is not 0 to 3.
 pub const LOG_BAD_LEVEL: i32 = -3;
 
-/// One host import: its name and its type.
+/// What a storage import that writes or removes returns when it did.
+pub const STORAGE_DONE: i32 = 0;
+/// What a storage import returns: the key or entry has no value.
+pub const STORAGE_NOT_FOUND: i32 = -1;
+/// What a storage import returns: a key, value or buffer doesn't lie inside the module's memory.
+pub const STORAGE_OUTSIDE_MEMORY: i32 = -2;
+/// What a storage import returns: the key is not a [`crate::storage::valid_name`].
+pub const STORAGE_BAD_NAME: i32 = -3;
+/// What a storage import returns: the write would pass a cap ([`crate::storage`]); nothing changed.
+pub const STORAGE_FULL: i32 = -4;
+/// What a storage import returns: there is nowhere to keep anything (no plug-in store, as on the
+/// web, or a module that isn't installed).
+pub const STORAGE_UNAVAILABLE: i32 = -5;
+/// What a storage import returns: reading or writing the file failed.
+pub const STORAGE_FAILED: i32 = -6;
+/// What a storage import returns: the run used up its storage calls or bytes
+/// ([`MAX_STORAGE_CALLS`], [`MAX_STORAGE_BYTES`]).
+pub const STORAGE_BUDGET: i32 = -7;
+
+/// Most storage calls one run makes; later ones return [`STORAGE_BUDGET`].
+pub const MAX_STORAGE_CALLS: usize = 10_000;
+
+/// Most bytes one run's storage calls read and write, all together, counting the whole settings
+/// file each settings call reads and writes and each cache entry read or written; a call that would
+/// pass it returns [`STORAGE_BUDGET`].
+pub const MAX_STORAGE_BYTES: usize = 1 << 30;
+
+/// One host import: its name, its type and the permission it needs.
 pub struct Import {
     pub name: &'static str,
     params: &'static [ValType],
     results: &'static [ValType],
     /// Its type as WebAssembly text writes it.
     pub signature: &'static str,
+    pub permission: Permission,
 }
 
-/// The host imports of API level 2, in module [`MODULE`]:
+const I32: ValType = ValType::I32;
+
+/// An import that takes `params` i32 arguments and returns an i32.
+const fn storage_import(name: &'static str, params: &'static [ValType], signature: &'static str, permission: Permission) -> Import {
+    Import { name, params, results: &[I32], signature, permission }
+}
+
+/// The host imports of API level 2, in module [`MODULE`]. With `progress`:
 ///
 /// - `vc_progress(done: i64, total: i64)`: `done` of `total` steps are finished (`total` 0 or less:
 ///   not known). Negative values count as 0 and `done` is clamped to `total`;
@@ -77,17 +120,71 @@ pub struct Import {
 /// - `vc_log(level: i32, ptr: i32, len: i32) -> i32`: writes the UTF-8 text at `ptr` as a log line
 ///   of `level` (0 error, 1 warning, 2 information, 3 debug) → [`LOG_WRITTEN`], [`LOG_DROPPED`],
 ///   [`LOG_OUTSIDE_MEMORY`], [`LOG_NOT_UTF8`] or [`LOG_BAD_LEVEL`].
-pub const IMPORTS: [Import; 3] = [
-    Import { name: "vc_progress", params: &[ValType::I64, ValType::I64], results: &[], signature: "(param i64 i64)" },
-    Import { name: "vc_cancelled", params: &[], results: &[ValType::I32], signature: "(result i32)" },
+///
+/// With `settings`, for the key of `key_len` bytes at `key`:
+///
+/// - `vc_settings_get(key, key_len, out, out_cap) -> i32`: the value's length, its bytes copied to
+///   `out` when they fit in `out_cap` (nothing is copied otherwise);
+/// - `vc_settings_set(key, key_len, value, value_len) -> i32`: sets it → [`STORAGE_DONE`];
+/// - `vc_settings_delete(key, key_len) -> i32`: removes it → [`STORAGE_DONE`].
+///
+/// With `cache`, the same for the entry named at `name`: `vc_cache_read`, `vc_cache_write` and
+/// `vc_cache_clear(name, name_len)`, which removes the entry, or every entry when `name_len` is 0.
+///
+/// A storage call that fails returns [`STORAGE_NOT_FOUND`], [`STORAGE_OUTSIDE_MEMORY`],
+/// [`STORAGE_BAD_NAME`], [`STORAGE_FULL`], [`STORAGE_UNAVAILABLE`], [`STORAGE_FAILED`] or
+/// [`STORAGE_BUDGET`].
+pub const IMPORTS: [Import; 9] = [
+    Import {
+        name: "vc_progress",
+        params: &[ValType::I64, ValType::I64],
+        results: &[],
+        signature: "(param i64 i64)",
+        permission: Permission::Progress,
+    },
+    Import { name: "vc_cancelled", params: &[], results: &[I32], signature: "(result i32)", permission: Permission::Progress },
     Import {
         name: "vc_log",
-        params: &[ValType::I32, ValType::I32, ValType::I32],
-        results: &[ValType::I32],
+        params: &[I32, I32, I32],
+        results: &[I32],
         signature: "(param i32 i32 i32) (result i32)",
+        permission: Permission::Progress,
     },
+    storage_import("vc_settings_get", &[I32, I32, I32, I32], "(param i32 i32 i32 i32) (result i32)", Permission::Settings),
+    storage_import("vc_settings_set", &[I32, I32, I32, I32], "(param i32 i32 i32 i32) (result i32)", Permission::Settings),
+    storage_import("vc_settings_delete", &[I32, I32], "(param i32 i32) (result i32)", Permission::Settings),
+    storage_import("vc_cache_read", &[I32, I32, I32, I32], "(param i32 i32 i32 i32) (result i32)", Permission::Cache),
+    storage_import("vc_cache_write", &[I32, I32, I32, I32], "(param i32 i32 i32 i32) (result i32)", Permission::Cache),
+    storage_import("vc_cache_clear", &[I32, I32], "(param i32 i32) (result i32)", Permission::Cache),
 ];
 
+/// Which of a plug-in's stores a storage import reads or writes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Area {
+    Settings,
+    Cache,
+}
+
+impl Area {
+    /// The largest value one key or entry holds.
+    fn max_value(self) -> usize {
+        match self {
+            Area::Settings => storage::MAX_SETTING_BYTES,
+            Area::Cache => storage::MAX_CACHE_ENTRY,
+        }
+    }
+}
+
+/// What a storage import returns for `e`.
+fn storage_code(e: &StorageError) -> i32 {
+    match e {
+        StorageError::Full => STORAGE_FULL,
+        StorageError::Unavailable => STORAGE_UNAVAILABLE,
+        StorageError::Io(_) => STORAGE_FAILED,
+        StorageError::Budget => STORAGE_BUDGET,
+    }
+}
+
 /// A log line's level.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum LogLevel {
@@ -189,6 +286,11 @@ pub(crate) struct Run {
     /// Bytes of log text written (with their escapes) and read.
     log_bytes: usize,
     log_read: usize,
+    /// Where the plug-in keeps its settings and cache (none while the module is being loaded), and
+    /// how many storage calls the run made and bytes they moved.
+    storage: Option<Arc<dyn Storage>>,
+    storage_calls: usize,
+    storage_bytes: usize,
     pub(crate) report: Report,
 }
 
@@ -204,10 +306,111 @@ impl Run {
             skipped: 0,
             log_bytes: 0,
             log_read: 0,
+            storage: None,
+            storage_calls: 0,
+            storage_bytes: 0,
             report: Report::default(),
         }
     }
 
+    /// The run, with the plug-in's settings and cache kept in `storage`.
+    pub(crate) fn with_storage(mut self, storage: Option<Arc<dyn Storage>>) -> Self {
+        self.storage = storage;
+        self
+    }
+
+    /// Makes one storage call with `call`, on the plug-in's storage and a [`Meter`] holding the
+    /// run's storage bytes left, and counts the call and the bytes it read and wrote → the code for
+    /// a run that has used up its calls or has no storage, else what `call` returns.
+    fn metered<T>(&mut self, call: impl FnOnce(&dyn Storage, &mut Meter) -> std::result::Result<T, StorageError>) -> std::result::Result<T, i32> {
+        if self.storage_calls >= MAX_STORAGE_CALLS {
+            return Err(STORAGE_BUDGET);
+        }
+        self.storage_calls += 1;
+        let Some(store) = self.storage.clone() else { return Err(STORAGE_UNAVAILABLE) };
+        let mut meter = Meter::new(MAX_STORAGE_BYTES.saturating_sub(self.storage_bytes) as u64);
+        let done = call(store.as_ref(), &mut meter);
+        // What the call read before it failed counts too.
+        self.storage_bytes = self.storage_bytes.saturating_add(usize::try_from(meter.used()).unwrap_or(usize::MAX));
+        done.map_err(|e| storage_code(&e))
+    }
+
+    /// The key or entry name of `len` bytes at `ptr` in `memory`, checked, or the code a storage
+    /// import returns for it.
+    fn storage_name(memory: &[u8], ptr: usize, len: usize) -> std::result::Result<String, i32> {
+        let bytes = ptr.checked_add(len).and_then(|end| memory.get(ptr..end)).ok_or(STORAGE_OUTSIDE_MEMORY)?;
+        let name = std::str::from_utf8(bytes).ok().filter(|n| storage::valid_name(n)).ok_or(STORAGE_BAD_NAME)?;
+        Ok(name.to_string())
+    }
+
+    /// `vc_settings_get` and `vc_cache_read`: copies the value of the key at `name` into the
+    /// `out_cap` bytes at `out` when it fits → its length.
+    fn storage_read(&mut self, area: Area, memory: &mut [u8], name: (usize, usize), out: (usize, usize)) -> i32 {
+        let key = match Self::storage_name(memory, name.0, name.1) {
+            Ok(key) => key,
+            Err(code) => return code,
+        };
+        if out.1 > 0 && out.0.checked_add(out.1).is_none_or(|end| end > memory.len()) {
+            return STORAGE_OUTSIDE_MEMORY;
+        }
+        // The storage counts what it read whether or not the value fits the buffer.
+        let got = self.metered(|store, meter| match area {
+            Area::Settings => store.setting(&key, meter),
+            Area::Cache => store.cache_entry(&key, meter),
+        });
+        let value = match got {
+            Ok(Some(value)) => value,
+            Ok(None) => return STORAGE_NOT_FOUND,
+            Err(code) => return code,
+        };
+        let Ok(len) = i32::try_from(value.len()) else { return STORAGE_FAILED };
+        if value.len() <= out.1
+            && let Some(dest) = memory.get_mut(out.0..out.0 + value.len())
+        {
+            dest.copy_from_slice(&value);
+        }
+        len
+    }
+
+    /// `vc_settings_set` and `vc_cache_write`: sets the key at `name` to the `value` bytes.
+    fn storage_write(&mut self, area: Area, memory: &[u8], name: (usize, usize), value: (usize, usize)) -> i32 {
+        let key = match Self::storage_name(memory, name.0, name.1) {
+            Ok(key) => key,
+            Err(code) => return code,
+        };
+        let Some(bytes) = value.0.checked_add(value.1).and_then(|end| memory.get(value.0..end)) else { return STORAGE_OUTSIDE_MEMORY };
+        if bytes.len() > area.max_value() {
+            return STORAGE_FULL;
+        }
+        let written = self.metered(|store, meter| match area {
+            Area::Settings => store.set_setting(&key, bytes, meter),
+            Area::Cache => store.set_cache_entry(&key, bytes, meter),
+        });
+        written.map_or_else(|code| code, |()| STORAGE_DONE)
+    }
+
+    /// `vc_settings_delete` and `vc_cache_clear`: removes the key at `name`, or with `vc_cache_clear`
+    /// and a `name` of no bytes, every cache entry.
+    fn storage_remove(&mut self, area: Area, memory: &[u8], name: (usize, usize)) -> i32 {
+        let key = match (area, name.1) {
+            (Area::Cache, 0) => None,
+            _ => match Self::storage_name(memory, name.0, name.1) {
+                Ok(key) => Some(key),
+                Err(code) => return code,
+            },
+        };
+        let removed = self.metered(|store, meter| match (area, key) {
+            (Area::Settings, Some(key)) => store.delete_setting(&key, meter),
+            (Area::Cache, Some(key)) => store.remove_cache_entry(&key),
+            (_, None) => store.clear_cache().map(|_| true),
+        });
+        match removed {
+            Ok(true) => STORAGE_DONE,
+            Ok(false) => STORAGE_NOT_FOUND,
+            Err(code) => code,
+        }
+    }
+
     fn progress(&mut self, done: i64, total: i64) {
         let total = u64::try_from(total).unwrap_or(0);
         let done = u64::try_from(done).unwrap_or(0);
@@ -286,55 +489,89 @@ pub(crate) struct Host {
     pub(crate) run: Run,
 }
 
-/// A linker that offers the host imports when `granted`, and no import otherwise.
-pub(crate) fn linker(engine: &Engine, granted: bool) -> Linker<Host> {
+/// The module's memory and the store's state, for an import that reads or writes the memory.
+fn memory_and_host<'a>(caller: &'a mut Caller<'_, Host>) -> Option<(&'a mut [u8], &'a mut Host)> {
+    let Some(Extern::Memory(memory)) = caller.get_export("memory") else { return None };
+    Some(memory.data_and_store_mut(caller))
+}
+
+/// An i32 argument as the unsigned offset or length it stands for.
+fn offset(v: i32) -> usize {
+    v as u32 as usize
+}
+
+/// A linker that offers the host imports whose permission is in `granted`, and no other import.
+pub(crate) fn linker(engine: &Engine, granted: &[Permission]) -> Linker<Host> {
     let mut linker = Linker::<Host>::new(engine);
-    if granted {
-        // Each name is defined once, so none of these fails.
+    // Each name is defined once, so none of these fails.
+    if granted.contains(&Permission::Progress) {
         let _ = linker.func_wrap(MODULE, "vc_progress", |mut caller: Caller<'_, Host>, done: i64, total: i64| {
             caller.data_mut().run.progress(done, total);
         });
         let _ = linker.func_wrap(MODULE, "vc_cancelled", |caller: Caller<'_, Host>| -> i32 { caller.data().run.cancelled() });
         let _ = linker.func_wrap(MODULE, "vc_log", |mut caller: Caller<'_, Host>, level: i32, ptr: i32, len: i32| -> i32 {
-            let Some(Extern::Memory(memory)) = caller.get_export("memory") else { return LOG_OUTSIDE_MEMORY };
-            let (data, host) = memory.data_and_store_mut(&mut caller);
-            host.run.log(level, data, ptr as u32 as usize, len as u32 as usize)
+            let Some((data, host)) = memory_and_host(&mut caller) else { return LOG_OUTSIDE_MEMORY };
+            host.run.log(level, data, offset(ptr), offset(len))
+        });
+    }
+    for (area, permission, get, set, remove) in [
+        (Area::Settings, Permission::Settings, "vc_settings_get", "vc_settings_set", "vc_settings_delete"),
+        (Area::Cache, Permission::Cache, "vc_cache_read", "vc_cache_write", "vc_cache_clear"),
+    ] {
+        if !granted.contains(&permission) {
+            continue;
+        }
+        let _ = linker.func_wrap(MODULE, get, move |mut caller: Caller<'_, Host>, key: i32, key_len: i32, out: i32, out_cap: i32| -> i32 {
+            let Some((data, host)) = memory_and_host(&mut caller) else { return STORAGE_OUTSIDE_MEMORY };
+            host.run.storage_read(area, data, (offset(key), offset(key_len)), (offset(out), offset(out_cap)))
+        });
+        let _ = linker.func_wrap(MODULE, set, move |mut caller: Caller<'_, Host>, key: i32, key_len: i32, value: i32, value_len: i32| -> i32 {
+            let Some((data, host)) = memory_and_host(&mut caller) else { return STORAGE_OUTSIDE_MEMORY };
+            host.run.storage_write(area, data, (offset(key), offset(key_len)), (offset(value), offset(value_len)))
+        });
+        let _ = linker.func_wrap(MODULE, remove, move |mut caller: Caller<'_, Host>, key: i32, key_len: i32| -> i32 {
+            let Some((data, host)) = memory_and_host(&mut caller) else { return STORAGE_OUTSIDE_MEMORY };
+            host.run.storage_remove(area, data, (offset(key), offset(key_len)))
         });
     }
     linker
 }
 
-/// Checks that every import of `module` is a host import with the host's signature → their names.
-/// Any other import is refused, and the error names it.
-pub(crate) fn check_imports(module: &Module) -> Result<Vec<&'static str>> {
-    let mut names = Vec::new();
+/// Checks that every import of `module` is a host import with the host's signature → them. Any
+/// other import is refused, and the error names it.
+pub(crate) fn check_imports(module: &Module) -> Result<Vec<&'static Import>> {
+    let mut found = Vec::new();
     for imp in module.imports() {
         let offered = if imp.module() == MODULE { IMPORTS.iter().find(|i| i.name == imp.name()) } else { None };
         let (from, name) = (permissions::display_text(imp.module(), 64), permissions::display_text(imp.name(), 64));
         let Some(host) = offered else {
             return Err(Error::Abi(format!(
-                "the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network"
+                "the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network"
             )));
         };
         match imp.ty() {
-            ExternType::Func(f) if f.params() == host.params && f.results() == host.results => names.push(host.name),
+            ExternType::Func(f) if f.params() == host.params && f.results() == host.results => found.push(host),
             _ => {
                 let signature = host.signature;
                 return Err(Error::Abi(format!("the module imports `env.{name}` with another type than the host's: it is {signature}")));
             }
         }
     }
-    Ok(names)
+    Ok(found)
 }
 
-/// Checks that `manifest` allows the host imports `imports`: `api` 2 and the `progress`
-/// permission. The error names the first import it doesn't allow.
-pub(crate) fn check_granted(manifest: &Manifest, imports: &[&str]) -> Result<()> {
-    match imports.first() {
-        Some(name) if manifest.api < PROGRESS_API || !manifest.permissions().contains(&Permission::Progress) => Err(Error::Abi(format!(
-            "the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`"
-        ))),
-        _ => Ok(()),
+/// Checks that `manifest` allows the host imports `imports`: `api` 2 and each import's permission.
+/// The error names the first import it doesn't allow.
+pub(crate) fn check_granted(manifest: &Manifest, imports: &[&Import]) -> Result<()> {
+    let granted = manifest.permissions();
+    match imports.iter().find(|i| manifest.api < PROGRESS_API || !granted.contains(&i.permission)) {
+        Some(import) => {
+            let (name, permission) = (import.name, import.permission.name());
+            Err(Error::Abi(format!(
+                "the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`"
+            )))
+        }
+        None => Ok(()),
     }
 }
 
diff --git a/crates/plugins/src/lib.rs b/crates/plugins/src/lib.rs
index fd2375be6..4ac06db48 100644
--- a/crates/plugins/src/lib.rs
+++ b/crates/plugins/src/lib.rs
@@ -3,14 +3,16 @@
 //! A plug-in is a WebAssembly module that implements the VectorCraft plug-in ABI (v1, documented
 //! in `docs/plugins.md`). It runs in [`wasmi`], a pure-Rust interpreter, with:
 //!
-//! - **no host imports but the three of API level 2** ([`host`]: progress, Cancel and log lines,
-//!   with the `progress` permission): no WASI, file system, network, clock or randomness. A module
-//!   that imports anything else is rejected;
+//! - **no host imports but those of API level 2** ([`host`]: progress, Cancel and log lines with
+//!   the `progress` permission, and settings and a cache of its own with the `settings` and `cache`
+//!   permissions, [`storage`]): no WASI, file system, network, clock or randomness. A module that
+//!   imports anything else is rejected;
 //! - an **instruction budget** (fuel) per call, metered in slices so a wall-clock deadline is
 //!   also enforced (native builds), so infinite loops end with an error. A filter may ask for a
 //!   larger one ([`Budget::Heavy`]), which the host lets the user allow before installing it;
 //! - a **linear-memory cap**, a **recursion-depth cap** and wasmi's strict module limits;
-//! - a **fresh instance per run**, so no state leaks between calls.
+//! - a **fresh instance per run**, so no state leaks between calls; what a plug-in keeps is only
+//!   what it writes to its settings and cache.
 //!
 //! Every failure (malformed module, trap, exhausted budget, bad output) is an [`Error`]; nothing
 //! a module does can panic or hang the host.
@@ -36,6 +38,7 @@ pub mod permissions;
 pub mod registry;
 mod runtime;
 pub mod safe_mode;
+pub mod storage;
 pub mod wat;
 
 pub use dialog::ParamUi;
diff --git a/crates/plugins/src/manifest.rs b/crates/plugins/src/manifest.rs
index 36b4b78c4..da66ae820 100644
--- a/crates/plugins/src/manifest.rs
+++ b/crates/plugins/src/manifest.rs
@@ -308,10 +308,11 @@ impl Manifest {
             return Err(Error::Manifest(format!("`api` is {}; this host implements plug-in API levels 1 to {API_LEVEL}", self.api)));
         }
         if let Some(names) = &self.permissions
-            && permissions::validate(self.kind, names)?.contains(&Permission::Progress)
+            && let Some(host) = permissions::validate(self.kind, names)?.into_iter().find(|p| permissions::HOST.contains(p))
             && self.api < PROGRESS_API
         {
-            return Err(Error::Manifest(format!("permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}")));
+            let permission = host.name();
+            return Err(Error::Manifest(format!("permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}")));
         }
         self.validate_extensions()?;
         match (self.budget, self.kind) {
@@ -658,6 +659,9 @@ mod tests {
         assert_eq!(serde_json::to_value(&level2).unwrap()["api"], json!(2));
         let plain2 = Manifest::parse(br#"{"id":"a","name":"x","kind":"filter","api":2}"#).unwrap();
         assert!(!plain2.permissions().contains(&Permission::Progress), "never implied");
+        let storing = Manifest::parse(br#"{"id":"a","name":"x","kind":"filter","api":2,"permissions":["cache","settings"]}"#).unwrap();
+        assert_eq!(storing.permissions(), [Permission::Settings, Permission::Cache]);
+        assert!(!plain2.permissions().iter().any(|p| permissions::HOST.contains(p)), "never implied");
         for (bad, says) in [
             (r#"{"id":"a","name":"x","kind":"filter","permissions":["doc.read","net.fetch"]}"#, "unknown permission `net.fetch`"),
             (r#"{"id":"a","name":"x","kind":"filter","permissions":["ui.panel"]}"#, "reserved"),
@@ -665,6 +669,8 @@ mod tests {
             (r#"{"id":"a","name":"x","kind":"filter","permissions":"doc.read"}"#, "manifest"),
             (r#"{"id":"a","name":"x","kind":"filter","permissions":["progress"]}"#, "`progress` needs plug-in API level 2"),
             (r#"{"id":"a","name":"x","kind":"filter","api":1,"permissions":["progress"]}"#, "`progress` needs plug-in API level 2"),
+            (r#"{"id":"a","name":"x","kind":"filter","permissions":["settings"]}"#, "`settings` needs plug-in API level 2"),
+            (r#"{"id":"a","name":"x","kind":"filter","api":1,"permissions":["doc.read","cache"]}"#, "`cache` needs plug-in API level 2"),
             (r#"{"id":"a","name":"x","kind":"filter","api":3}"#, "`api` is 3"),
             (r#"{"id":"a","name":"x","kind":"filter","api":0}"#, "`api` is 0"),
             (r#"{"id":"a","name":"x","kind":"filter","api":-1}"#, "manifest"),
diff --git a/crates/plugins/src/permissions.rs b/crates/plugins/src/permissions.rs
index 41ab1569a..4587c801d 100644
--- a/crates/plugins/src/permissions.rs
+++ b/crates/plugins/src/permissions.rs
@@ -5,8 +5,9 @@
 //! `doc.read`, `doc.write`, `state` and `progress` are the names of the plug-in capability model in
 //! storytold/photocraft#662; the other names are VectorCraft's own. A manifest without
 //! `permissions` gets the ones its kind implies ([`Permission::implied`]): what every plug-in of
-//! that kind could do before manifests listed them. `progress`, which lets a plug-in use the host
-//! imports of API level 2 ([`crate::host`]), is never implied: a manifest lists it.
+//! that kind could do before manifests listed them. `progress`, `settings` and `cache`, which let a
+//! plug-in use the host imports of API level 2 ([`crate::host`]), are never implied: a manifest
+//! lists them.
 
 use serde::{Deserialize, Serialize};
 
@@ -16,8 +17,8 @@ use crate::{Error, Kind, Result};
 /// this.
 pub const API_LEVEL: u32 = 2;
 
-/// The API level that adds the host imports ([`crate::host::IMPORTS`]) and the `progress`
-/// permission they need.
+/// The API level that adds the host imports ([`crate::host::IMPORTS`]) and the `progress`,
+/// `settings` and `cache` permissions they need.
 pub const PROGRESS_API: u32 = 2;
 
 /// Most permissions a manifest may list.
@@ -56,11 +57,29 @@ pub enum Permission {
     /// host imports of API level 2 ([`crate::host::IMPORTS`]).
     #[serde(rename = "progress")]
     Progress,
+    /// Keep settings of its own between runs and sessions ([`crate::storage`]).
+    #[serde(rename = "settings")]
+    Settings,
+    /// Keep a cache of its own, which the user can clear ([`crate::storage`]).
+    #[serde(rename = "cache")]
+    Cache,
 }
 
 /// Every permission this host grants, in the order prompts list them.
-pub const ALL: [Permission; 6] =
-    [Permission::DocRead, Permission::DocWrite, Permission::State, Permission::EffectRender, Permission::ExportWrite, Permission::Progress];
+pub const ALL: [Permission; 8] = [
+    Permission::DocRead,
+    Permission::DocWrite,
+    Permission::State,
+    Permission::EffectRender,
+    Permission::ExportWrite,
+    Permission::Progress,
+    Permission::Settings,
+    Permission::Cache,
+];
+
+/// The permissions of the host imports, which any kind may list and none implies; each needs plug-in
+/// API level [`PROGRESS_API`].
+pub const HOST: [Permission; 3] = [Permission::Progress, Permission::Settings, Permission::Cache];
 
 impl Permission {
     /// Its name in a manifest and in `plugin.install`'s `grant`.
@@ -72,6 +91,8 @@ impl Permission {
             Permission::EffectRender => "effect.render",
             Permission::ExportWrite => "export.write",
             Permission::Progress => "progress",
+            Permission::Settings => "settings",
+            Permission::Cache => "cache",
         }
     }
 
@@ -89,17 +110,19 @@ impl Permission {
             Permission::EffectRender => "Change how the objects its effect is applied to are drawn",
             Permission::ExportWrite => "Write the document as a file in its own format",
             Permission::Progress => "Show its progress, see Cancel and write log lines",
+            Permission::Settings => "Keep settings of its own",
+            Permission::Cache => "Keep a cache of its own, which you can clear",
         }
     }
 
-    /// May a plug-in of `kind` list it: one its kind implies, or `progress`, which any kind may
-    /// list.
+    /// May a plug-in of `kind` list it: one its kind implies, or one of the host imports' ([`HOST`]),
+    /// which any kind may list.
     pub fn applies(self, kind: Kind) -> bool {
-        self == Permission::Progress || Permission::implied(kind).contains(&self)
+        HOST.contains(&self) || Permission::implied(kind).contains(&self)
     }
 
     /// The permissions a manifest of `kind` without `permissions` gets. A manifest may also list
-    /// `progress` ([`Permission::applies`]).
+    /// the host imports' ([`HOST`], [`Permission::applies`]).
     pub fn implied(kind: Kind) -> &'static [Permission] {
         match kind {
             Kind::Filter => &[Permission::DocRead, Permission::DocWrite, Permission::State],
@@ -247,10 +270,22 @@ mod tests {
         assert!(validate(Kind::Effect, &list(&["doc.read", "effect.render", "progress"])).is_ok());
         assert!(validate(Kind::Exporter, &list(&["progress", "export.write", "doc.read"])).is_ok());
         assert!([Kind::Filter, Kind::Effect, Kind::Exporter].iter().all(|k| !Permission::implied(*k).contains(&Permission::Progress)));
+        // So may `settings` and `cache`, which no kind implies either.
+        assert_eq!(
+            validate(Kind::Effect, &list(&["cache", "settings", "doc.read", "effect.render"])).unwrap(),
+            [Permission::DocRead, Permission::EffectRender, Permission::Settings, Permission::Cache]
+        );
+        assert!(validate(Kind::Exporter, &list(&["settings", "export.write", "doc.read"])).is_ok());
+        assert_eq!(validate(Kind::Filter, &list(&["cache"])).unwrap(), [Permission::Cache]);
+        for kind in [Kind::Filter, Kind::Effect, Kind::Exporter] {
+            assert!(HOST.iter().all(|p| p.applies(kind) && !Permission::implied(kind).contains(p)));
+        }
         for (kind, names, says) in [
             (Kind::Filter, &["doc.read", "clipboard"][..], "unknown permission `clipboard`"),
             (Kind::Filter, &["ui.panel"], "`ui.panel` is reserved"),
             (Kind::Filter, &["progress", "progress"], "`progress` is listed twice"),
+            (Kind::Filter, &["cache", "cache"], "`cache` is listed twice"),
+            (Kind::Filter, &["storage"], "unknown permission `storage`"),
             (Kind::Filter, &["export.write"], "doesn't apply to a plug-in of kind `filter`"),
             (Kind::Exporter, &["doc.read", "export.write", "doc.read"], "`doc.read` is listed twice"),
             (Kind::Effect, &["doc.read"], "needs the permission `effect.render`"),
diff --git a/crates/plugins/src/registry.rs b/crates/plugins/src/registry.rs
index be1f0623f..824396508 100644
--- a/crates/plugins/src/registry.rs
+++ b/crates/plugins/src/registry.rs
@@ -10,12 +10,30 @@ use std::sync::{Arc, Mutex, RwLock};
 #[cfg(not(target_arch = "wasm32"))]
 use crate::Error;
 use crate::permissions::Grant;
+use crate::storage::Storage;
 use crate::{Limits, Plugin, Result};
 
 static PLUGINS: RwLock<BTreeMap<String, Arc<Plugin>>> = RwLock::new(BTreeMap::new());
 static REVISION: AtomicU64 = AtomicU64::new(0);
 /// What the user approved, by plug-in id.
 static GRANTS: RwLock<BTreeMap<String, Grant>> = RwLock::new(BTreeMap::new());
+/// Where each plug-in keeps its settings and cache, by plug-in id.
+static STORAGE: RwLock<BTreeMap<String, Arc<dyn Storage>>> = RwLock::new(BTreeMap::new());
+
+/// Keeps the settings and cache of plug-in `id` in `storage` from now on (`None`: nowhere, so its
+/// storage calls fail as unavailable). A run of the plug-in reaches only its own id's storage.
+pub fn set_storage(id: &str, storage: Option<Arc<dyn Storage>>) {
+    let mut all = STORAGE.write().unwrap_or_else(|e| e.into_inner());
+    match storage {
+        Some(s) => all.insert(id.to_string(), s),
+        None => all.remove(id),
+    };
+}
+
+/// Where plug-in `id` keeps its settings and cache, if anywhere.
+pub fn storage(id: &str) -> Option<Arc<dyn Storage>> {
+    STORAGE.read().unwrap_or_else(|e| e.into_inner()).get(id).cloned()
+}
 
 /// Records what the user approved for a plug-in, replacing an earlier grant for its id.
 pub fn grant(g: Grant) {
@@ -47,9 +65,12 @@ pub fn approved(plugin: &Plugin) -> bool {
 
 /// Installs `plugin`, replacing one with the same id.
 pub fn install(mut plugin: Plugin) -> Arc<Plugin> {
+    // The revision moves while the write lock is held, so a cache that reads the new revision and
+    // then the plug-ins finds the new plug-in among them.
+    let mut plugins = PLUGINS.write().unwrap_or_else(|e| e.into_inner());
     plugin.set_serial(REVISION.fetch_add(1, Ordering::Relaxed) + 1);
     let p = Arc::new(plugin);
-    PLUGINS.write().unwrap_or_else(|e| e.into_inner()).insert(p.id().to_string(), p.clone());
+    plugins.insert(p.id().to_string(), p.clone());
     p
 }
 
diff --git a/crates/plugins/src/runtime.rs b/crates/plugins/src/runtime.rs
index 7059aed15..d37a9159d 100644
--- a/crates/plugins/src/runtime.rs
+++ b/crates/plugins/src/runtime.rs
@@ -154,8 +154,9 @@ impl Plugin {
         let hash = crate::permissions::sha256_hex(bytes);
         let mut p = Plugin { manifest: Manifest::placeholder(), engine, module, limits, size: bytes.len(), hash, source: None, serial: 0 };
         let deadline = Deadline::new(p.limits.wall_time_ms);
-        // The manifest isn't read yet: every host import is linked, and what it reports is dropped.
-        let mut live = p.instantiate(Run::new("", false, false, deadline), true, &mut Report::default())?;
+        // The manifest isn't read yet: every host import is linked, what it reports is dropped and
+        // there is no storage to reach.
+        let mut live = p.instantiate(Run::new("", false, false, deadline), &crate::permissions::ALL, &mut Report::default())?;
         let version: TypedFunc<(), i32> = live.func("vc_abi_version")?;
         let v = p.call(&mut live, &version, (), p.limits.fuel_base, &deadline)?;
         if v != ABI_VERSION {
@@ -215,9 +216,9 @@ impl Plugin {
         self.serial = serial;
     }
 
-    /// A new instance for `run`, with the host imports linked when `granted`. When the module's
-    /// start function fails, what it reported through the host imports goes to `report`.
-    fn instantiate(&self, run: Run, granted: bool, report: &mut Report) -> Result<Live> {
+    /// A new instance for `run`, with the host imports of the permissions `granted` linked. When the
+    /// module's start function fails, what it reported through the host imports goes to `report`.
+    fn instantiate(&self, run: Run, granted: &[Permission], report: &mut Report) -> Result<Live> {
         let limits =
             StoreLimitsBuilder::new().memory_size(self.limits.max_memory_bytes).memories(1).tables(4).table_elements(100_000).instances(1).build();
         let mut store = Store::new(&self.engine, Host { limits, run });
@@ -287,7 +288,8 @@ impl Plugin {
     }
 
     /// [`Plugin::run_limited`], and what the run reported through the host imports: its last
-    /// progress report and its log lines, which also go to the app's log under its id. Inside a
+    /// progress report and its log lines, which also go to the app's log under its id. Its storage
+    /// imports reach the storage of its id ([`crate::registry::storage`]). Inside a
     /// [`vectorcraft_doc::cancel::scope`] its progress goes to the scope's sink (a live effect's
     /// doesn't) and `vc_cancelled` sees the scope's Cancel.
     pub fn run_reporting(&self, input: &[u8], params: &[u8], limits: &Limits) -> (Result<Vec<u8>>, Report) {
@@ -306,8 +308,8 @@ impl Plugin {
         total.ok_or_else(|| Error::Limit("memory budget (the selection is too large to hand over)".into()))?;
         let deadline = Deadline::new(limits.wall_time_ms);
         let m = &self.manifest;
-        let run = Run::new(&m.id, m.kind != Kind::Effect, true, deadline);
-        let mut live = self.instantiate(run, m.permissions().contains(&Permission::Progress), report)?;
+        let run = Run::new(&m.id, m.kind != Kind::Effect, true, deadline).with_storage(crate::registry::storage(&m.id));
+        let mut live = self.instantiate(run, &m.permissions(), report)?;
         let out = self.run_live(&mut live, input, params, limits, &deadline);
         *report = std::mem::take(&mut live.store.data_mut().run.report);
         out
diff --git a/crates/plugins/src/storage.rs b/crates/plugins/src/storage.rs
new file mode 100644
index 000000000..f3ef2e899
--- /dev/null
+++ b/crates/plugins/src/storage.rs
@@ -0,0 +1,151 @@
+//! What a plug-in keeps between runs, from plug-in API level 2 on: **settings**, a few named values
+//! (the `settings` permission), and a **cache** of named entries the user can clear (the `cache`
+//! permission). A plug-in reads and writes them through the host imports ([`crate::host::IMPORTS`]),
+//! naming each by a key ([`valid_name`]), never by a path; the host keeps them per plug-in id
+//! ([`Storage`], given with [`crate::registry::set_storage`]), so one plug-in can't reach another's.
+//!
+//! The caps are VectorCraft's own values: [`MAX_SETTINGS`] keys of at most [`MAX_SETTING_BYTES`]
+//! each in a settings file of at most [`MAX_SETTINGS_BYTES`], and cache entries of at most
+//! [`MAX_CACHE_ENTRY`] bytes, [`MAX_CACHE_BYTES`] and [`MAX_CACHE_ENTRIES`] in all. A write that
+//! would pass one fails with [`StorageError::Full`] and changes nothing.
+
+/// Longest key or cache entry name, in bytes.
+pub const MAX_NAME: usize = 64;
+
+/// Most settings a plug-in keeps.
+pub const MAX_SETTINGS: usize = 256;
+
+/// Largest value of one setting, in bytes.
+pub const MAX_SETTING_BYTES: usize = 64 << 10;
+
+/// Largest settings file, in bytes: the keys and the values in base64, as JSON.
+pub const MAX_SETTINGS_BYTES: usize = 1 << 20;
+
+/// Largest cache entry, in bytes.
+pub const MAX_CACHE_ENTRY: usize = 64 << 20;
+
+/// Most bytes a plug-in's cache holds, all entries together.
+pub const MAX_CACHE_BYTES: u64 = 512 << 20;
+
+/// Most entries a plug-in's cache holds.
+pub const MAX_CACHE_ENTRIES: usize = 4096;
+
+/// Why a storage call failed.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum StorageError {
+    /// The write would pass a cap; nothing was changed.
+    Full,
+    /// There is nowhere to keep anything: no plug-in store is attached, as in the web build.
+    Unavailable,
+    /// Reading or writing the file failed, with the system's reason.
+    Io(String),
+    /// The call would read or write more bytes than its [`Meter`] has left; nothing was changed.
+    Budget,
+}
+
+/// The bytes a storage call may still read and write, and those it has. The storage charges each
+/// file it reads or writes, at its size, before it does.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Meter {
+    left: u64,
+    used: u64,
+}
+
+impl Meter {
+    /// A meter that lets a call read and write `left` bytes.
+    pub fn new(left: u64) -> Self {
+        Meter { left, used: 0 }
+    }
+
+    /// A meter with no limit, for callers that don't count.
+    pub fn unlimited() -> Self {
+        Meter::new(u64::MAX)
+    }
+
+    /// Counts `bytes` about to be read or written → [`StorageError::Budget`], counting nothing,
+    /// when that is more than is left.
+    pub fn take(&mut self, bytes: u64) -> Result<(), StorageError> {
+        if bytes > self.left {
+            return Err(StorageError::Budget);
+        }
+        self.left -= bytes;
+        self.used = self.used.saturating_add(bytes);
+        Ok(())
+    }
+
+    /// The bytes counted so far.
+    pub fn used(&self) -> u64 {
+        self.used
+    }
+}
+
+impl std::fmt::Display for StorageError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StorageError::Full => write!(f, "the plug-in's storage is full"),
+            StorageError::Unavailable => write!(f, "no plug-in storage is available"),
+            StorageError::Io(why) => write!(f, "{why}"),
+            StorageError::Budget => write!(f, "the run has used up its storage bytes"),
+        }
+    }
+}
+
+/// Where one plug-in's settings and cache are kept. Every key and name the host passes is a
+/// [`valid_name`], and every value is within its cap ([`MAX_SETTING_BYTES`], [`MAX_CACHE_ENTRY`]);
+/// the storage enforces the totals. The calls that read or write a file charge `meter` the bytes
+/// they read and write ([`Meter::take`]) before they do: a settings call the whole settings file it
+/// reads and the whole file it writes, a cache call the entry it reads or writes.
+pub trait Storage: Send + Sync {
+    /// The value of setting `key`, if it has one.
+    fn setting(&self, key: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError>;
+    /// Sets `key` to `value`.
+    fn set_setting(&self, key: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError>;
+    /// Removes setting `key` → whether it had a value.
+    fn delete_setting(&self, key: &str, meter: &mut Meter) -> Result<bool, StorageError>;
+    /// The cache entry `name`, if there is one.
+    fn cache_entry(&self, name: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError>;
+    /// Writes the cache entry `name`.
+    fn set_cache_entry(&self, name: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError>;
+    /// Removes the cache entry `name` → whether there was one.
+    fn remove_cache_entry(&self, name: &str) -> Result<bool, StorageError>;
+    /// Removes every cache entry → the bytes they held.
+    fn clear_cache(&self) -> Result<u64, StorageError>;
+    /// The bytes the cache holds now.
+    fn cache_bytes(&self) -> u64;
+}
+
+/// Is `name` a key or cache entry name a plug-in may use: 1 to [`MAX_NAME`] characters from
+/// `A-Z a-z 0-9 _ -`, and not a name Windows keeps for a device (`CON`, `PRN`, `AUX`, `NUL`,
+/// `COM0` to `COM9`, `LPT0` to `LPT9`, in any case)? Keys differ in case: `a` and `A` are two.
+pub fn valid_name(name: &str) -> bool {
+    (1..=MAX_NAME).contains(&name.len()) && name.bytes().all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-')) && !device_name(name)
+}
+
+/// Is `name` one of the device names Windows keeps?
+fn device_name(name: &str) -> bool {
+    let upper = name.to_ascii_uppercase();
+    match upper.as_bytes() {
+        [a, b, c] => matches!(&[*a, *b, *c], b"CON" | b"PRN" | b"AUX" | b"NUL"),
+        [a, b, c, d] => matches!(&[*a, *b, *c], b"COM" | b"LPT") && d.is_ascii_digit(),
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn names_are_short_plain_and_never_a_device() {
+        for ok in ["a", "Z", "zoom-level", "tile_12", &"x".repeat(MAX_NAME), "CONSOLE", "COM10", "LPTX", "con1"] {
+            assert!(valid_name(ok), "{ok}");
+        }
+        for bad in ["", "..", ".", "a/b", "a\\b", "a.b", "a b", "a\u{0}", "\u{7}", "é", &"x".repeat(MAX_NAME + 1), "CON", "con", "Nul", "aux", "prn"]
+        {
+            assert!(!valid_name(bad), "{bad:?}");
+        }
+        for n in 0..10 {
+            assert!(!valid_name(&format!("COM{n}")) && !valid_name(&format!("lpt{n}")));
+        }
+    }
+}
diff --git a/crates/plugins/src/wat.rs b/crates/plugins/src/wat.rs
index af041414a..f6bd289a6 100644
--- a/crates/plugins/src/wat.rs
+++ b/crates/plugins/src/wat.rs
@@ -59,6 +59,16 @@ pub const HOST_IMPORTS: &str = r#"(import "env" "vc_progress" (func $vc_progress
   (import "env" "vc_cancelled" (func $vc_cancelled (result i32)))
   (import "env" "vc_log" (func $vc_log (param i32 i32 i32) (result i32)))"#;
 
+/// The storage imports of plug-in API level 2 ([`crate::host::IMPORTS`]), as `$vc_settings_get`,
+/// `$vc_settings_set`, `$vc_settings_delete`, `$vc_cache_read`, `$vc_cache_write` and
+/// `$vc_cache_clear`; a manifest that uses them lists `settings` and `cache`.
+pub const STORAGE_IMPORTS: &str = r#"(import "env" "vc_settings_get" (func $vc_settings_get (param i32 i32 i32 i32) (result i32)))
+  (import "env" "vc_settings_set" (func $vc_settings_set (param i32 i32 i32 i32) (result i32)))
+  (import "env" "vc_settings_delete" (func $vc_settings_delete (param i32 i32) (result i32)))
+  (import "env" "vc_cache_read" (func $vc_cache_read (param i32 i32 i32 i32) (result i32)))
+  (import "env" "vc_cache_write" (func $vc_cache_write (param i32 i32 i32 i32) (result i32)))
+  (import "env" "vc_cache_clear" (func $vc_cache_clear (param i32 i32) (result i32)))"#;
+
 /// A plug-in of API level 2 (its manifest gives `api` 2 and lists `progress`) that imports the
 /// host functions ([`HOST_IMPORTS`]) and whose `vc_run` runs `first`, which may call them, then
 /// returns `output`.
diff --git a/crates/plugins/tests/abi.rs b/crates/plugins/tests/abi.rs
index f5b78d224..bb32906ea 100644
--- a/crates/plugins/tests/abi.rs
+++ b/crates/plugins/tests/abi.rs
@@ -6,6 +6,7 @@
 use std::time::{Duration, Instant};
 
 use serde_json::{Value, json};
+use vectorcraft_plugins::storage::{Meter, Storage, StorageError};
 use vectorcraft_plugins::{Error, HEAVY_FUEL, HEAVY_WALL_TIME_MS, Kind, Limits, Plugin, Report, heavy_terms, registry, wat as tpl};
 
 /// The example Desaturate plug-in, built from `crates/plugins/example`.
@@ -356,8 +357,8 @@ fn load_err(bytes: &[u8]) -> String {
     Plugin::load(bytes, Limits::default()).expect_err("the module must be refused").to_string()
 }
 
-/// A module may import only the host's three functions, with the host's types, and only when its
-/// manifest gives `api` 2 and lists `progress`; the error names the import it refuses.
+/// A module may import only the host's functions, with the host's types, and the progress ones only
+/// when its manifest gives `api` 2 and lists `progress`; the error names the import it refuses.
 #[test]
 fn host_imports_are_checked_when_a_module_is_loaded() {
     let with = |manifest: &str, import: &str| build(&tpl::with_imports(manifest, import, "", INPUT));
@@ -502,6 +503,206 @@ fn what_a_start_function_reports_before_it_fails_is_kept() {
     assert_eq!(report.progress, Some((1, 4)));
 }
 
+/// Settings and a cache kept in memory, for the storage imports. Each call charges its meter the
+/// bytes of the value it reads or writes.
+#[derive(Default)]
+struct Kept {
+    settings: std::sync::Mutex<std::collections::BTreeMap<String, Vec<u8>>>,
+    cache: std::sync::Mutex<std::collections::BTreeMap<String, Vec<u8>>>,
+}
+
+/// The value `key` has in `kept`, once `meter` is charged its bytes.
+fn charged(
+    kept: &std::sync::Mutex<std::collections::BTreeMap<String, Vec<u8>>>,
+    key: &str,
+    meter: &mut Meter,
+) -> Result<Option<Vec<u8>>, StorageError> {
+    let value = kept.lock().unwrap().get(key).cloned();
+    meter.take(value.as_ref().map_or(0, |v| v.len() as u64))?;
+    Ok(value)
+}
+
+impl Storage for Kept {
+    fn setting(&self, key: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError> {
+        charged(&self.settings, key, meter)
+    }
+    fn set_setting(&self, key: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError> {
+        meter.take(value.len() as u64)?;
+        self.settings.lock().unwrap().insert(key.into(), value.to_vec());
+        Ok(())
+    }
+    fn delete_setting(&self, key: &str, _: &mut Meter) -> Result<bool, StorageError> {
+        Ok(self.settings.lock().unwrap().remove(key).is_some())
+    }
+    fn cache_entry(&self, name: &str, meter: &mut Meter) -> Result<Option<Vec<u8>>, StorageError> {
+        charged(&self.cache, name, meter)
+    }
+    fn set_cache_entry(&self, name: &str, value: &[u8], meter: &mut Meter) -> Result<(), StorageError> {
+        meter.take(value.len() as u64)?;
+        self.cache.lock().unwrap().insert(name.into(), value.to_vec());
+        Ok(())
+    }
+    fn remove_cache_entry(&self, name: &str) -> Result<bool, StorageError> {
+        Ok(self.cache.lock().unwrap().remove(name).is_some())
+    }
+    fn clear_cache(&self) -> Result<u64, StorageError> {
+        let mut cache = self.cache.lock().unwrap();
+        let freed = cache.values().map(|v| v.len() as u64).sum();
+        cache.clear();
+        Ok(freed)
+    }
+    fn cache_bytes(&self) -> u64 {
+        self.cache.lock().unwrap().values().map(|v| v.len() as u64).sum()
+    }
+}
+
+/// A filter `id` of API level 2 that lists `settings` and `cache`.
+fn storing(id: &str) -> String {
+    format!(r#"{{"id":"{id}","name":"Storing","version":"1","kind":"filter","api":2,"permissions":["settings","cache"]}}"#)
+}
+
+/// Instructions that trap unless `call` returns `want`.
+fn expect(call: &str, want: i32) -> String {
+    format!("(if (i32.ne {call} (i32.const {want})) (then unreachable))")
+}
+
+/// The module fields of a storage test: the storage imports, keys at 0x2000 ("zoom", "..", "a/b",
+/// "CON", a tab, 65 "x"), the value "hello" at 0x2100; 0x3000 is free for an output buffer.
+fn storage_data() -> String {
+    format!(r#"{} (data (i32.const 0x2000) "zoom..a/bCON\09{}") (data (i32.const 0x2100) "hello")"#, tpl::STORAGE_IMPORTS, "x".repeat(65))
+}
+
+/// Each storage import needs its own permission: a module that imports one its manifest doesn't
+/// list is refused, and the error names the import and the permission.
+#[test]
+fn storage_imports_need_their_own_permission() {
+    let with = |manifest: &str, import: &str| build(&tpl::with_imports(manifest, import, "", INPUT));
+    let get = r#"(import "env" "vc_settings_get" (func (param i32 i32 i32 i32) (result i32)))"#;
+    let clear = r#"(import "env" "vc_cache_clear" (func (param i32 i32) (result i32)))"#;
+    let e = load_err(&with(LEVEL2, get));
+    assert!(
+        e.contains("imports `env.vc_settings_get`, which a plug-in may use only at plug-in API level 2 (`api` 2) and with the permission `settings`"),
+        "{e}"
+    );
+    let settings_only = r#"{"id":"test.settings","name":"S","kind":"filter","api":2,"permissions":["settings"]}"#;
+    assert!(Plugin::load(&with(settings_only, get), Limits::default()).is_ok());
+    let e = load_err(&with(settings_only, clear));
+    assert!(
+        e.contains("imports `env.vc_cache_clear`, which a plug-in may use only at plug-in API level 2 (`api` 2) and with the permission `cache`"),
+        "{e}"
+    );
+    let wrong = load_err(&with(&storing("test.wrong"), r#"(import "env" "vc_cache_clear" (func (param i32) (result i32)))"#));
+    assert!(wrong.contains("imports `env.vc_cache_clear` with another type than the host's: it is (param i32 i32) (result i32)"), "{wrong}");
+    assert!(Plugin::load(&build(&tpl::with_imports(&storing("test.all"), tpl::STORAGE_IMPORTS, "", INPUT)), Limits::default()).is_ok());
+}
+
+/// A plug-in sets, reads and removes its settings and cache entries through the storage imports,
+/// by key; a value too large for its buffer returns its length and copies nothing; a key or buffer
+/// outside its memory, a key that isn't a plain name and a value over its cap are errors it sees.
+#[test]
+fn storage_imports_read_and_write_the_plugins_own_storage() {
+    use vectorcraft_plugins::host::{STORAGE_BAD_NAME, STORAGE_DONE, STORAGE_FULL, STORAGE_NOT_FOUND, STORAGE_OUTSIDE_MEMORY};
+    let id = "test.storage.own";
+    let kept = std::sync::Arc::new(Kept::default());
+    registry::set_storage(id, Some(kept.clone()));
+    let zoom = "(i32.const 0x2000) (i32.const 4)";
+    let first = [
+        expect(&format!("(call $vc_settings_get {zoom} (i32.const 0x3000) (i32.const 16))"), STORAGE_NOT_FOUND),
+        expect(&format!("(call $vc_settings_set {zoom} (i32.const 0x2100) (i32.const 5))"), STORAGE_DONE),
+        // Too small a buffer: the length, and nothing copied.
+        expect(&format!("(call $vc_settings_get {zoom} (i32.const 0x3000) (i32.const 4))"), 5),
+        expect("(i32.load8_u (i32.const 0x3000))", 0),
+        expect(&format!("(call $vc_settings_get {zoom} (i32.const 0x3000) (i32.const 16))"), 5),
+        expect("(i32.load (i32.const 0x3000))", i32::from_le_bytes(*b"hell")),
+        expect(&format!("(call $vc_cache_write {zoom} (i32.const 0x2100) (i32.const 0))"), STORAGE_DONE),
+        expect(&format!("(call $vc_cache_read {zoom} (i32.const 0x3000) (i32.const 0))"), 0),
+        expect(&format!("(call $vc_cache_write {zoom} (i32.const 0x2100) (i32.const 3))"), STORAGE_DONE),
+        // Hostile keys: `..`, `a/b`, `CON`, a tab, 65 bytes, no bytes.
+        expect("(call $vc_settings_set (i32.const 0x2004) (i32.const 2) (i32.const 0x2100) (i32.const 5))", STORAGE_BAD_NAME),
+        expect("(call $vc_settings_set (i32.const 0x2006) (i32.const 3) (i32.const 0x2100) (i32.const 5))", STORAGE_BAD_NAME),
+        expect("(call $vc_cache_write (i32.const 0x2009) (i32.const 3) (i32.const 0x2100) (i32.const 5))", STORAGE_BAD_NAME),
+        expect("(call $vc_cache_read (i32.const 0x200c) (i32.const 1) (i32.const 0x3000) (i32.const 16))", STORAGE_BAD_NAME),
+        expect("(call $vc_settings_get (i32.const 0x200d) (i32.const 65) (i32.const 0x3000) (i32.const 16))", STORAGE_BAD_NAME),
+        expect("(call $vc_settings_delete (i32.const 0x2000) (i32.const 0))", STORAGE_BAD_NAME),
+        // Outside memory: the key, the value, the buffer.
+        expect("(call $vc_settings_get (i32.const -1) (i32.const 4) (i32.const 0x3000) (i32.const 16))", STORAGE_OUTSIDE_MEMORY),
+        expect(&format!("(call $vc_settings_set {zoom} (i32.const 0x2100) (i32.const -1))"), STORAGE_OUTSIDE_MEMORY),
+        expect(&format!("(call $vc_cache_read {zoom} (i32.mul (memory.size) (i32.const 65536)) (i32.const 1))"), STORAGE_OUTSIDE_MEMORY),
+        // A setting over its cap changes nothing.
+        expect(
+            &format!("(call $vc_settings_set {zoom} (i32.const 0) (i32.const {}))", vectorcraft_plugins::storage::MAX_SETTING_BYTES + 1),
+            STORAGE_FULL,
+        ),
+        expect(&format!("(call $vc_settings_get {zoom} (i32.const 0x3000) (i32.const 16))"), 5),
+    ]
+    .concat();
+    let p = Plugin::load(&build(&tpl::with_imports(&storing(id), &storage_data(), &first, INPUT)), Limits::default()).unwrap();
+    assert_eq!(p.run(INPUT.as_bytes(), b"{}").unwrap(), INPUT.as_bytes(), "every call returned what it should");
+    assert_eq!(kept.settings.lock().unwrap().get("zoom"), Some(&b"hello".to_vec()));
+    assert_eq!(kept.cache.lock().unwrap().get("zoom"), Some(&b"hel".to_vec()));
+    // Removing: one setting, then a missing one, then the whole cache, then a missing entry.
+    let removing = [
+        expect("(call $vc_settings_delete (i32.const 0x2000) (i32.const 4))", STORAGE_DONE),
+        expect("(call $vc_settings_delete (i32.const 0x2000) (i32.const 4))", STORAGE_NOT_FOUND),
+        expect("(call $vc_cache_clear (i32.const 0) (i32.const 0))", STORAGE_DONE),
+        expect("(call $vc_cache_clear (i32.const 0x2000) (i32.const 4))", STORAGE_NOT_FOUND),
+    ]
+    .concat();
+    let p = Plugin::load(&build(&tpl::with_imports(&storing(id), &storage_data(), &removing, INPUT)), Limits::default()).unwrap();
+    assert_eq!(p.run(INPUT.as_bytes(), b"{}").unwrap(), INPUT.as_bytes(), "every call returned what it should");
+    assert!(kept.settings.lock().unwrap().is_empty() && kept.cache.lock().unwrap().is_empty());
+    registry::set_storage(id, None);
+}
+
+/// A read counts the value's bytes toward the run's storage bytes even when its buffer is too small
+/// and nothing is copied, so reading a large entry into no buffer again and again ends in
+/// `STORAGE_BUDGET`.
+#[test]
+fn a_read_into_too_small_a_buffer_still_counts_its_bytes() {
+    use vectorcraft_plugins::host::{MAX_STORAGE_BYTES, STORAGE_BUDGET};
+    use vectorcraft_plugins::storage::MAX_CACHE_ENTRY;
+    let id = "test.storage.budget";
+    let kept = std::sync::Arc::new(Kept::default());
+    kept.cache.lock().unwrap().insert("zoom".into(), vec![0; MAX_CACHE_ENTRY]);
+    registry::set_storage(id, Some(kept.clone()));
+    let read = "(call $vc_cache_read (i32.const 0x2000) (i32.const 4) (i32.const 0x3000) (i32.const 0))";
+    let fits = MAX_STORAGE_BYTES / MAX_CACHE_ENTRY;
+    let reading = [vec![expect(read, MAX_CACHE_ENTRY as i32); fits], vec![expect(read, STORAGE_BUDGET)]].concat().concat();
+    let p = Plugin::load(&build(&tpl::with_imports(&storing(id), &storage_data(), &reading, INPUT)), Limits::default()).unwrap();
+    assert_eq!(p.run(INPUT.as_bytes(), b"{}").unwrap(), INPUT.as_bytes(), "every call returned what it should");
+    registry::set_storage(id, None);
+}
+
+/// A plug-in reaches only the storage of its own id, and a plug-in with none (not installed with a
+/// plug-in store, as on the web) gets `STORAGE_UNAVAILABLE`.
+#[test]
+fn a_plugin_reaches_only_its_own_storage() {
+    use vectorcraft_plugins::host::{STORAGE_DONE, STORAGE_NOT_FOUND, STORAGE_UNAVAILABLE};
+    let (mine, theirs) = (std::sync::Arc::new(Kept::default()), std::sync::Arc::new(Kept::default()));
+    registry::set_storage("test.storage.mine", Some(mine.clone()));
+    registry::set_storage("test.storage.theirs", Some(theirs.clone()));
+    theirs.settings.lock().unwrap().insert("zoom".into(), b"theirs".to_vec());
+    theirs.cache.lock().unwrap().insert("zoom".into(), b"theirs".to_vec());
+    let zoom = "(i32.const 0x2000) (i32.const 4)";
+    let looking = [
+        expect(&format!("(call $vc_settings_get {zoom} (i32.const 0x3000) (i32.const 16))"), STORAGE_NOT_FOUND),
+        expect(&format!("(call $vc_cache_read {zoom} (i32.const 0x3000) (i32.const 16))"), STORAGE_NOT_FOUND),
+        expect("(call $vc_cache_clear (i32.const 0) (i32.const 0))", STORAGE_DONE),
+        expect(&format!("(call $vc_settings_set {zoom} (i32.const 0x2100) (i32.const 5))"), STORAGE_DONE),
+    ]
+    .concat();
+    let p = Plugin::load(&build(&tpl::with_imports(&storing("test.storage.mine"), &storage_data(), &looking, INPUT)), Limits::default()).unwrap();
+    assert_eq!(p.run(INPUT.as_bytes(), b"{}").unwrap(), INPUT.as_bytes());
+    assert_eq!(theirs.settings.lock().unwrap().get("zoom"), Some(&b"theirs".to_vec()));
+    assert_eq!(theirs.cache_bytes(), 6);
+    assert_eq!(mine.settings.lock().unwrap().get("zoom"), Some(&b"hello".to_vec()));
+    let nowhere = expect(&format!("(call $vc_settings_set {zoom} (i32.const 0x2100) (i32.const 5))"), STORAGE_UNAVAILABLE);
+    let p = Plugin::load(&build(&tpl::with_imports(&storing("test.storage.nowhere"), &storage_data(), &nowhere, INPUT)), Limits::default()).unwrap();
+    assert_eq!(p.run(INPUT.as_bytes(), b"{}").unwrap(), INPUT.as_bytes());
+    registry::set_storage("test.storage.mine", None);
+    registry::set_storage("test.storage.theirs", None);
+}
+
 /// A heavy filter installs once the user agrees, which loading a folder doesn't ask: it is skipped
 /// and reported.
 #[test]
diff --git a/crates/render/src/ink.rs b/crates/render/src/ink.rs
index dee93e903..10bfe03ce 100644
--- a/crates/render/src/ink.rs
+++ b/crates/render/src/ink.rs
@@ -563,17 +563,25 @@ mod tests {
     fn the_ink_table_matches_the_profile() {
         let cms = cms::active();
         let lut = InkLut::build(&cms);
-        let mut worst = 0.0f32;
+        let (mut worst, mut worst_dark) = (0.0f32, 0.0f32);
         // Between the grid points (where interpolation errs most) and on them.
         for i in 0..=20 {
             for j in 0..=20 {
                 let inks = [i as f32 / 20.0, j as f32 / 20.0, ((i * 7 + j * 3) % 21) as f32 / 20.0, ((i + j * 5) % 21) as f32 / 20.0];
                 let (a, b) = (lut.apply(inks), cms.cmyk_to_srgb(inks, false));
-                worst = worst.max((0..3).map(|c| (a[c] - b[c]).abs()).fold(0.0, f32::max));
+                let err = (0..3).map(|c| (a[c] - b[c]).abs()).fold(0.0, f32::max);
+                // Builds darker than the press's black point clip at 0 in one or more XYZ channels,
+                // so the grid interpolates across that clip in the darkest levels.
+                if b.iter().all(|v| *v < 0.05) {
+                    worst_dark = worst_dark.max(err);
+                } else {
+                    worst = worst.max(err);
+                }
             }
         }
         // Within two 8-bit levels: far below a visible difference.
         assert!(worst * 255.0 < 2.5, "worst error {} levels", worst * 255.0);
+        assert!(worst_dark * 255.0 < 5.0, "worst error near black {} levels", worst_dark * 255.0);
     }
 
     #[test]
diff --git a/crates/render/src/tests/fontchange.rs b/crates/render/src/tests/fontchange.rs
index 2ca5b5978..5b0f60091 100644
--- a/crates/render/src/tests/fontchange.rs
+++ b/crates/render/src/tests/fontchange.rs
@@ -119,6 +119,25 @@ fn variable_font_settings_are_not_highlighted_as_substituted_glyphs() {
     assert!(g.alternate_glyphs(&t).elements().is_empty());
 }
 
+/// Type in a composite font draws each class of character in its part's face, which is not a
+/// substitute: Document Setup's highlight of substituted glyphs leaves it alone.
+#[test]
+fn composite_font_parts_are_not_highlighted_as_substituted_glyphs() {
+    use vectorcraft_doc::{CompositeFont, CompositePart, CompositeParts};
+    let _adding = adding_fonts();
+    let db = vectorcraft_text::FontDb::global();
+    let mut parts = CompositeParts::all(CompositePart::new("Source Sans 3", "Regular"));
+    parts.roman = CompositePart::new("JetBrains Mono", "Regular");
+    parts.numerals = CompositePart::new("Inter", "Regular");
+    db.set_composite_font(&CompositeFont { name: "CF Highlight".into(), parts });
+    let style = CharStyle { size: 40.0, font_family: "CF Highlight".into(), ..Default::default() };
+    let t = TextObject::point(Point::new(10.0, 60.0), "Ab12", style);
+    let g = text_geom(&t);
+    db.remove_composite_font("CF Highlight");
+    assert!(!g.all.elements().is_empty());
+    assert!(g.substituted_glyphs.elements().is_empty() && g.substituted_fonts.elements().is_empty());
+}
+
 /// Type at 80% opacity, in Multiply and with a drop shadow redraws in a font that becomes
 /// available: the glyph geometry kept for it is laid out again.
 #[test]
diff --git a/crates/render/src/text_geom.rs b/crates/render/src/text_geom.rs
index 5e3c9496a..05228eb20 100644
--- a/crates/render/src/text_geom.rs
+++ b/crates/render/src/text_geom.rs
@@ -191,7 +191,14 @@ pub(crate) fn text_geom_snapped(t: &TextObject, snap: Option<Affine>) -> TextGeo
         if let Some(art) = g.placed_colour(Affine::IDENTITY) {
             colours.push((g.run, Arc::new(art)));
         }
-        let Some(&(missing, face)) = faces.get(g.run) else { continue };
+        let Some(&(mut missing, mut face)) = faces.get(g.run) else { continue };
+        // Type in a composite font: each character's face is its class's part's.
+        if let Some(r) = t.runs.get(g.run)
+            && let Some(c) = plain.get(g.byte..).and_then(|s| s.chars().next())
+            && let Some((m, f)) = db.composite_face(&r.style.font_family, c)
+        {
+            (missing, face) = (m, Some(f));
+        }
         let Some(line) = layout.lines.get(g.line) else { continue };
         let mut cell = Rect::new(g.origin.x, g.origin.y - line.ascent, g.origin.x + g.advance, g.origin.y + line.descent).to_path(0.1);
         cell.apply_affine(Affine::rotate_about(g.angle, g.origin));
diff --git a/crates/svg/src/export/text.rs b/crates/svg/src/export/text.rs
index dd956692d..c9d9027b8 100644
--- a/crates/svg/src/export/text.rs
+++ b/crates/svg/src/export/text.rs
@@ -84,11 +84,14 @@ impl Writer<'_> {
         let inline = t.runs.iter().any(|r| r.inline.is_some());
         // Ruby is written as outlines with its base text: a reader's <text> can't place it. So are
         // small capitals, superscript and subscript and tab leaders, which SVG text doesn't draw (#3869),
-        // and a glyph chosen for a character, which a reader's <text> draws with the default glyph.
-        let unwritable =
-            t.runs.iter().any(|r| {
-                r.style.small_caps.is_some() || r.style.position != vectorcraft_doc::CharPosition::Normal || r.style.glyph_alternate.is_some()
-            }) || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));
+        // and a glyph chosen for a character, which a reader's <text> draws with the default glyph. So
+        // is type in one of the document's composite fonts, which a reader can't find by its name.
+        let unwritable = t.runs.iter().any(|r| {
+            r.style.small_caps.is_some()
+                || r.style.position != vectorcraft_doc::CharPosition::Normal
+                || r.style.glyph_alternate.is_some()
+                || vectorcraft_doc::CompositeFont::named(&doc.composite_fonts, &r.style.font_family).is_some()
+        }) || std::iter::once(&t.para).chain(&t.paras).any(|p| p.tabs.iter().any(|tab| !tab.leader.is_empty()));
         let outlined =
             self.opts.outline_text || t.vertical || !t.ruby.is_empty() || (inline && matches!(t.kind, TextKind::OnPath { .. })) || unwritable;
         let chars = |w: &mut Self, n: &Node| if outlined { w.text_outlines(n, t) } else { w.text(n, t) };
diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs
index 1dbc7035b..a3ad7a069 100644
--- a/crates/svg/src/lib.rs
+++ b/crates/svg/src/lib.rs
@@ -367,6 +367,8 @@ pub fn export_with_report(doc: &Document, opts: &ExportOptions) -> (String, Vec<
 /// Export a document as SVG plus the image files it links to. `native`: the document in the
 /// native format, embedded when [`ExportOptions::preserve_editing`] is on.
 pub fn export_full(doc: &Document, opts: &ExportOptions, native: Option<&[u8]>) -> Output {
+    // Type in the document's composite fonts is drawn in them, whether or not an app has the document open.
+    let _lent = vectorcraft_text::FontDb::global().lend_composite_fonts(&doc.composite_fonts);
     export::export(doc, opts, native)
 }
 
diff --git a/crates/text/src/fontdb.rs b/crates/text/src/fontdb.rs
index d42e8f351..a95ac2dc5 100644
--- a/crates/text/src/fontdb.rs
+++ b/crates/text/src/fontdb.rs
@@ -20,6 +20,7 @@ use vectorcraft_doc::color::Color;
 mod alternates;
 mod build;
 mod cache;
+mod composite;
 mod db;
 mod dirs;
 mod face;
@@ -36,6 +37,7 @@ pub use build::style_weight;
 #[cfg(test)]
 use cache::GlyphCache;
 use cache::{CanonicalNames, Catalog, GlyphColours, GlyphImages, PostScriptNames};
+pub use composite::{CompositeCoverage, LentCompositeFonts};
 #[cfg(all(not(target_arch = "wasm32"), test))]
 pub(crate) use dirs::fonts_outside;
 #[cfg(test)]
@@ -47,6 +49,7 @@ pub use dirs::{
 use face::Instances;
 #[cfg(test)]
 pub(crate) use face::MAX_LIVE_INSTANCES;
+pub(crate) use face::PathAlignHeights;
 pub use face::{FALLBACK_FAMILY, FontFace, IcfMargins};
 pub(crate) use glyph_pen::FlipPen;
 #[cfg(not(target_arch = "wasm32"))]
@@ -107,6 +110,11 @@ pub struct FontDb {
     stamp: Mutex<Option<ScanStamp>>,
     /// Faces instanced at the axis settings of type's Variable Font sliders ([`FontDb::instance`]).
     instances: Mutex<Instances>,
+    /// Composite fonts (Type › Composite Fonts…) by lowercased name ([`FontDb::set_composite_font`]):
+    /// type naming one as its family is set in its parts' fonts.
+    composites: RwLock<HashMap<String, Arc<vectorcraft_doc::CompositeFont>>>,
+    /// The composite fonts [`FontDb::lend_composite_fonts`] put in, by lowercased name.
+    composite_loans: Mutex<HashMap<String, composite::CompositeLoan>>,
 }
 
 /// Where a database's system font scan looks: folders (read with their subfolders) and font files.
diff --git a/crates/text/src/fontdb/build.rs b/crates/text/src/fontdb/build.rs
index 40bcb1df1..4946bbd84 100644
--- a/crates/text/src/fontdb/build.rs
+++ b/crates/text/src/fontdb/build.rs
@@ -75,6 +75,7 @@ pub(super) fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Opt
         plans: std::sync::Mutex::new(Vec::new()),
         ideographic_centre: std::sync::OnceLock::new(),
         icf_margins: std::sync::OnceLock::new(),
+        path_align: std::sync::OnceLock::new(),
         colour_bitmaps,
         colour_layers,
         svg_glyphs,
diff --git a/crates/text/src/fontdb/composite.rs b/crates/text/src/fontdb/composite.rs
new file mode 100644
index 000000000..faee695ca
--- /dev/null
+++ b/crates/text/src/fontdb/composite.rs
@@ -0,0 +1,345 @@
+//! Composite fonts (Type › Composite Fonts…) in the font database: each is listed first in the
+//! font menus and resolves to its base (Kanji) font, and layout sets each character of type in one
+//! in the font of the character's class ([`FontDb::composite_split`]).
+
+use unicode_segmentation::UnicodeSegmentation;
+use vectorcraft_doc::{CharClass, CompositeFont, TextObject, TextRun};
+
+use super::face::FALLBACK_FAMILY;
+use super::{Arc, FontDb, FontFace, FontMatch};
+
+/// A face [`FontDb::resolve`] found and how it matched.
+type Resolved = Option<(Arc<FontFace>, FontMatch)>;
+
+/// How a composite font draws some text ([`FontDb::composite_coverage`]).
+#[derive(Clone, Debug)]
+pub struct CompositeCoverage {
+    /// The worst match among the parts that draw it.
+    pub status: FontMatch,
+    /// The face of the first part with that match.
+    pub face: Option<Arc<FontFace>>,
+    /// The characters whose part's face lacks them.
+    pub lacking: Vec<char>,
+}
+
+impl FontDb {
+    /// Make `font` available by its name, in place of a composite font of that name (any case).
+    /// The font menus and anything else that lists fonts change only when the definition does.
+    /// Whether it did.
+    pub fn set_composite_font(&self, font: &CompositeFont) -> bool {
+        let key = font.name.to_lowercase();
+        {
+            let mut map = self.composites.write().unwrap_or_else(|e| e.into_inner());
+            if map.get(&key).is_some_and(|f| **f == *font) {
+                return false;
+            }
+            map.insert(key, Arc::new(font.clone()));
+        }
+        self.changed();
+        true
+    }
+
+    /// Forget the composite font named `name` (any case). Whether there was one.
+    pub fn remove_composite_font(&self, name: &str) -> bool {
+        let removed = self.composites.write().unwrap_or_else(|e| e.into_inner()).remove(&name.to_lowercase()).is_some();
+        if removed {
+            self.changed();
+        }
+        removed
+    }
+
+    /// The composite font named `name` (any case).
+    pub fn composite_font(&self, name: &str) -> Option<Arc<CompositeFont>> {
+        let map = self.composites.read().unwrap_or_else(|e| e.into_inner());
+        if map.is_empty() {
+            return None;
+        }
+        map.get(&name.to_lowercase()).cloned()
+    }
+
+    /// The face composite font `name` sets character `c` in (its class's part's), and whether
+    /// that part's font is missing. `None` when `name` is no composite font.
+    pub fn composite_face(&self, name: &str, c: char) -> Option<(bool, u32)> {
+        self.composite_resolve(name, c).map(|(face, m)| (m == FontMatch::Missing, face.id()))
+    }
+
+    /// [`FontDb::composite_resolve`] for the character at byte `at` of run text `text`: the part of
+    /// the grapheme cluster that holds it, by the cluster's first character, as layout sets it.
+    pub fn composite_resolve_at(&self, name: &str, text: &str, at: usize) -> Option<(Arc<FontFace>, FontMatch)> {
+        let first = text.grapheme_indices(true).take_while(|(i, _)| *i <= at).last().and_then(|(_, g)| g.chars().next())?;
+        self.composite_resolve(name, first)
+    }
+
+    /// The face composite font `name` sets character `c` in (its class's part's), and how that
+    /// part's font matched ([`FontDb::resolve`]). `None` when `name` is no composite font, or no
+    /// font at all is loaded.
+    pub fn composite_resolve(&self, name: &str, c: char) -> Option<(Arc<FontFace>, FontMatch)> {
+        let f = self.composite_font(name)?;
+        let (family, style) = self.part_font(&f, CharClass::of(c));
+        self.resolve(&family, &style)
+    }
+
+    /// The fonts (family, style) composite font `name` sets `text` in: those of the parts its
+    /// grapheme clusters fall in (each by its first character, as layout splits them), each once,
+    /// in the order first used; the Kanji part's for text without characters. `None` when `name` is
+    /// no composite font.
+    pub fn composite_fonts_for(&self, name: &str, text: &str) -> Option<Vec<(String, String)>> {
+        let f = self.composite_font(name)?;
+        let mut classes: Vec<CharClass> = Vec::new();
+        for g in text.graphemes(true) {
+            let c = g.chars().next().map_or(CharClass::Kanji, CharClass::of);
+            if !classes.contains(&c) {
+                classes.push(c);
+            }
+        }
+        if classes.is_empty() {
+            classes.push(CharClass::Kanji);
+        }
+        let mut fonts: Vec<(String, String)> = Vec::with_capacity(classes.len());
+        for c in classes {
+            let font = self.part_font(&f, c);
+            if !fonts.contains(&font) {
+                fonts.push(font);
+            }
+        }
+        Some(fonts)
+    }
+
+    /// How composite font `name` draws the runs of text `texts` (each split into grapheme clusters
+    /// on its own, as layout splits runs): the worst match among the parts their grapheme clusters
+    /// fall in (missing, then another style, then exact), the face of the first part with that
+    /// match, and the characters (neither whitespace nor control characters, sorted, each once)
+    /// that their part's face lacks. `None` when `name` is no composite font.
+    pub fn composite_coverage(&self, name: &str, texts: &[&str]) -> Option<CompositeCoverage> {
+        let f = self.composite_font(name)?;
+        let rank = |m: FontMatch| match m {
+            FontMatch::Exact => 0,
+            FontMatch::Style => 1,
+            FontMatch::Missing => 2,
+        };
+        let mut faces: Vec<(CharClass, Resolved)> = Vec::new();
+        let mut face_of = |class: CharClass| {
+            if let Some((_, found)) = faces.iter().find(|(c, _)| *c == class) {
+                return found.clone();
+            }
+            let (family, style) = self.part_font(&f, class);
+            let found = self.resolve(&family, &style);
+            faces.push((class, found.clone()));
+            found
+        };
+        let mut worst: Option<(FontMatch, Option<Arc<FontFace>>)> = None;
+        let mut lacking: Vec<char> = Vec::new();
+        let mut graphemes: Vec<&str> = texts.iter().flat_map(|t| t.graphemes(true)).collect();
+        if graphemes.is_empty() {
+            graphemes.push("");
+        }
+        for g in graphemes {
+            let class = g.chars().next().map_or(CharClass::Kanji, CharClass::of);
+            let found = face_of(class);
+            let m = found.as_ref().map_or(FontMatch::Missing, |(_, m)| *m);
+            if worst.as_ref().is_none_or(|(w, _)| rank(m) > rank(*w)) {
+                worst = Some((m, found.as_ref().map(|(face, _)| face.clone())));
+            }
+            lacking.extend(g.chars().filter(|c| !c.is_whitespace() && !c.is_control() && !found.as_ref().is_some_and(|(face, _)| face.covers(*c))));
+        }
+        lacking.sort_unstable();
+        lacking.dedup();
+        let (status, face) = worst.unwrap_or((FontMatch::Exact, None));
+        Some(CompositeCoverage { status, face, lacking })
+    }
+
+    /// The family type in `family` is stored under when it is set in that font: a composite font's
+    /// own name, else the family of the face it resolves to (any name of a family, ヒラギノ角ゴシック,
+    /// is stored as its own, Hiragino Sans). `None` when the family isn't available.
+    pub fn stored_family(&self, family: &str, style: &str) -> Option<String> {
+        if let Some(f) = self.composite_font(family) {
+            return Some(f.name.clone());
+        }
+        match self.resolve(family, style) {
+            Some((face, m)) if m != FontMatch::Missing => Some(face.family.clone()),
+            _ => None,
+        }
+    }
+
+    /// Make each of the composite fonts `fonts` available while the returned guard lives, in place
+    /// of a composite font of the same name that the database holds. An app's session registers
+    /// the composite fonts of its front document; with the guard, a document exported without a
+    /// session, or one that is not in front, draws its type in its own. Dropping the guard puts
+    /// back the font each one replaced, or forgets it, unless another guard still lends the same
+    /// definition or a font of that name has been set since. While one guard lends a font, another
+    /// guard's different definition of that name is not lent.
+    pub fn lend_composite_fonts(&self, fonts: &[CompositeFont]) -> LentCompositeFonts<'_> {
+        let mut lent = Vec::new();
+        let mut changed = false;
+        // A font a document can't use (its name an installed family's, or a value out of range)
+        // is not lent: an app leaves it out when it opens the document.
+        let usable: Vec<&CompositeFont> = fonts.iter().filter(|f| f.check().is_ok() && !self.has_installed_family(&f.name)).collect();
+        if !usable.is_empty() {
+            let mut map = self.composites.write().unwrap_or_else(|e| e.into_inner());
+            let mut loans = self.composite_loans.lock().unwrap_or_else(|e| e.into_inner());
+            for f in usable {
+                let key = f.name.to_lowercase();
+                // A loan still in force: lend the same definition again, and leave another as it is.
+                if let Some(loan) = loans.get_mut(&key)
+                    && map.get(&key).is_some_and(|have| Arc::ptr_eq(have, &loan.font))
+                {
+                    if *loan.font == *f {
+                        loan.guards += 1;
+                        lent.push((key, loan.font.clone()));
+                    }
+                    continue;
+                }
+                if map.get(&key).is_some_and(|have| **have == *f) {
+                    continue;
+                }
+                let font = Arc::new((*f).clone());
+                let previous = map.insert(key.clone(), font.clone());
+                loans.insert(key.clone(), CompositeLoan { font: font.clone(), previous, guards: 1 });
+                lent.push((key, font));
+                changed = true;
+            }
+        }
+        if changed {
+            self.changed();
+        }
+        LentCompositeFonts { db: self, lent }
+    }
+
+    /// The family and style composite font `f` sets characters of `class` in: its part's, or the
+    /// fallback font's when that part names a composite font.
+    fn part_font(&self, f: &CompositeFont, class: CharClass) -> (String, String) {
+        let p = f.parts.get(class);
+        if self.composite_font(&p.font).is_some() { (FALLBACK_FAMILY.to_string(), "Regular".to_string()) } else { (p.font.clone(), p.style.clone()) }
+    }
+
+    /// The names of the composite fonts, sorted.
+    pub fn composite_font_names(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.composites.read().unwrap_or_else(|e| e.into_inner()).values().map(|f| f.name.clone()).collect();
+        v.sort_by_key(|n| n.to_lowercase());
+        v
+    }
+
+    /// The family and style that stand for composite font `name` where one font is needed (its
+    /// metrics, whether it is missing): its Kanji part's, or the fallback font's when that part
+    /// names a composite font too. `None` when `name` is no composite font.
+    pub(super) fn composite_base(&self, name: &str) -> Option<(String, String)> {
+        let f = self.composite_font(name)?;
+        Some(self.part_font(&f, CharClass::Kanji))
+    }
+
+    /// `t` with each run set in a composite font split into runs of one [`CharClass`] each, set in
+    /// that class's font: its size and baseline shift from the part's size and baseline (in
+    /// percent of the run's size), its scales multiplied by the part's, and Kana scaled at the
+    /// center raised so the em box's center stays where it was. Each grapheme cluster goes with
+    /// its first character. Also the index of the run of `t` each run came from. `None` when no run
+    /// is set in a composite font.
+    pub fn composite_split(&self, t: &TextObject) -> Option<(TextObject, Vec<usize>)> {
+        if self.composites.read().unwrap_or_else(|e| e.into_inner()).is_empty() {
+            return None;
+        }
+        let fonts: Vec<Option<Arc<CompositeFont>>> =
+            t.runs.iter().map(|r| if r.inline.is_some() { None } else { self.composite_font(&r.style.font_family) }).collect();
+        if fonts.iter().all(Option::is_none) {
+            return None;
+        }
+        let mut runs = Vec::with_capacity(t.runs.len());
+        let mut from = Vec::with_capacity(t.runs.len());
+        for (i, (r, font)) in t.runs.iter().zip(&fonts).enumerate() {
+            let Some(font) = font else {
+                runs.push(r.clone());
+                from.push(i);
+                continue;
+            };
+            let mut start = 0;
+            let mut class = None;
+            for (at, g) in r.text.grapheme_indices(true) {
+                let c = g.chars().next().map_or(CharClass::Kanji, CharClass::of);
+                if let Some(k) = class
+                    && k != c
+                {
+                    runs.push(self.composite_run(r.text.get(start..at).unwrap_or_default(), r, font, k));
+                    from.push(i);
+                    start = at;
+                }
+                class = Some(c);
+            }
+            runs.push(self.composite_run(r.text.get(start..).unwrap_or_default(), r, font, class.unwrap_or(CharClass::Kanji)));
+            from.push(i);
+        }
+        Some((TextObject { runs, ..t.clone() }, from))
+    }
+
+    /// Characters `text` of run `r` (set in composite font `font`), all of class `class`, as a run
+    /// set in that class's part.
+    fn composite_run(&self, text: &str, r: &TextRun, font: &CompositeFont, class: CharClass) -> TextRun {
+        let p = font.parts.get(class);
+        let mut st = r.style.clone();
+        let base = st.size;
+        let (family, style) = self.part_font(font, class);
+        st.font_family = family;
+        st.font_style = style;
+        st.font_version = None;
+        st.font_axes.clear();
+        st.size = base * p.size / 100.0;
+        st.baseline_shift += base * p.baseline / 100.0;
+        st.h_scale *= p.h_scale / 100.0;
+        st.v_scale *= p.v_scale / 100.0;
+        if class == CharClass::Kana && p.scale_at_center && p.v_scale != 100.0 {
+            let centre = self.style_face(&st).map_or(0.38, |f| f.ideographic_centre());
+            st.baseline_shift += st.size * centre * (1.0 - p.v_scale / 100.0);
+        }
+        TextRun { text: text.to_string(), style: st, inline: None }
+    }
+}
+
+/// A composite font [`FontDb::lend_composite_fonts`] put in the database.
+pub(super) struct CompositeLoan {
+    /// The font lent.
+    font: Arc<CompositeFont>,
+    /// The font of that name it replaced, put back when the last guard lending it drops.
+    previous: Option<Arc<CompositeFont>>,
+    /// How many guards lend it.
+    guards: usize,
+}
+
+/// The composite fonts [`FontDb::lend_composite_fonts`] made available, given back when it drops.
+#[must_use = "the fonts are given back when the guard drops"]
+pub struct LentCompositeFonts<'a> {
+    db: &'a FontDb,
+    /// The lowercased names this guard lends, each with the font lent.
+    lent: Vec<(String, Arc<CompositeFont>)>,
+}
+
+impl Drop for LentCompositeFonts<'_> {
+    fn drop(&mut self) {
+        if self.lent.is_empty() {
+            return;
+        }
+        let mut changed = false;
+        {
+            let mut map = self.db.composites.write().unwrap_or_else(|e| e.into_inner());
+            let mut loans = self.db.composite_loans.lock().unwrap_or_else(|e| e.into_inner());
+            for (key, font) in &self.lent {
+                // A later loan of that name is another guard's.
+                let Some(loan) = loans.get_mut(key).filter(|l| Arc::ptr_eq(&l.font, font)) else { continue };
+                loan.guards -= 1;
+                if loan.guards > 0 {
+                    continue;
+                }
+                let previous = loan.previous.take();
+                loans.remove(key);
+                // Given back unless a font of that name has been set or removed since.
+                if map.get(key).is_some_and(|have| Arc::ptr_eq(have, font)) {
+                    match previous {
+                        Some(p) => map.insert(key.clone(), p),
+                        None => map.remove(key),
+                    };
+                    changed = true;
+                }
+            }
+        }
+        if changed {
+            self.db.changed();
+        }
+    }
+}
diff --git a/crates/text/src/fontdb/db.rs b/crates/text/src/fontdb/db.rs
index 9cc32eeee..902a3e5aa 100644
--- a/crates/text/src/fontdb/db.rs
+++ b/crates/text/src/fontdb/db.rs
@@ -69,6 +69,8 @@ impl FontDb {
             #[cfg(not(target_arch = "wasm32"))]
             stamp: Mutex::new(None),
             instances: Mutex::new(Instances::default()),
+            composites: RwLock::new(HashMap::new()),
+            composite_loans: Mutex::new(HashMap::new()),
         }
     }
 
@@ -150,7 +152,8 @@ impl FontDb {
     /// The families font menus and lists show: [`FontDb::family_list`] without the system's hidden
     /// families, whose names start with "." (macOS keeps ".SF NS", ".LastResort" and others for its
     /// own interface, and Mac apps don't list them). Those still resolve by name, for documents and
-    /// fallbacks that name them. Cheap to call every frame.
+    /// fallbacks that name them. The composite fonts ([`FontDb::composite_font_names`]) come first.
+    /// Cheap to call every frame.
     pub fn menu_family_list(&self) -> Arc<[String]> {
         let all = self.family_list();
         let mut cache = self.menu_cache.lock().unwrap_or_else(|e| e.into_inner());
@@ -159,7 +162,8 @@ impl FontDb {
         {
             return list.clone();
         }
-        let list: Arc<[String]> = all.iter().filter(|f| !f.starts_with('.')).cloned().collect();
+        let composites = self.composite_font_names();
+        let list: Arc<[String]> = composites.into_iter().chain(all.iter().filter(|f| !f.starts_with('.')).cloned()).collect();
         *cache = Some((all, list.clone()));
         list
     }
@@ -187,7 +191,7 @@ impl FontDb {
         let mut v: Vec<String> = self.read_faces().iter().map(|f| f.family.clone()).filter(|f| !f.starts_with('.')).collect();
         v.sort_by_key(|a| a.to_lowercase());
         v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
-        v.into()
+        self.composite_font_names().into_iter().chain(v).collect()
     }
 
     /// How a font menu labels `family`: the English name when `english` is on (Preferences › Type ›
diff --git a/crates/text/src/fontdb/face.rs b/crates/text/src/fontdb/face.rs
index 5ab31eeae..fa59ff8ee 100644
--- a/crates/text/src/fontdb/face.rs
+++ b/crates/text/src/fontdb/face.rs
@@ -193,6 +193,8 @@ pub struct FontFace {
     pub(super) ideographic_centre: std::sync::OnceLock<f64>,
     /// [`Self::icf_margins`], read once.
     pub(super) icf_margins: std::sync::OnceLock<IcfMargins>,
+    /// [`Self::path_align_heights`], read once.
+    pub(super) path_align: std::sync::OnceLock<PathAlignHeights>,
     /// Has `sbix` or `CBDT` strikes: colour bitmap glyphs ([`FontDb::glyph_image`]).
     pub(super) colour_bitmaps: bool,
     /// Has `COLR` colour glyphs ([`FontDb::glyph_colour`]).
@@ -212,6 +214,26 @@ pub struct IcfMargins {
     pub left: f64,
 }
 
+/// The heights above the baseline, in ems, that Type on a Path's Align to Path runs along the
+/// path ([`FontFace::path_align_heights`]). These are VectorCraft's own values.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub(crate) struct PathAlignHeights {
+    /// Ascender: the top of the face's em box ([`FontFace::em_box_top`]).
+    pub(crate) top: f64,
+    /// Descender (negative): the bottom of the font's bounding box (`head`), else the face's
+    /// descent.
+    pub(crate) bottom: f64,
+    /// Center: half the height of the top of the H above the baseline in whole thousandths of an
+    /// em, else half the OS/2 cap height, else the middle of the em box.
+    pub(crate) center: f64,
+}
+
+/// The characters whose ink an ideographic face's em box is centered on, the first the face has.
+const EM_BOX_IDEOGRAPHS: [char; 4] = ['永', '鬱', '곬', '・'];
+
+/// A box-drawing character whose ink, in an ideographic face, is one em tall: the em box.
+const EM_BOX_CROSS: char = '┼';
+
 impl std::fmt::Debug for FontFace {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "FontFace({} {})", self.family, self.style)
@@ -462,6 +484,111 @@ impl FontFace {
         *self.icf_margins.get_or_init(|| self.icf_from_base().or_else(|| self.icf_from_glyphs()).unwrap_or_default())
     }
 
+    /// The lines Type on a Path's Align to Path runs along the path, in ems above the baseline
+    /// ([`PathAlignHeights`]): the top of the em box ([`Self::em_box_top`], else 0.88 em), the
+    /// bottom of the font's bounding box, and half the height of the top of the H.
+    pub(crate) fn path_align_heights(&self) -> PathAlignHeights {
+        *self.path_align.get_or_init(|| {
+            use skrifa::raw::TableProvider;
+            let em = self.upem;
+            let top = self.em_box_top().unwrap_or(0.88);
+            let bottom =
+                self.skrifa().and_then(|f| f.head().ok()).map(|h| f64::from(h.y_min()) / em).filter(|b| b.is_finite() && *b <= 0.0 && *b > -4.0);
+            // Measured from the baseline to the top of the H, as a cap height is, wherever its ink starts.
+            let cap = self.glyph_ink('H').map(|(_, top)| top / em).or_else(|| self.os2_cap_height()).filter(|c| c.is_finite() && *c < 2.0);
+            PathAlignHeights {
+                top,
+                bottom: bottom.unwrap_or(-self.descent / em),
+                center: cap.map_or(top - 0.5, |cap| (cap * 1000.0).round() / 2000.0),
+            }
+        })
+    }
+
+    /// The top of the face's em box, in ems above the baseline. A `BASE` table with an `ideo`
+    /// baseline gives it: its `idtp`, else one em above `ideo`. In a face whose OS/2 code pages
+    /// include Chinese, Japanese or Korean, it is the typographic ascender of the typographic box
+    /// (else, in a TrueType face, of the `hhea` box) when that box holds the ink of the first of 永,
+    /// 鬱, 곬 and ・ the face has, and is one em tall or leaves equal margins above and below the
+    /// ink; a face with none of them needs the box to be one em tall. Else it is the top of a ┼
+    /// one em tall, else the top of an em box centered on the ink. In any other face the em box is
+    /// centered on the cap height: the OS/2 value, else the lower of the tops of H and O in whole
+    /// thousandths of an em. `None` when none of these applies.
+    pub(crate) fn em_box_top(&self) -> Option<f64> {
+        use skrifa::raw::TableProvider;
+        let f = self.skrifa()?;
+        let em = self.upem;
+        let sane = |v: f64| (v.is_finite() && v.abs() < 4.0).then_some(v);
+        // A roman baseline below the ideographic one is a damaged table: the baselines are ignored.
+        if let Some(h) = f.base().ok().and_then(|b| b.horiz_axis()).and_then(Result::ok).and_then(base_values)
+            && let Some(&ideo) = h.get(b"ideo")
+            && h.get(b"romn").is_none_or(|&romn| romn >= ideo)
+        {
+            return sane(h.get(b"idtp").copied().unwrap_or(ideo + em) / em);
+        }
+        // ulCodePageRange1 bits 17 to 21: JIS/Japan, Chinese Simplified, Korean Wansung, Chinese
+        // Traditional and Korean Johab.
+        let cjk = f.os2().ok().and_then(|o| o.ul_code_page_range_1()).is_some_and(|r| r & (0b1_1111 << 17) != 0);
+        if !cjk {
+            let lower_top = || {
+                let ((_, h), (_, o)) = (self.glyph_ink('H')?, self.glyph_ink('O')?);
+                Some((h.min(o) / em * 1000.0).round() / 1000.0)
+            };
+            let cap = self.os2_cap_height().or_else(lower_top).filter(|c| c.is_finite() && *c > 0.0 && *c < 2.0)?;
+            return Some((cap + 1.0) * 0.5);
+        }
+        // Heights in 65,536ths of an em, as the em box is kept.
+        let units = |v: f64| (v / em * 65536.0).round();
+        let ink = EM_BOX_IDEOGRAPHS.into_iter().find_map(|c| self.glyph_ink(c));
+        // A variable font's MVAR table moves the OS/2 typographic ascender (`hasc`) and descender
+        // (`hdsc`); it has no tags for the `hhea` ascender and descender, which do not vary:
+        // https://learn.microsoft.com/en-us/typography/opentype/spec/mvar
+        let varied = |tag: &[u8; 4]| {
+            f.mvar().ok().and_then(|m| m.metric_delta(skrifa::Tag::new(tag), self.location().coords()).ok()).map_or(0.0, |d| d.to_f64())
+        };
+        let typo = f
+            .os2()
+            .ok()
+            .map(|o| (f64::from(o.s_typo_ascender()) + varied(b"hasc"), f64::from(o.s_typo_descender()) + varied(b"hdsc")))
+            .filter(|(ascent, descent)| ascent > descent)
+            .or_else(|| {
+                let truetype = f.table_data(skrifa::Tag::new(b"glyf")).is_some();
+                f.hhea().ok().filter(|_| truetype).map(|h| (f64::from(h.ascender().to_i16()), f64::from(h.descender().to_i16())))
+            })
+            .filter(|(ascent, descent)| ascent > descent);
+        if let Some((ascent, descent)) = typo {
+            let one_em = units(ascent - descent) == 65536.0;
+            let holds = match ink {
+                None => one_em,
+                Some((lo, hi)) => hi <= ascent && lo >= descent && (one_em || units((ascent - hi) - (lo - descent)).abs() <= 197.0),
+            };
+            if holds {
+                return sane(ascent / em);
+            }
+        }
+        if let Some((lo, hi)) = self.glyph_ink(EM_BOX_CROSS)
+            && (65535.0..=65537.0).contains(&units(hi - lo))
+        {
+            return sane(hi / em);
+        }
+        ink.and_then(|(lo, hi)| sane((lo + hi) / em * 0.5 + 0.5))
+    }
+
+    /// The bottom and top of the ink of `c`'s glyph, in font units; `None` when the face has no
+    /// glyph for it, or the glyph has no ink.
+    fn glyph_ink(&self, c: char) -> Option<(f64, f64)> {
+        let g = self.glyph_for(c);
+        if g == 0 {
+            return None;
+        }
+        let b = self.skrifa()?.glyph_metrics(Size::unscaled(), self.location()).bounds(GlyphId::new(g))?;
+        Some((f64::from(b.y_min), f64::from(b.y_max))).filter(|(lo, hi)| hi > lo)
+    }
+
+    /// The cap height of the OS/2 table, in ems; `None` without one.
+    fn os2_cap_height(&self) -> Option<f64> {
+        self.skrifa()?.metrics(Size::unscaled(), self.location()).cap_height.map(|c| f64::from(c) / self.upem).filter(|c| *c > 0.0)
+    }
+
     /// The height of the face that a font size measures with `reference`, in ems: 1 for the em
     /// box; the cap height or x height of its OS/2 table; the height of its ideographic character
     /// face ([`Self::icf_margins`]), or across a `vertical` line its width. None for a face whose
diff --git a/crates/text/src/fontdb/lookup.rs b/crates/text/src/fontdb/lookup.rs
index 010f96ffa..71e8e7ab8 100644
--- a/crates/text/src/fontdb/lookup.rs
+++ b/crates/text/src/fontdb/lookup.rs
@@ -82,8 +82,11 @@ impl FontDb {
     /// The kind of `family` (whether it sets Japanese, its class), for font menu filters: from a
     /// loaded face, else from the system font scan. Variable when any of its faces, loaded or
     /// scanned, is: a family may install static files beside a variable one. Cheap: no font file
-    /// is read, and a loaded family doesn't start the scan.
+    /// is read, and a loaded family doesn't start the scan. A composite font takes its base font's.
     pub fn family_traits(&self, family: &str) -> FontTraits {
+        if let Some((base, _)) = self.composite_base(family) {
+            return self.family_traits(&base);
+        }
         let loaded = {
             let faces = self.read_faces();
             let mut of_family = faces.iter().filter(|f| f.family.eq_ignore_ascii_case(family));
@@ -101,8 +104,11 @@ impl FontDb {
     }
 
     /// [`face`](Self::face) by any of the family's names ([`canonical`](Self::canonical)), and how
-    /// it matched.
+    /// it matched. A composite font matches as its base font does ([`Self::composite_base`]).
     pub fn resolve(&self, family: &str, style: &str) -> Option<(Arc<FontFace>, FontMatch)> {
+        if let Some((base, base_style)) = self.composite_base(family) {
+            return self.resolve(&base, &base_style);
+        }
         let (family, style) = self.canonical(family, style);
         let f = self.face(&family, &style)?;
         let m = if !f.family.eq_ignore_ascii_case(&family) {
@@ -159,8 +165,12 @@ impl FontDb {
     /// Resolve a family + style to a face, falling back to the closest style of the family, then to
     /// Source Sans 3 Regular. Installed system fonts are found by name whatever ran before. `None`
     /// only if no font at all is loaded (the bundled fonts failed to parse, or were left out with
-    /// the `bundled-fonts` feature and none was added), in which case text has no glyphs.
+    /// the `bundled-fonts` feature and none was added), in which case text has no glyphs. A
+    /// composite font gives its base font's face ([`Self::composite_base`]).
     pub fn face(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {
+        if let Some((base, base_style)) = self.composite_base(family) {
+            return self.face(&base, &base_style);
+        }
         let (family, style) = self.canonical(family, style);
         let (family, style) = (family.as_str(), style.as_str());
         let found = self.find(family, style);
@@ -352,8 +362,16 @@ impl FontDb {
         self.family_list().iter().find(|f| norm_chars(f).eq(norm_chars(name))).cloned()
     }
 
-    /// Is `family` available (loaded, or installed on the system)?
+    /// Is `family` available (loaded, installed on the system, or a composite font)?
     pub fn has_family(&self, family: &str) -> bool {
+        if self.composite_font(family).is_some() {
+            return true;
+        }
+        self.has_installed_family(family)
+    }
+
+    /// Is `family` available as a loaded or installed font, excluding composite fonts?
+    pub fn has_installed_family(&self, family: &str) -> bool {
         let (family, _) = self.canonical(family, "");
         self.is_loaded(&family) || self.read_catalog().contains_key(&family.to_ascii_lowercase())
     }
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 6e9334041..053cd2981 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -115,6 +115,10 @@ struct Ctx<'a> {
     db: &'a FontDb,
     text: &'a str,
     runs: Vec<(Range<usize>, &'a CharStyle)>,
+    /// The runs as the text sets them, when `runs` are the pieces a composite font splits them
+    /// into ([`FontDb::composite_split`]); empty otherwise. Ruby readings take their style from
+    /// these, so a reading in a composite font is set in its own parts.
+    set_runs: Vec<(Range<usize>, &'a CharStyle)>,
     /// The inline graphic of each run that is one (parallel to `runs`).
     inlines: Vec<Option<&'a InlineArt>>,
     /// The face of each run (parallel to `runs`), looked up once ([`run_face`]).
@@ -151,6 +155,16 @@ impl Ctx<'_> {
         self.run_at(b).and_then(|i| self.runs.get(i)).map_or(&self.default, |(_, s)| *s)
     }
 
+    /// The style the text sets byte `b` in: [`Self::style_at`], or for text in a composite font
+    /// the run's style before it was split by class ([`Self::set_runs`]).
+    fn set_style_at(&self, b: usize) -> &CharStyle {
+        let i = self.set_runs.partition_point(|(r, _)| r.end <= b);
+        match self.set_runs.get(i).or_else(|| self.set_runs.last()) {
+            Some((_, s)) => s,
+            None => self.style_at(b),
+        }
+    }
+
     /// The face of [`Self::style_at`] `b` ([`FontDb::style_face`]).
     fn face_at(&self, b: usize) -> Option<Arc<FontFace>> {
         match self.run_at(b).and_then(|i| self.runs.get(i).map(|(_, s)| (i, *s))) {
diff --git a/crates/text/src/layout/driver.rs b/crates/text/src/layout/driver.rs
index f55750e95..75796e265 100644
--- a/crates/text/src/layout/driver.rs
+++ b/crates/text/src/layout/driver.rs
@@ -276,8 +276,27 @@ pub(crate) fn layout_faces_per_call(db: &FontDb, t: &TextObject) -> TextLayout {
     l
 }
 
-/// One layout pass, without fitting.
+/// One layout pass, without fitting. Runs set in a composite font are laid out as the runs of one
+/// class each that [`FontDb::composite_split`] makes of them; the glyphs, ruby and inline
+/// graphics still name the runs of `t`.
 fn layout_once(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout {
+    let Some((split, from)) = db.composite_split(t) else { return layout_runs(db, t, opts, None) };
+    let mut l = layout_runs(db, &split, opts, Some(t));
+    let original = |run: &mut usize| *run = from.get(*run).copied().unwrap_or(*run);
+    l.glyphs.iter_mut().chain(l.ruby.iter_mut()).for_each(|g| original(&mut g.run));
+    l.inlines.iter_mut().for_each(|i| original(&mut i.run));
+    l
+}
+
+/// [`layout_once`] for text set in no composite font: `t` itself, or with `set`, the pieces a
+/// composite font splits `set` into (ruby readings take their style from `set`'s runs).
+fn layout_runs(db: &FontDb, t: &TextObject, opts: &LayoutOptions, set: Option<&TextObject>) -> TextLayout {
+    let mut set_runs = Vec::new();
+    let mut off = 0;
+    for r in set.map(|s| s.runs.as_slice()).unwrap_or_default() {
+        set_runs.push((off..off + r.text.len(), &r.style));
+        off += r.text.len();
+    }
     let text = t.plain_text();
     let mut runs = Vec::with_capacity(t.runs.len());
     let mut inlines = Vec::with_capacity(t.runs.len());
@@ -315,6 +334,7 @@ fn layout_once(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLayout
         text: &text,
         faces,
         runs,
+        set_runs,
         inlines,
         default: CharStyle::default(),
         opts,
diff --git a/crates/text/src/layout/on_path.rs b/crates/text/src/layout/on_path.rs
index 14bc3ef4b..aafe17531 100644
--- a/crates/text/src/layout/on_path.rs
+++ b/crates/text/src/layout/on_path.rs
@@ -6,6 +6,7 @@ use super::{
     Affine, ArcPath, BezPath, Ctx, GlyphBend, Justify, LineInfo, ListMarker, ParamCurve, PathAlign, PathData, PathEffect, PathEl, Point, Range,
     SGlyph, Shape, TextObject, Vec2, style_metrics,
 };
+use crate::fontdb::PathAlignHeights;
 
 /// The distance along type on a path each glyph takes: its advance measured `spacing` points above
 /// the path (Type on a Path Options › Spacing), so glyphs close up round the outside of a curve and
@@ -315,16 +316,25 @@ pub(super) fn on_path(cx: &mut Ctx<'_>, paras: &[Range<usize>], t: &TextObject,
         cx.out.overflow = true;
         fits = sg.get(fit..).and_then(|rest| rest.iter().map(|g| g.byte).min()).unwrap_or(text_len);
     }
-    // Align to Path: how far down (glyph space) the type moves to run its ascender, centre or
-    // descender along the path instead of its baseline.
-    let rise = match t.path_align {
-        PathAlign::Baseline => 0.0,
-        PathAlign::Ascender => m.0,
-        PathAlign::Descender => -m.1,
-        PathAlign::Center => (m.0 - m.1) * 0.5,
+    // Align to Path: how far down (glyph space) a glyph moves to run the top of its em box, half the
+    // height of the top of its H or the bottom of its font's bounding box along the path instead of its
+    // baseline, each glyph by its own face, size and vertical scale. In vertical type the glyph
+    // moves half its em (with its horizontal scale) for Ascender and Descender, and stays for Center.
+    // An inline graphic moves as a character of its run would, by its run's vertical scale in both.
+    let vertical = cx.vertical;
+    let rise_of = |g: &SGlyph| {
+        let em = g.face.units_per_em() * if vertical { g.sx } else { g.sy };
+        let h = if vertical { PathAlignHeights { top: 0.5, bottom: -0.5, center: 0.0 } } else { g.face.path_align_heights() };
+        match t.path_align {
+            PathAlign::Baseline => 0.0,
+            PathAlign::Ascender => h.top * em,
+            PathAlign::Descender => h.bottom * em,
+            PathAlign::Center => h.center * em,
+        }
     };
     let mut x = 0.0;
     for (g, &step) in sg.iter().zip(&steps).take(fit) {
+        let rise = rise_of(g);
         let s = s0 + x;
         let (p, dir) = ap.at(s + step * 0.5);
         let angle = dir.y.atan2(dir.x);
diff --git a/crates/text/src/layout/ruby.rs b/crates/text/src/layout/ruby.rs
index 1cf34e24c..34cb71f09 100644
--- a/crates/text/src/layout/ruby.rs
+++ b/crates/text/src/layout/ruby.rs
@@ -127,7 +127,10 @@ fn ruby_piece_for_line(
 ) -> Option<RubyPiece> {
     let mut x0 = f64::INFINITY;
     let mut x1 = f64::NEG_INFINITY;
+    // The size the base is drawn at (where the reading goes), and the size the text sets it in (what
+    // the reading is scaled from: a composite font's part scales the reading itself).
     let mut base_size: f64 = 0.0;
+    let mut set_size: f64 = 0.0;
     let mut run = 0;
     let mut byte = start;
     for (index, &glyph_index) in glyph_indices.iter().enumerate() {
@@ -135,6 +138,7 @@ fn ruby_piece_for_line(
         x0 = x0.min(glyph.origin.x);
         x1 = x1.max(glyph.origin.x + glyph.advance);
         base_size = base_size.max(cx.style_at(glyph.byte).size);
+        set_size = set_size.max(cx.set_style_at(glyph.byte).size);
         if index == 0 {
             run = glyph.run;
             byte = glyph.byte;
@@ -143,8 +147,9 @@ fn ruby_piece_for_line(
     if !(x0.is_finite() && x1.is_finite()) || base_size <= 0.0 {
         return None;
     }
-    let mut style = cx.style_at(byte).clone();
-    style.size = base_size * ratio;
+    // The base's style as the text sets it: a reading in a composite font is set in its parts.
+    let mut style = cx.set_style_at(byte).clone();
+    style.size = set_size * ratio;
     style.leading = None;
     style.baseline_shift = 0.0;
     style.tracking = 0.0;
diff --git a/crates/text/src/layout/wrapping_tests.rs b/crates/text/src/layout/wrapping_tests.rs
index aec815641..e54a49144 100644
--- a/crates/text/src/layout/wrapping_tests.rs
+++ b/crates/text/src/layout/wrapping_tests.rs
@@ -114,6 +114,7 @@ fn composition_trim_stays_along_the_line_when_a_character_rotates() {
                 db: &db,
                 text: "A",
                 runs: vec![(0..1, &style)],
+                set_runs: Vec::new(),
                 inlines: vec![None],
                 faces: vec![std::cell::OnceCell::new()],
                 default: style.clone(),
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
index ce315645e..2dc80a3e9 100644
--- a/crates/text/src/lib.rs
+++ b/crates/text/src/lib.rs
@@ -36,9 +36,9 @@ pub use bitmap::GlyphImage;
 pub use craft_fonts::{CRAFT_FONTS, CraftFont, WEB_FONTS, WebFont};
 pub use features::{EXTRA_FEATURES, LIGATURE_TRACKING_LIMITS, MAX_STYLE_FEATURES, OtFeatures, explicit_ligatures, ligatures_suppressed_by};
 pub use fontdb::{
-    FALLBACK_FAMILY, FontClass, FontDb, FontFace, FontMatch, FontTraits, GlyphAlternate, IcfMargins, PlatformFontFiles, StylisticSet, WantedFont,
-    WantedFonts, app_font_dir, is_font_file, is_suitcase, set_app_font_dir, set_platform_font_files, set_user_font_dirs, set_user_font_dirs_confined,
-    style_weight, system_font_dirs, user_font_dirs,
+    CompositeCoverage, FALLBACK_FAMILY, FontClass, FontDb, FontFace, FontMatch, FontTraits, GlyphAlternate, IcfMargins, LentCompositeFonts,
+    PlatformFontFiles, StylisticSet, WantedFont, WantedFonts, app_font_dir, is_font_file, is_suitcase, set_app_font_dir, set_platform_font_files,
+    set_user_font_dirs, set_user_font_dirs_confined, style_weight, system_font_dirs, user_font_dirs,
 };
 pub use hyphen::{hyphenation_exceptions, set_hyphenation_exceptions};
 pub use layout::{envelope_ink, register_envelope_ink};
diff --git a/crates/text/src/test_fonts.rs b/crates/text/src/test_fonts.rs
index 00c994467..cbb2c20d2 100644
--- a/crates/text/src/test_fonts.rs
+++ b/crates/text/src/test_fonts.rs
@@ -1073,6 +1073,160 @@ pub fn tall_ideograph_font() -> Option<Vec<u8>> {
     Some(data)
 }
 
+/// A family of [`path_align_font`]: OS/2 cap height 660, H and O.
+pub const PATH_ALIGN_ROMAN_FAMILY: &str = "Pathalign Roman Sans";
+/// A family of [`path_align_font`]: no cap height, no H or O, and a `head` box above the baseline.
+pub const PATH_ALIGN_BARE_FAMILY: &str = "Pathalign Bare Sans";
+/// A family of [`path_align_font`]: a `BASE` table with `ideo` at -150 and no `idtp`.
+pub const PATH_ALIGN_BASE_FAMILY: &str = "Pathalign Base Sans";
+/// A family of [`path_align_font`]: Japanese code page, 永 on the ⌠ outline (ink -51 to 949).
+pub const PATH_ALIGN_IDEOGRAPH_FAMILY: &str = "Pathalign Ideograph Sans";
+/// A family of [`path_align_font`]: as [`PATH_ALIGN_IDEOGRAPH_FAMILY`], with ┼ on the | outline
+/// (ink -250 to 750, one em).
+pub const PATH_ALIGN_CROSS_FAMILY: &str = "Pathalign Cross Sans";
+/// A family of [`path_align_font`]: Japanese code page, 永 on the H outline (ink 0 to 656), and a
+/// typographic box from -100 to 900.
+pub const PATH_ALIGN_TYPO_FAMILY: &str = "Pathalign Typo Sans";
+/// A family of [`path_align_font`]: as [`PATH_ALIGN_TYPO_FAMILY`], with a typographic box of 0
+/// to 0 and an `hhea` box from -100 to 900.
+pub const PATH_ALIGN_HHEA_FAMILY: &str = "Pathalign Hhea Sans";
+/// A family of [`path_align_font`]: as [`PATH_ALIGN_TYPO_FAMILY`], as a variable font with one
+/// weight axis (400–700, named instances Regular and Bold) whose `MVAR` table raises the
+/// typographic ascender and descender by 100 at 700: a box from 0 to 1,000 in Bold.
+pub const PATH_ALIGN_VARIABLE_FAMILY: &str = "Pathalign Variable Sans";
+/// A family of [`path_align_font`]: Japanese code page, with no reference ideograph and no ┼.
+pub const PATH_ALIGN_NONE_FAMILY: &str = "Pathalign None Sans";
+/// A family of [`path_align_font`]: no cap height, and H and O swapped (H top 668, O top 656).
+pub const PATH_ALIGN_LOWER_FAMILY: &str = "Pathalign Lower Sans";
+/// A family of [`path_align_font`]: OS/2 cap height 660, O and no H, and a `BASE` table as
+/// [`PATH_ALIGN_BASE_FAMILY`]'s.
+pub const PATH_ALIGN_CAPITAL_FAMILY: &str = "Pathalign Capital Sans";
+/// A family of [`path_align_font`]: as [`PATH_ALIGN_IDEOGRAPH_FAMILY`], with a typographic box
+/// from -101 to 1,002: margins of 53 and 50 round 永's ink.
+pub const PATH_ALIGN_MARGINS_FAMILY: &str = "Pathalign Margins Sans";
+/// A family of [`path_align_font`]: as [`PATH_ALIGN_IDEOGRAPH_FAMILY`], with a typographic box
+/// from -101 to 1,003: margins of 54 and 50 round 永's ink.
+pub const PATH_ALIGN_UNEVEN_FAMILY: &str = "Pathalign Uneven Sans";
+/// A family of [`path_align_font`]: a `BASE` table with `ideo` at -150 and `romn` below it at
+/// -200.
+pub const PATH_ALIGN_DAMAGED_FAMILY: &str = "Pathalign Damaged Sans";
+
+/// The bundled Source Sans 3 Regular (1,000 units to the em, typographic box -326 to 1,000, `head`
+/// box bottom -295, H top 656, O top 668) without its `BASE` table, as one of the
+/// `PATH_ALIGN_*_FAMILY` faces, which map x, and H and O except where the family says otherwise.
+/// `None` when it can't be built.
+pub fn path_align_font(family: &str) -> Option<Vec<u8>> {
+    use write_fonts::tables::base::{Axis, Base, BaseCoord, BaseScript, BaseScriptList, BaseScriptRecord, BaseTagList, BaseValues};
+    use write_fonts::tables::mvar::{Mvar, ValueRecord};
+    use write_fonts::tables::variations::{ItemVariationData, ItemVariationStore, RegionAxisCoordinates, VariationRegion, VariationRegionList};
+    use write_fonts::types::MajorMinor;
+
+    let typo = family == PATH_ALIGN_TYPO_FAMILY || family == PATH_ALIGN_VARIABLE_FAMILY;
+    let ideograph = [PATH_ALIGN_IDEOGRAPH_FAMILY, PATH_ALIGN_CROSS_FAMILY, PATH_ALIGN_MARGINS_FAMILY, PATH_ALIGN_UNEVEN_FAMILY].contains(&family);
+    let japanese = typo || ideograph || [PATH_ALIGN_HHEA_FAMILY, PATH_ALIGN_NONE_FAMILY].contains(&family);
+    let mut mapping = vec![('x', 'x')];
+    match family {
+        PATH_ALIGN_BARE_FAMILY => {}
+        PATH_ALIGN_LOWER_FAMILY => mapping.extend([('H', 'O'), ('O', 'H')]),
+        PATH_ALIGN_CAPITAL_FAMILY => mapping.push(('O', 'O')),
+        _ => mapping.extend([('H', 'H'), ('O', 'O')]),
+    }
+    if ideograph {
+        mapping.push(('永', '⌠'));
+    }
+    if family == PATH_ALIGN_CROSS_FAMILY {
+        mapping.push(('┼', '|'));
+    }
+    if typo || family == PATH_ALIGN_HHEA_FAMILY {
+        mapping.push(('永', 'H'));
+    }
+    let mut data = remapped_source_sans(family, &format!("{}-Regular", family.replace(' ', "")), &mapping)?;
+    let tables: Vec<(Tag, usize)> = {
+        let font = skrifa::FontRef::new(&data).ok()?;
+        font.table_directory.table_records().iter().map(|r| (Tag::new(&r.tag().to_be_bytes()), r.offset() as usize)).collect()
+    };
+    for (tag, at) in tables {
+        if tag == Tag::new(b"OS/2") {
+            if japanese {
+                // ulCodePageRange1 at bytes 78 to 82: bit 17, JIS/Japan.
+                data.get_mut(at + 78..at + 82)?.copy_from_slice(&(1_u32 << 17).to_be_bytes());
+            }
+            if typo {
+                // sTypoAscender and sTypoDescender at bytes 68 to 72.
+                data.get_mut(at + 68..at + 72)?.copy_from_slice(&[900_i16.to_be_bytes(), (-100_i16).to_be_bytes()].concat());
+            }
+            if family == PATH_ALIGN_HHEA_FAMILY {
+                data.get_mut(at + 68..at + 72)?.copy_from_slice(&[0, 0, 0, 0]);
+            }
+            if family == PATH_ALIGN_MARGINS_FAMILY || family == PATH_ALIGN_UNEVEN_FAMILY {
+                let top: i16 = if family == PATH_ALIGN_MARGINS_FAMILY { 1002 } else { 1003 };
+                data.get_mut(at + 68..at + 72)?.copy_from_slice(&[top.to_be_bytes(), (-101_i16).to_be_bytes()].concat());
+            }
+            if family == PATH_ALIGN_BARE_FAMILY || family == PATH_ALIGN_LOWER_FAMILY {
+                // sCapHeight at bytes 88 to 90.
+                data.get_mut(at + 88..at + 90)?.copy_from_slice(&0_i16.to_be_bytes());
+            }
+        } else if tag == Tag::new(b"hhea") && family == PATH_ALIGN_HHEA_FAMILY {
+            // ascender and descender at bytes 4 to 8.
+            data.get_mut(at + 4..at + 8)?.copy_from_slice(&[900_i16.to_be_bytes(), (-100_i16).to_be_bytes()].concat());
+        } else if tag == Tag::new(b"head") && family == PATH_ALIGN_BARE_FAMILY {
+            // yMin at bytes 38 to 40.
+            data.get_mut(at + 38..at + 40)?.copy_from_slice(&10_i16.to_be_bytes());
+        }
+    }
+    // Source Sans 3's own `BASE` table (`ideo` -170) is left out.
+    let font = skrifa::FontRef::new(&data).ok()?;
+    let mut builder = FontBuilder::new();
+    if [PATH_ALIGN_BASE_FAMILY, PATH_ALIGN_CAPITAL_FAMILY, PATH_ALIGN_DAMAGED_FAMILY].contains(&family) {
+        let romn = if family == PATH_ALIGN_DAMAGED_FAMILY { -200 } else { 0 };
+        let tags = BaseTagList::new([b"ideo", b"romn"].map(Tag::new).to_vec());
+        let values = BaseValues::new(1, [-150, romn].map(BaseCoord::format_1).to_vec());
+        let latn = BaseScriptRecord::new(Tag::new(b"latn"), BaseScript::new(Some(values), None, vec![]));
+        let axis = Axis::new(Some(tags), BaseScriptList::new(vec![latn]));
+        builder.add_table(&Base::new(Some(axis), None)).ok()?;
+    }
+    if family == PATH_ALIGN_VARIABLE_FAMILY {
+        let region = VariationRegion::new(vec![RegionAxisCoordinates::new(F2Dot14::from_f32(0.0), F2Dot14::from_f32(1.0), F2Dot14::from_f32(1.0))]);
+        // Two delta sets (hasc, hdsc) of one 16-bit delta each for the one region.
+        let data = ItemVariationData::new(2, 1, vec![0], [100_i16.to_be_bytes(), 100_i16.to_be_bytes()].concat());
+        let store = ItemVariationStore::new(VariationRegionList::new(1, vec![region]), vec![Some(data)]);
+        let records = vec![ValueRecord::new(Tag::new(b"hasc"), 0, 0), ValueRecord::new(Tag::new(b"hdsc"), 0, 1)];
+        let axis = VariationAxisRecord {
+            axis_tag: Tag::new(b"wght"),
+            min_value: Fixed::from_i32(400),
+            default_value: Fixed::from_i32(400),
+            max_value: Fixed::from_i32(700),
+            flags: 0,
+            axis_name_id: NameId::new(256),
+        };
+        let instance = |name: u16, wght: i32| InstanceRecord {
+            subfamily_name_id: NameId::new(name),
+            flags: 0,
+            coordinates: vec![Fixed::from_i32(wght)],
+            post_script_name_id: None,
+        };
+        let fvar = Fvar::new(AxisInstanceArrays::new(vec![axis], vec![instance(257, 400), instance(258, 700)]));
+        let name = name_table(&[
+            (1, family),
+            (2, "Regular"),
+            (4, "Pathalign Variable Sans Regular"),
+            (6, "PathalignVariableSans-Regular"),
+            (256, "Weight"),
+            (257, "Regular"),
+            (258, "Bold"),
+        ])?;
+        builder.add_raw(Tag::new(b"name"), name);
+        builder.add_table(&fvar).ok()?.add_table(&Mvar::new(MajorMinor::VERSION_1_0, Some(store), records)).ok()?;
+    }
+    for r in font.table_directory.table_records() {
+        let tag = Tag::new(&r.tag().to_be_bytes());
+        if !builder.contains(tag) && tag != Tag::new(b"BASE") {
+            builder.add_raw(tag, font.table_data(r.tag())?.as_bytes());
+        }
+    }
+    Some(builder.build())
+}
+
 /// The family of [`soft_hyphen_outline_font`].
 pub const SOFT_HYPHEN_OUTLINE_FAMILY: &str = "Soft Hyphen Profile Sans";
 
diff --git a/crates/text/src/tests.rs b/crates/text/src/tests.rs
index 6183278ed..ef171316e 100644
--- a/crates/text/src/tests.rs
+++ b/crates/text/src/tests.rs
@@ -9,6 +9,7 @@ mod bidi;
 mod bitmaps;
 mod colr;
 mod combos;
+mod composite;
 mod devanagari;
 mod embed;
 mod fit;
@@ -454,6 +455,158 @@ fn on_path_effects_orient_glyphs() {
     assert_eq!(PathEffect::parse("stair step"), Some(PathEffect::StairStep));
 }
 
+/// Type on a straight path from (0, 50) to (500, 50), one run per style: how far each glyph's
+/// baseline lies below the path under each Align to Path option, or with `ink` the middle of its
+/// drawn outline.
+fn path_align_drops(db: &FontDb, styles: &[CharStyle], vertical: bool, ink: bool) -> Vec<(vectorcraft_doc::PathAlign, Vec<f64>)> {
+    use vectorcraft_doc::PathAlign;
+    let mut line = BezPath::new();
+    line.move_to((0.0, 50.0));
+    line.line_to((500.0, 50.0));
+    let mut t = point("", style(12.0));
+    t.runs = styles.iter().map(|st| TextRun::new("x", st.clone())).collect();
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&line), start: 0.0, end: None };
+    t.vertical = vertical;
+    [PathAlign::Baseline, PathAlign::Ascender, PathAlign::Center, PathAlign::Descender]
+        .into_iter()
+        .map(|align| {
+            t.path_align = align;
+            let drop = |g: &PositionedGlyph| {
+                let b = g.outline.bounding_box();
+                if ink { (b.y0 + b.y1) * 0.5 - 50.0 } else { g.origin.y - 50.0 }
+            };
+            (align, layout(db, &t).glyphs.iter().map(drop).collect())
+        })
+        .collect()
+}
+
+/// Align to Path moves each glyph's baseline off the path by its own face, size and vertical
+/// scale: Ascender by the top of an em box centered on the cap height, Center by half the height
+/// of the top of the H in whole thousandths of an em, Descender up by the bottom of the font's
+/// bounding box. Without an OS/2 cap height, the em box is centered on the lower of the tops of H
+/// and O; without an H, Center takes half the OS/2 cap height. A face with no cap height and no H
+/// or O takes an em box from 0.12 em below the baseline to 0.88 em above it and, with a bounding
+/// box above the baseline, its descent. Leading and horizontal scale do not count.
+#[test]
+fn on_path_align_runs_each_glyph_by_its_own_metrics() {
+    use crate::test_fonts::{PATH_ALIGN_BARE_FAMILY, PATH_ALIGN_CAPITAL_FAMILY, PATH_ALIGN_LOWER_FAMILY, PATH_ALIGN_ROMAN_FAMILY, path_align_font};
+    use vectorcraft_doc::PathAlign;
+    let db = FontDb::with_font_dirs(vec![]);
+    for family in [PATH_ALIGN_ROMAN_FAMILY, PATH_ALIGN_BARE_FAMILY, PATH_ALIGN_LOWER_FAMILY, PATH_ALIGN_CAPITAL_FAMILY] {
+        db.add_font(path_align_font(family).unwrap());
+    }
+    let bare = db.face(PATH_ALIGN_BARE_FAMILY, "Regular").unwrap();
+    let bare_descent = bare.vertical_metrics().1 / bare.units_per_em();
+    let st = |family: &str, size: f64| CharStyle { font_family: family.into(), ..style(size) };
+    let styles = [
+        st(PATH_ALIGN_ROMAN_FAMILY, 20.0),
+        st(PATH_ALIGN_ROMAN_FAMILY, 40.0),
+        CharStyle { v_scale: 200.0, ..st(PATH_ALIGN_ROMAN_FAMILY, 20.0) },
+        CharStyle { h_scale: 200.0, leading: Some(90.0), ..st(PATH_ALIGN_ROMAN_FAMILY, 20.0) },
+        st(PATH_ALIGN_BARE_FAMILY, 20.0),
+        st(PATH_ALIGN_LOWER_FAMILY, 20.0),
+        st(PATH_ALIGN_CAPITAL_FAMILY, 20.0),
+    ];
+    // Per em: the cap height is 0.66 em, the H 0.656 em tall, the bounding box's bottom -0.295 em;
+    // the lower face's H is 0.668 em tall and its O 0.656 em; the capital face's em box runs from
+    // its `BASE` table's `ideo` at -0.15 em.
+    for (align, drops) in path_align_drops(&db, &styles, false, false) {
+        let (roman, bare, lower, capital) = match align {
+            PathAlign::Baseline => (0.0, 0.0, 0.0, 0.0),
+            PathAlign::Ascender => ((0.66 + 1.0) / 2.0, 0.88, (0.656 + 1.0) / 2.0, 0.85),
+            PathAlign::Center => (0.328, 0.38, 0.334, 0.33),
+            PathAlign::Descender => (-0.295, -bare_descent, -0.295, -0.295),
+        };
+        let want = [roman * 20.0, roman * 40.0, roman * 40.0, roman * 20.0, bare * 20.0, lower * 20.0, capital * 20.0];
+        assert!(drops.len() == 7 && drops.iter().zip(want).all(|(d, w)| (d - w).abs() < 1e-6), "{align:?}: {drops:?}, want {want:?}");
+    }
+}
+
+/// The em box whose top Ascender runs along the path, by the kind of face: a `BASE` table's
+/// ideographic baseline, unless its roman baseline lies below it; in a face with a Chinese,
+/// Japanese or Korean code page, a typographic box that holds the ink of 永 and is one em tall or
+/// leaves margins within 197/65,536 em of each other, else a ┼ one em tall, else an em box
+/// centered on the ink of 永; else 0.88 em. Center measures the H, not the OS/2 cap height (0.7 em
+/// in the heights face).
+#[test]
+fn on_path_align_finds_the_em_box_of_each_kind_of_face() {
+    use crate::test_fonts::{
+        HEIGHT_FAMILY, PATH_ALIGN_BASE_FAMILY, PATH_ALIGN_CROSS_FAMILY, PATH_ALIGN_DAMAGED_FAMILY, PATH_ALIGN_HHEA_FAMILY,
+        PATH_ALIGN_IDEOGRAPH_FAMILY, PATH_ALIGN_MARGINS_FAMILY, PATH_ALIGN_NONE_FAMILY, PATH_ALIGN_TYPO_FAMILY, PATH_ALIGN_UNEVEN_FAMILY,
+        height_font, path_align_font,
+    };
+    use vectorcraft_doc::PathAlign;
+    let db = FontDb::with_font_dirs(vec![]);
+    let families = [
+        PATH_ALIGN_BASE_FAMILY,
+        PATH_ALIGN_IDEOGRAPH_FAMILY,
+        PATH_ALIGN_CROSS_FAMILY,
+        PATH_ALIGN_TYPO_FAMILY,
+        PATH_ALIGN_HHEA_FAMILY,
+        PATH_ALIGN_NONE_FAMILY,
+        PATH_ALIGN_MARGINS_FAMILY,
+        PATH_ALIGN_UNEVEN_FAMILY,
+        PATH_ALIGN_DAMAGED_FAMILY,
+    ];
+    for family in families {
+        db.add_font(path_align_font(family).unwrap());
+    }
+    db.add_font(height_font(true).unwrap());
+    let styles: Vec<CharStyle> = families.iter().chain([&HEIGHT_FAMILY]).map(|f| CharStyle { font_family: (*f).into(), ..style(10.0) }).collect();
+    let drops = path_align_drops(&db, &styles, false, false);
+    let of = |align: PathAlign| drops.iter().find(|(a, _)| *a == align).map(|(_, d)| d.clone()).unwrap();
+    // BASE -150 + one em; Japanese: the ⌠'s ink -51 to 949 centered, the | from -250 to 750, the
+    // typographic box -100 to 900, the `hhea` box -100 to 900 under an empty typographic box,
+    // nothing, the typographic box -101 to 1,002 (margins 3/1,000 em apart), the ink centered
+    // under a box -101 to 1,003 (4/1,000 em apart); a damaged BASE table's face by its cap height
+    // 660; the heights face's BASE `idtp` 880.
+    let want = [0.85, 0.949, 0.75, 0.9, 0.9, 0.88, 1.002, 0.949, 0.83, 0.88].map(|em| em * 10.0);
+    let ascender = of(PathAlign::Ascender);
+    assert!(ascender.len() == 10 && ascender.iter().zip(want).all(|(d, w)| (d - w).abs() < 1e-6), "{ascender:?}, want {want:?}");
+    let center = of(PathAlign::Center);
+    assert!((center[9] - 3.28).abs() < 1e-6, "{center:?}");
+}
+
+/// A variable font's instance takes its em box from the typographic box its `MVAR` table varies:
+/// from -100 to 900 in Regular, from 0 to 1,000 in Bold.
+#[test]
+fn on_path_align_takes_a_variable_font_instances_em_box() {
+    use crate::test_fonts::{PATH_ALIGN_VARIABLE_FAMILY, path_align_font};
+    use vectorcraft_doc::PathAlign;
+    let db = FontDb::with_font_dirs(vec![]);
+    db.add_font(path_align_font(PATH_ALIGN_VARIABLE_FAMILY).unwrap());
+    let st = |font_style: &str| CharStyle { font_family: PATH_ALIGN_VARIABLE_FAMILY.into(), font_style: font_style.into(), ..style(10.0) };
+    let drops = path_align_drops(&db, &[st("Regular"), st("Bold")], false, false);
+    let ascender = drops.iter().find(|(a, _)| *a == PathAlign::Ascender).map(|(_, d)| d.clone()).unwrap();
+    assert!(ascender.len() == 2 && (ascender[0] - 9.0).abs() < 1e-6 && (ascender[1] - 10.0).abs() < 1e-6, "{ascender:?}");
+}
+
+/// In vertical type, Align to Path moves the glyphs half an em, with their horizontal scale and not
+/// their vertical scale, for Ascender and Descender, and leaves them on the path for Center: their
+/// baselines and their drawn outlines both.
+#[test]
+fn on_path_align_in_vertical_type_moves_half_an_em() {
+    use crate::test_fonts::{PATH_ALIGN_ROMAN_FAMILY, path_align_font};
+    use vectorcraft_doc::PathAlign;
+    let db = FontDb::with_font_dirs(vec![]);
+    db.add_font(path_align_font(PATH_ALIGN_ROMAN_FAMILY).unwrap());
+    let st = CharStyle { font_family: PATH_ALIGN_ROMAN_FAMILY.into(), ..style(20.0) };
+    let styles = [st.clone(), CharStyle { h_scale: 200.0, ..st.clone() }, CharStyle { v_scale: 200.0, ..st }];
+    for ink in [false, true] {
+        let baseline = path_align_drops(&db, &styles, true, ink).first().map(|(_, d)| d.clone()).unwrap();
+        for (align, drops) in path_align_drops(&db, &styles, true, ink) {
+            let half = match align {
+                PathAlign::Ascender => 10.0,
+                PathAlign::Descender => -10.0,
+                _ => 0.0,
+            };
+            let want = [half, half * 2.0, half];
+            let moved: Vec<f64> = drops.iter().zip(&baseline).map(|(d, b)| d - b).collect();
+            assert!(moved.len() == 3 && moved.iter().zip(want).all(|(m, w)| (m - w).abs() < 1e-6), "{align:?}, ink {ink}: {moved:?}, want {want:?}");
+        }
+    }
+}
+
 #[test]
 fn on_path_circle_and_overflow() {
     let circle = kurbo::Circle::new((0.0, 0.0), 100.0).to_path(0.1);
diff --git a/crates/text/src/tests/composite.rs b/crates/text/src/tests/composite.rs
new file mode 100644
index 000000000..370fa4557
--- /dev/null
+++ b/crates/text/src/tests/composite.rs
@@ -0,0 +1,196 @@
+//! Composite fonts: each class of character set in its part's font.
+
+use crate::*;
+use vectorcraft_doc::{CharStyle, CompositeFont, TextRun};
+
+/// Base (Kanji) Source Sans 3; Roman in JetBrains Mono at half size, raised by a tenth of the size;
+/// Numerals in Inter, scaled to 80% across; Kana scaled to 50% up from the center.
+fn mixed(name: &str) -> CompositeFont {
+    let mut f = CompositeFont::new(name, "Source Sans 3", "Regular");
+    f.parts.roman.font = "JetBrains Mono".into();
+    f.parts.roman.size = 50.0;
+    f.parts.roman.baseline = 10.0;
+    f.parts.numerals.font = "Inter".into();
+    f.parts.numerals.h_scale = 80.0;
+    f.parts.kana.v_scale = 50.0;
+    f.parts.kana.scale_at_center = true;
+    f
+}
+
+fn style(family: &str, size: f64) -> CharStyle {
+    CharStyle { font_family: family.into(), size, ..CharStyle::default() }
+}
+
+fn face_id(db: &FontDb, family: &str) -> u32 {
+    db.face(family, "Regular").unwrap().id()
+}
+
+/// Each run in a composite font splits where the class changes; a grapheme cluster stays with its
+/// first character, runs in other fonts are kept, and each piece remembers its run.
+#[test]
+fn composite_runs_split_by_class() {
+    let db = FontDb::with_font_dirs(vec![]);
+    db.set_composite_font(&mixed("Mixed"));
+    let mut t = TextObject::point(Point::ZERO, "Ae\u{301}12\u{304B}\u{3099}国", style("Mixed", 20.0));
+    t.runs.insert(0, TextRun::new("x", style("Inter", 12.0)));
+    let (split, from) = db.composite_split(&t).expect("split");
+    let pieces: Vec<(&str, &str)> = split.runs.iter().map(|r| (r.text.as_str(), r.style.font_family.as_str())).collect();
+    assert_eq!(
+        pieces,
+        [("x", "Inter"), ("Ae\u{301}", "JetBrains Mono"), ("12", "Inter"), ("\u{304B}\u{3099}", "Source Sans 3"), ("国", "Source Sans 3")]
+    );
+    assert_eq!(from, [0, 1, 1, 1, 1]);
+    assert_eq!(split.plain_text(), t.plain_text());
+    let roman = &split.runs[1].style;
+    assert_eq!((roman.size, roman.baseline_shift, roman.h_scale, roman.v_scale), (10.0, 2.0, 100.0, 100.0));
+    let numerals = &split.runs[2].style;
+    assert_eq!((numerals.size, numerals.h_scale), (20.0, 80.0));
+    // Kana at half height, raised by half the em box's center so the center stays put.
+    let kana = &split.runs[3].style;
+    let centre = db.face("Source Sans 3", "Regular").unwrap().ideographic_centre();
+    assert_eq!(kana.v_scale, 50.0);
+    assert!((kana.baseline_shift - 20.0 * centre * 0.5).abs() < 1e-9, "{}", kana.baseline_shift);
+    assert_eq!(split.runs[4].style.baseline_shift, 0.0);
+    // Text in no composite font is not split.
+    assert!(db.composite_split(&TextObject::point(Point::ZERO, "Ab", style("Inter", 12.0))).is_none());
+}
+
+/// Laid out, each character is drawn in its class's font, sized by its part, and the glyphs still
+/// name the run of the text they belong to.
+#[test]
+fn composite_type_draws_each_class_in_its_font() {
+    let db = FontDb::with_font_dirs(vec![]);
+    db.set_composite_font(&mixed("Mixed"));
+    let mut t = TextObject::point(Point::ZERO, "x", style("Inter", 12.0));
+    t.runs.push(TextRun::new("A1", style("Mixed", 20.0)));
+    let l = layout(&db, &t);
+    let fonts: Vec<(usize, u32)> = l.glyphs.iter().map(|g| (g.run, g.font_id)).collect();
+    assert_eq!(fonts, [(0, face_id(&db, "Inter")), (1, face_id(&db, "JetBrains Mono")), (1, face_id(&db, "Inter"))]);
+    // `A` is set as JetBrains Mono at 10 pt would set it.
+    let alone = layout(&db, &TextObject::point(Point::ZERO, "A", style("JetBrains Mono", 10.0)));
+    assert!((l.glyphs[1].advance - alone.glyphs[0].advance).abs() < 1e-9);
+}
+
+/// A ruby reading over type in a composite font is set in the parts its own characters fall in.
+#[test]
+fn ruby_over_composite_type_is_set_in_its_own_parts() {
+    let db = FontDb::with_font_dirs(vec![]);
+    db.set_composite_font(&mixed("Ruby Parts"));
+    let mut t = TextObject::point(Point::ZERO, "\u{56FD}", style("Ruby Parts", 20.0));
+    t.ruby = vec![vectorcraft_doc::text::RubySpan::new(0, 3, "A")];
+    let l = layout(&db, &t);
+    let fonts: Vec<u32> = l.ruby.iter().map(|g| g.font_id).collect();
+    assert_eq!(fonts, [face_id(&db, "JetBrains Mono")]);
+    assert_eq!(l.ruby[0].run, 0);
+    // Over a Roman base (a 50% part), the reading is half the 20 pt type, scaled once by its part:
+    // 5 pt, not the base's 10 pt halved twice.
+    let mut t = TextObject::point(Point::ZERO, "A", style("Ruby Parts", 20.0));
+    t.ruby = vec![vectorcraft_doc::text::RubySpan::new(0, 1, "a")];
+    let l = layout(&db, &t);
+    let alone = layout(&db, &TextObject::point(Point::ZERO, "a", style("JetBrains Mono", 5.0)));
+    assert_eq!(l.ruby.len(), 1);
+    // The width each glyph is drawn at, in text space.
+    let width = |g: &crate::PositionedGlyph| {
+        use kurbo::Shape;
+        g.outline.bounding_box().width()
+    };
+    let (reading, expected) = (width(&l.ruby[0]), width(&alone.glyphs[0]));
+    assert!(expected > 0.0 && (reading - expected).abs() < 1e-6, "{reading} vs {expected}");
+    // It sits above the base as drawn (10 pt), not above the 20 pt the text sets it in.
+    let rise = l.glyphs[0].origin.y - l.ruby[0].origin.y;
+    assert!(rise > 8.0 && rise < 15.0, "the reading is {rise} pt above the base's baseline");
+}
+
+/// Lent composite fonts are available while a guard lends them: a second guard lends one again, a
+/// font of the same name the database holds is replaced and put back afterwards, and a font named
+/// like an installed family is not lent.
+#[test]
+fn lent_composite_fonts_last_as_long_as_a_guard() {
+    let db = FontDb::with_font_dirs(vec![]);
+    db.set_composite_font(&mixed("Held"));
+    let mut held = mixed("Held");
+    held.parts.roman.size = 75.0;
+    let fonts = [mixed("Lent"), held, CompositeFont::new("Inter", "Source Sans 3", "Regular")];
+    let first = db.lend_composite_fonts(&fonts);
+    assert!(db.composite_font("lent").is_some());
+    assert_eq!(db.composite_font("Held").unwrap().parts.roman.size, 75.0);
+    assert!(db.composite_font("Inter").is_none());
+    let second = db.lend_composite_fonts(&fonts);
+    drop(first);
+    assert!(db.composite_font("Lent").is_some());
+    assert_eq!(db.composite_font("Held").unwrap().parts.roman.size, 75.0);
+    drop(second);
+    assert!(db.composite_font("Lent").is_none());
+    assert_eq!(db.composite_font("Held").unwrap().parts.roman.size, 50.0);
+    // A font set in its place while lent stays when the guard drops.
+    let lent = db.lend_composite_fonts(&fonts[..1]);
+    let mut replaced = mixed("Lent");
+    replaced.parts.roman.size = 60.0;
+    db.set_composite_font(&replaced);
+    drop(lent);
+    assert_eq!(db.composite_font("Lent").unwrap().parts.roman.size, 60.0);
+    // A guard whose font was removed doesn't give back a later guard's loan of that name.
+    assert!(db.remove_composite_font("Lent"));
+    let old = db.lend_composite_fonts(&fonts[..1]);
+    assert!(db.remove_composite_font("Lent"));
+    let new = db.lend_composite_fonts(&fonts[..1]);
+    drop(old);
+    assert!(db.composite_font("Lent").is_some());
+    drop(new);
+    assert!(db.composite_font("Lent").is_none());
+}
+
+/// The fonts a composite font sets text in are those of the parts its characters fall in, and
+/// coverage is checked against each character's part.
+#[test]
+fn composite_fonts_for_text_follow_each_characters_part() {
+    let db = FontDb::with_font_dirs(vec![]);
+    let mut f = mixed("Parts");
+    f.parts.kana.font = "No Such Kana Font".into();
+    db.set_composite_font(&f);
+    let fonts = |text: &str| db.composite_fonts_for("parts", text).unwrap();
+    let pair = |family: &str| (family.to_string(), "Regular".to_string());
+    assert_eq!(fonts("A1"), [pair("JetBrains Mono"), pair("Inter")]);
+    assert_eq!(fonts(""), [pair("Source Sans 3")]);
+    assert!(db.composite_fonts_for("Inter", "A").is_none());
+    let exact = db.composite_coverage("Parts", &["A1"]).unwrap();
+    assert_eq!((exact.status, exact.lacking.len()), (FontMatch::Exact, 0));
+    let missing = db.composite_coverage("Parts", &["A\u{304B}"]).unwrap();
+    assert_eq!(missing.status, FontMatch::Missing);
+    assert_eq!(missing.face.map(|f| f.family.clone()).as_deref(), Some(FALLBACK_FAMILY));
+    // Each run is split on its own: a combining mark that starts a run is a Roman character.
+    f.parts.kana.font = "Source Sans 3".into();
+    f.parts.roman.font = "No Such Roman Font".into();
+    db.set_composite_font(&f);
+    assert_eq!(db.composite_coverage("Parts", &["\u{304B}\u{301}"]).unwrap().status, FontMatch::Exact);
+    assert_eq!(db.composite_coverage("Parts", &["\u{304B}", "\u{301}"]).unwrap().status, FontMatch::Missing);
+    assert_eq!(db.stored_family("parts", "Regular").as_deref(), Some("Parts"));
+    assert_eq!(db.stored_family("No Such Kana Font", "Regular"), None);
+}
+
+/// A composite font resolves to its base font as an exact match, lists first in the font menus,
+/// and is gone from them once removed.
+#[test]
+fn composite_fonts_resolve_to_their_base_and_list_first() {
+    let db = FontDb::with_font_dirs(vec![]);
+    let generation = db.generation();
+    db.set_composite_font(&mixed("Zeta Mixed"));
+    assert_ne!(db.generation(), generation);
+    let (face, how) = db.resolve("zeta mixed", "Regular").unwrap();
+    assert_eq!((face.family.as_str(), how), ("Source Sans 3", FontMatch::Exact));
+    assert!(db.has_family("Zeta Mixed"));
+    assert_eq!(db.menu_family_list().first().map(String::as_str), Some("Zeta Mixed"));
+    // Registering the same definition again changes nothing.
+    let generation = db.generation();
+    db.set_composite_font(&mixed("Zeta Mixed"));
+    assert_eq!(db.generation(), generation);
+    // A base naming a composite font falls back rather than looping.
+    let mut odd = mixed("Odd");
+    odd.parts.kanji.font = "Zeta Mixed".into();
+    db.set_composite_font(&odd);
+    assert_eq!(db.face("Odd", "Regular").unwrap().family, FALLBACK_FAMILY);
+    assert!(db.remove_composite_font("ZETA MIXED"));
+    assert!(!db.remove_composite_font("Zeta Mixed"));
+    assert!(!db.menu_family_list().iter().any(|f| f == "Zeta Mixed"));
+    assert!(!db.has_family("Zeta Mixed"));
+}
diff --git a/crates/three-d/src/mesh.rs b/crates/three-d/src/mesh.rs
index 04b5db626..45b559f77 100644
--- a/crates/three-d/src/mesh.rs
+++ b/crates/three-d/src/mesh.rs
@@ -72,7 +72,7 @@ pub fn inflate_meshes(
     options: Inflate,
     view: View,
 ) -> impl Iterator<Item = Result<Mesh, String>> + use<> {
-    inflate_faces(shapes, bounds, options, view, true).into_iter().map(|r| r.and_then(|(_, faces)| mesh(&faces)))
+    inflate_faces(shapes, bounds, options, view, true).map(|r| r.and_then(|(_, faces)| mesh(&faces)))
 }
 
 /// Revolve's surface ([`crate::revolve`]) as a mesh. As the effect draws it, a sweep of less than
diff --git a/crates/three-d/src/mesh/tests.rs b/crates/three-d/src/mesh/tests.rs
index 4ee38fe1d..1247926de 100644
--- a/crates/three-d/src/mesh/tests.rs
+++ b/crates/three-d/src/mesh/tests.rs
@@ -262,6 +262,23 @@ fn inflate_puffs_the_front_toward_the_viewer() {
     assert!(hi[2] > 0.0 && lo[2] < hi[2], "the front puffs toward the viewer: {lo:?} {hi:?}");
 }
 
+#[test]
+fn inflate_builds_each_solid_as_it_is_reached() {
+    let (mut a, mut b) = (BezPath::new(), BezPath::new());
+    square(&mut a, 0.0, 0.0, 100.0, false);
+    square(&mut b, 120.0, 0.0, 100.0, false);
+    let ((pa, _), (pb, _)) = (shape(&a), shape(&b));
+    let built = || crate::solid::INFLATED.with(|n| n.get());
+    let start = built();
+    let mut meshes =
+        inflate_meshes(&[(&pa, FillRule::NonZero), (&pb, FillRule::NonZero)], Rect::new(0.0, 0.0, 220.0, 100.0), Inflate::default(), front());
+    assert_eq!(built(), start, "no solid is built before the first mesh is asked for");
+    assert!(meshes.next().is_some_and(|m| m.is_ok_and(|m| !m.is_empty())));
+    assert_eq!(built(), start + 1, "the second solid waits until it is reached");
+    assert!(meshes.next().is_some_and(|m| m.is_ok_and(|m| !m.is_empty())));
+    assert_eq!(built(), start + 2);
+}
+
 #[test]
 fn an_empty_shape_makes_an_empty_mesh() {
     let p = PathData::new(vec![]);
diff --git a/crates/three-d/src/solid.rs b/crates/three-d/src/solid.rs
index 20beda4ec..e51e259c4 100644
--- a/crates/three-d/src/solid.rs
+++ b/crates/three-d/src/solid.rs
@@ -22,6 +22,8 @@ mod rings;
 use build::{Camera, cuts, edge_distance, newell, section};
 pub(crate) use build::{Face3, extrude_faces, plane_faces};
 pub use build::{extrude, plane};
+#[cfg(test)]
+pub(crate) use inflate::INFLATED;
 pub(crate) use inflate::inflate_faces;
 pub use inflate::{inflate, inflate_together};
 #[cfg(test)]
diff --git a/crates/three-d/src/solid/inflate.rs b/crates/three-d/src/solid/inflate.rs
index 40d70a79d..984017593 100644
--- a/crates/three-d/src/solid/inflate.rs
+++ b/crates/three-d/src/solid/inflate.rs
@@ -51,29 +51,42 @@ pub fn inflate(path: &PathData, rule: FillRule, bounds: Rect, options: Inflate,
 /// on its own over the grid of `bounds`, and one eye sees them all, as far away as the highest
 /// puff needs with Perspective. One result for each shape, in order.
 pub fn inflate_together(shapes: &[(&PathData, FillRule)], bounds: Rect, options: Inflate, view: View) -> Vec<Result<Vec<Facet>, String>> {
-    inflate_faces(shapes, bounds, options, view, false).into_iter().map(|r| r.map(|(facets, _)| facets)).collect()
+    inflate_faces(shapes, bounds, options, view, false).map(|r| r.map(|(facets, _)| facets)).collect()
 }
 
 /// [`inflate_together`], or with `mesh` each solid's faces before projection instead of its facets.
-pub(crate) fn inflate_faces(shapes: &[(&PathData, FillRule)], bounds: Rect, options: Inflate, view: View, mesh: bool) -> Vec<Result<Built, String>> {
+/// Every shape's membrane is solved at once (the eye depends on the highest puff); each solid is
+/// built as the iterator reaches it.
+pub(crate) fn inflate_faces(
+    shapes: &[(&PathData, FillRule)],
+    bounds: Rect,
+    options: Inflate,
+    view: View,
+    mesh: bool,
+) -> impl Iterator<Item = Result<Built, String>> + use<> {
     let o = options.sanitized();
     let puffs: Vec<Result<Option<Puff>, String>> =
         shapes.iter().map(|(path, rule)| check_bounds(bounds).and_then(|()| puff(path, *rule, bounds, &o))).collect();
     let reach = puffs.iter().flatten().flatten().map(|p| p.height).fold(0.0, f64::max);
-    puffs
-        .into_iter()
-        .map(|p| match p {
-            Ok(Some(p)) => inflated(p, bounds, o, view, reach, mesh),
-            Ok(None) => Ok((vec![], vec![])),
-            Err(e) => Err(e),
-        })
-        .collect()
+    puffs.into_iter().map(move |p| match p {
+        Ok(Some(p)) => inflated(p, bounds, o, view, reach, mesh),
+        Ok(None) => Ok((vec![], vec![])),
+        Err(e) => Err(e),
+    })
+}
+
+#[cfg(test)]
+thread_local! {
+    /// How many inflated solids this thread has built, for the tests.
+    pub(crate) static INFLATED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
 }
 
 /// The facets of one inflated shape, for a camera that allows for a puff `reach` high (or the
 /// shape's own, if higher): `reach` is the highest puff of the shapes drawn together. With `mesh`,
 /// its faces before projection instead.
 fn inflated(p: Puff, bounds: Rect, o: Inflate, view: View, reach: f64, mesh: bool) -> Result<Built, String> {
+    #[cfg(test)]
+    INFLATED.with(|n| n.set(n.get() + 1));
     let Puff { rings, edges, cell, nx, ny, m, height } = p;
     let outline: Vec<(Rect, vectorcraft_geom::SubPath)> = rings
         .iter()
diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs
index 985f98c34..de227b748 100644
--- a/crates/ui-egui/src/app/commands.rs
+++ b/crates/ui-egui/src/app/commands.rs
@@ -250,7 +250,7 @@ impl VectorcraftApp {
                         let to = &params["to"];
                         to["family"].as_str().and_then(|family| {
                             let style = to["style"].as_str().unwrap_or("Regular");
-                            vectorcraft_text::FontDb::global().resolve(family, style).map(|(face, _)| face.family.clone())
+                            vectorcraft_text::FontDb::global().stored_family(family, style)
                         })
                     }
                     _ => None,
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index f2c123a56..48b9895a6 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -22,6 +22,7 @@ pub mod color_balance;
 pub mod color_guide_options;
 mod color_picker;
 mod command;
+pub mod composite_fonts;
 pub mod confirm;
 pub mod corners;
 pub mod dimension;
@@ -348,6 +349,7 @@ registry! {
     Hyphenation: [hyphenation::KIND] => hyphenation::SPEC,
     Justification: [justification::KIND] => justification::SPEC,
     TateChuYokoSettings: [tate_chu_yoko::KIND] => tate_chu_yoko::SPEC,
+    CompositeFonts: [composite_fonts::KIND] => composite_fonts::SPEC,
     SavePdf: [save_pdf::KIND] => save_pdf::SPEC,
     SvgOptions: [svg_options::KIND] => svg_options::SPEC,
     JavaScriptFiles: [javascript_files::KIND] => javascript_files::SPEC,
diff --git a/crates/ui-egui/src/dialogs/composite_fonts.rs b/crates/ui-egui/src/dialogs/composite_fonts.rs
new file mode 100644
index 000000000..cc71cc32d
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/composite_fonts.rs
@@ -0,0 +1,275 @@
+//! Type › Composite Fonts… (with Show East Asian Options): the active document's composite fonts,
+//! the one picked in Font shown as a table with a row for each class of character (Kanji, Kana,
+//! Punctuation, Symbols, Roman, Numerals) and its font, style, size, baseline and scales. New adds
+//! a font based on the one picked, Delete Font takes it out, Import… adds the fonts of a file and
+//! Export… writes the one picked to a file. Nothing changes in the document until OK, which runs
+//! `type.compositeFonts.set` with every font as one undo step; Cancel leaves them as they were.
+//!
+//! Fields: `fonts` (the composite fonts as `type.compositeFonts.set` takes them), `selected` (the
+//! index of the one picked) and `name` (its name as typed).
+//!
+//! Behavior reference (public documentation):
+//! <https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347>.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::text::{COMPOSITE_BASELINE, COMPOSITE_SCALE, COMPOSITE_SIZE};
+use vectorcraft_doc::{CharClass, CompositeFont, CompositePart};
+use vectorcraft_engine::cmd::compositefonts::EXTS;
+
+use super::{DialogSpec, form};
+use crate::picks::PickRequest;
+use crate::state::Dialog;
+use crate::{FilePick, VectorcraftApp, widgets};
+
+/// The dialog kind of Composite Fonts.
+pub const KIND: &str = "compositeFonts";
+
+/// The command OK runs, and the menu item's.
+pub const COMMAND: &str = "type.compositeFonts.set";
+
+pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Composite Fonts").into(), body, confirm, min_width: 760.0, ..DialogSpec::FORM };
+
+/// Open Composite Fonts on the active document's composite fonts, the first one picked.
+pub fn open(app: &mut VectorcraftApp) -> Result<Value, String> {
+    let fonts = app.session.active().ok_or("no document open")?.doc.composite_fonts.to_vec();
+    let mut d = Dialog::new(KIND, json!({ "fonts": fonts, "selected": 0 }));
+    show_selected(&mut d);
+    app.ui.dialog = Some(d);
+    Ok(Value::Null)
+}
+
+/// The fonts the dialog holds.
+fn fonts(d: &Dialog) -> Vec<CompositeFont> {
+    d.fields.get("fonts").and_then(|v| serde_json::from_value(v.clone()).ok()).unwrap_or_default()
+}
+
+fn put_fonts(d: &mut Dialog, fonts: &[CompositeFont]) {
+    d.fields.insert("fonts".into(), json!(fonts));
+}
+
+/// The index of the font picked, within the fonts (0 when there are none).
+fn selected(d: &Dialog, count: usize) -> usize {
+    d.fields.get("selected").and_then(Value::as_u64).map_or(0, |i| i as usize).min(count.saturating_sub(1))
+}
+
+/// Pick font `i`: its name goes into Name.
+fn select(d: &mut Dialog, i: usize) {
+    d.fields.insert("selected".into(), json!(i));
+    show_selected(d);
+}
+
+fn show_selected(d: &mut Dialog) {
+    let fonts = fonts(d);
+    let name = fonts.get(selected(d, fonts.len())).map(|f| f.name.clone()).unwrap_or_default();
+    d.fields.insert("name".into(), json!(name));
+}
+
+/// The name of a class's row.
+fn class_label(c: CharClass) -> &'static str {
+    match c {
+        CharClass::Kanji => tl!("Kanji"),
+        CharClass::Kana => tl!("Kana"),
+        CharClass::Punctuation => tl!("Punctuation"),
+        CharClass::Symbols => tl!("Symbols"),
+        CharClass::Roman => tl!("Roman"),
+        CharClass::Numerals => tl!("Numerals"),
+    }
+}
+
+/// "Composite Font N", the first N no font in `fonts` and no installed font is named.
+fn new_name(fonts: &[CompositeFont]) -> String {
+    let db = vectorcraft_text::FontDb::global();
+    (1..)
+        .map(|n| format!("Composite Font {n}"))
+        .find(|n| !fonts.iter().any(|f| CompositeFont::same_name(&f.name, n)) && (db.composite_font(n).is_some() || !db.has_family(n)))
+        .unwrap_or_default()
+}
+
+/// What a button asked for, done once the table is drawn.
+enum Action {
+    New,
+    Delete,
+    Import,
+    Export,
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    let mut list = fonts(d);
+    let i = selected(d, list.len());
+    let mut act = None;
+    let names: Vec<&str> = list.iter().map(|f| f.name.as_str()).collect();
+    let pick = FilePick { filters: vec![FilePick::filter("Composite fonts", EXTS)], ..Default::default() };
+    let can_import = crate::picks::can(app, &PickRequest::Open(pick));
+    let mut picked = None;
+    ui.horizontal(|ui| {
+        widgets::dim_label(ui, tl!("Font:"));
+        if names.is_empty() {
+            widgets::dim_label(ui, tl!("None"));
+        } else if let Some(k) = widgets::dropdown_names(ui, "composite-fonts-font", names.get(i).copied().unwrap_or_default(), &names, 220.0) {
+            picked = Some(k);
+        }
+        ui.add_space(8.0);
+        ui.spacing_mut().item_spacing.x = 4.0;
+        if widgets::flat_button(ui, tl!("New"), 48.0).clicked() {
+            act = Some(Action::New);
+        }
+        if ui.add_enabled_ui(!list.is_empty(), |ui| widgets::flat_button(ui, tl!("Delete Font"), 84.0)).inner.clicked() {
+            act = Some(Action::Delete);
+        }
+        if can_import && widgets::flat_button(ui, tl!("Import…"), 64.0).clicked() {
+            act = Some(Action::Import);
+        }
+        if ui.add_enabled_ui(!list.is_empty(), |ui| widgets::flat_button(ui, tl!("Export…"), 64.0)).inner.clicked() {
+            act = Some(Action::Export);
+        }
+    });
+    if let Some(k) = picked {
+        select(d, k);
+        return false;
+    }
+    ui.add_space(8.0);
+    if let Some(f) = list.get_mut(i) {
+        ui.horizontal(|ui| {
+            widgets::dim_label(ui, tl!("Name:"));
+            form::text(ui, d, "name", 260.0);
+        });
+        f.name = d.str("name");
+        ui.add_space(8.0);
+        parts_table(app, ui, f);
+    }
+    put_fonts(d, &list);
+    if let Some(a) = act {
+        // Import…'s file dialog, shown off the UI thread, imports into the dialog as it is then.
+        let r = match a {
+            Action::Import => crate::picks::in_dialog(app, d, |app, d| run(app, d, Action::Import)),
+            a => run(app, d, a),
+        };
+        if let Err(e) = r {
+            app.status(e);
+        }
+    }
+    false
+}
+
+/// Do what button `act` asks for on the dialog's fonts.
+fn run(app: &mut VectorcraftApp, d: &mut Dialog, act: Action) -> Result<(), String> {
+    let mut list = fonts(d);
+    let i = selected(d, list.len());
+    match act {
+        Action::New => {
+            let mut f = list.get(i).cloned().unwrap_or_else(|| {
+                let st = vectorcraft_doc::CharStyle::default();
+                CompositeFont::new("", st.font_family, st.font_style)
+            });
+            f.name = new_name(&list);
+            list.push(f);
+            put_fonts(d, &list);
+            select(d, list.len() - 1);
+        }
+        Action::Delete => {
+            if i < list.len() {
+                list.remove(i);
+            }
+            put_fonts(d, &list);
+            select(d, i.min(list.len().saturating_sub(1)));
+        }
+        Action::Import => import(app, d)?,
+        Action::Export => {
+            let f = list.get(i).ok_or("no composite font")?;
+            crate::io::save_command_output(app, "type.compositeFonts.export", EXTS[0], json!({ "fonts": [f] }))?;
+        }
+    }
+    Ok(())
+}
+
+/// The table of `f`'s parts: a row for each class with its font, style, size, baseline, scales and
+/// (Kana) Scale at Center; the values a class can't take are not shown.
+fn parts_table(app: &VectorcraftApp, ui: &mut egui::Ui, f: &mut CompositeFont) {
+    let db = vectorcraft_text::FontDb::global();
+    egui::Grid::new("composite-fonts-parts").num_columns(8).spacing([8.0, 6.0]).show(ui, |ui| {
+        for h in ["", tl!("Font"), tl!("Style"), tl!("Size"), tl!("Baseline"), tl!("Horizontal Scale"), tl!("Vertical Scale"), ""] {
+            widgets::dim_label(ui, h);
+        }
+        ui.end_row();
+        for class in CharClass::ALL {
+            let p: &mut CompositePart = f.parts.get_mut(class);
+            ui.label(class_label(class));
+            let id = ("composite-font", class.key());
+            if let Some(crate::font_menu::FontPick::Chosen(family, style)) =
+                crate::font_menu::font_menu(ui, id, &p.font, 190.0, None, crate::font_menu::MenuLook::of(app))
+                && db.composite_font(&family).is_none()
+            {
+                p.style = style.unwrap_or_else(|| db.styles(&family).first().cloned().unwrap_or_else(|| "Regular".into()));
+                p.font = family;
+            }
+            let styles = db.styles(&p.font);
+            let style_names: Vec<&str> = styles.iter().map(String::as_str).collect();
+            if let Some(k) = widgets::dropdown_names(ui, ("composite-font-style", class.key()), &p.style, &style_names, 120.0)
+                && let Some(s) = styles.get(k)
+            {
+                p.style.clone_from(s);
+            }
+            let percent = |ui: &mut egui::Ui, key: &str, v: &mut f64, range: &std::ops::RangeInclusive<f64>| {
+                if let Some(n) = widgets::range_field(ui, ("composite-font", class.key(), key), *v, range.clone(), "%", 1, 64.0) {
+                    *v = n;
+                }
+            };
+            percent(ui, "size", &mut p.size, &COMPOSITE_SIZE);
+            percent(ui, "baseline", &mut p.baseline, &COMPOSITE_BASELINE);
+            if class.scales() {
+                percent(ui, "hScale", &mut p.h_scale, &COMPOSITE_SCALE);
+                percent(ui, "vScale", &mut p.v_scale, &COMPOSITE_SCALE);
+            } else {
+                ui.label("");
+                ui.label("");
+            }
+            if class == CharClass::Kana {
+                ui.checkbox(&mut p.scale_at_center, tl!("Scale at Center"));
+            } else {
+                ui.label("");
+            }
+            ui.end_row();
+        }
+    });
+}
+
+/// Import…: the fonts of a picked file join those in the dialog, a font of the same name replaced,
+/// and the first of them is picked.
+fn import(app: &mut VectorcraftApp, d: &mut Dialog) -> Result<(), String> {
+    let pick = FilePick { filters: vec![FilePick::filter("Composite fonts", EXTS)], ..Default::default() };
+    let path = crate::picks::open(app, &pick).ok_or("cancelled")?;
+    let r = app.run("type.compositeFonts.import", json!({ "path": path, "apply": false }))?;
+    let read: Vec<CompositeFont> = serde_json::from_value(r["fonts"].clone()).map_err(|e| e.to_string())?;
+    let mut list = fonts(d);
+    let mut first = None;
+    for f in read {
+        let at = match list.iter_mut().enumerate().find(|(_, g)| CompositeFont::same_name(&g.name, &f.name)) {
+            Some((k, g)) => {
+                *g = f;
+                k
+            }
+            None => {
+                list.push(f);
+                list.len() - 1
+            }
+        };
+        first.get_or_insert(at);
+    }
+    put_fonts(d, &list);
+    if let Some(k) = first {
+        select(d, k);
+    }
+    Ok(())
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let r = app.run(COMMAND, json!({ "fonts": fonts(d) }));
+    // A name two fonts share, or a value out of range, keeps the dialog open to be changed.
+    if r.is_ok() {
+        app.ui.dialog = None;
+    }
+    r
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ui-egui/src/dialogs/composite_fonts/tests.rs b/crates/ui-egui/src/dialogs/composite_fonts/tests.rs
new file mode 100644
index 000000000..64a031e04
--- /dev/null
+++ b/crates/ui-egui/src/dialogs/composite_fonts/tests.rs
@@ -0,0 +1,174 @@
+use serde_json::{Value, json};
+use vectorcraft_engine::Session;
+
+use super::*;
+
+fn app() -> VectorcraftApp {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
+    app
+}
+
+fn frame(app: &mut VectorcraftApp) {
+    let ctx = egui::Context::default();
+    crate::theme::install_fonts(&ctx);
+    let mut out = ctx.run_ui(egui::RawInput::default(), |ui| super::super::show(app, ui.ctx()));
+    out.textures_delta.clear();
+}
+
+fn dialog(app: &mut VectorcraftApp) -> &mut Dialog {
+    app.ui.dialog.as_mut().expect("Composite Fonts open")
+}
+
+fn names(app: &VectorcraftApp) -> Vec<String> {
+    app.session.active().unwrap().doc.composite_fonts.iter().map(|f| f.name.clone()).collect()
+}
+
+fn steps(app: &VectorcraftApp) -> usize {
+    app.session.active().unwrap().history.undo.len()
+}
+
+/// Do `act` with the dialog as it is, as its button does.
+fn press(app: &mut VectorcraftApp, act: Action) {
+    let mut d = app.ui.dialog.clone().unwrap();
+    run(app, &mut d, act).unwrap();
+    app.ui.dialog = Some(d);
+}
+
+/// Type › Composite Fonts… opens on the document's fonts; New adds one, its parts edited in the
+/// table; nothing changes until OK, which sets them as one undo step; Cancel leaves them.
+#[test]
+fn composite_fonts_change_on_ok_as_one_undo_step() {
+    let mut app = app();
+    crate::menus::invoke(&mut app, COMMAND, json!({}));
+    assert_eq!(dialog(&mut app).kind, KIND);
+    frame(&mut app);
+    press(&mut app, Action::New);
+    frame(&mut app);
+    let d = dialog(&mut app);
+    assert_eq!(d.str("name"), "Composite Font 1");
+    let mut list = fonts(d);
+    list[0].parts.roman.font = "JetBrains Mono".into();
+    list[0].parts.roman.size = 80.0;
+    list[0].parts.kana.scale_at_center = true;
+    put_fonts(d, &list);
+    d.fields.insert("name".into(), json!("UI Composite A"));
+    frame(&mut app);
+    assert!(names(&app).is_empty());
+    let before = steps(&app);
+    super::super::confirm(&mut app).unwrap();
+    assert!(app.ui.dialog.is_none());
+    assert_eq!(names(&app), ["UI Composite A"]);
+    assert_eq!(steps(&app), before + 1);
+    let f = &app.session.active().unwrap().doc.composite_fonts[0];
+    assert_eq!((f.parts.roman.font.as_str(), f.parts.roman.size, f.parts.kana.scale_at_center), ("JetBrains Mono", 80.0, true));
+    // OK with nothing changed adds no step; Cancel leaves the fonts.
+    open(&mut app).unwrap();
+    super::super::confirm(&mut app).unwrap();
+    assert_eq!(steps(&app), before + 1);
+    open(&mut app).unwrap();
+    press(&mut app, Action::Delete);
+    super::super::cancel(&mut app);
+    assert_eq!(names(&app), ["UI Composite A"]);
+    // Delete Font and OK takes it out.
+    open(&mut app).unwrap();
+    press(&mut app, Action::Delete);
+    assert_eq!(dialog(&mut app).str("name"), "");
+    frame(&mut app);
+    super::super::confirm(&mut app).unwrap();
+    assert!(names(&app).is_empty());
+}
+
+/// New is based on the font picked and takes the next free name; a name two fonts share, or one
+/// left empty, keeps the dialog open and changes nothing.
+#[test]
+fn shared_or_empty_names_keep_the_dialog_open() {
+    let mut app = app();
+    open(&mut app).unwrap();
+    press(&mut app, Action::New);
+    let d = dialog(&mut app);
+    let mut list = fonts(d);
+    list[0].parts.numerals.font = "Inter".into();
+    put_fonts(d, &list);
+    press(&mut app, Action::New);
+    let list = fonts(dialog(&mut app));
+    assert_eq!(list.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["Composite Font 1", "Composite Font 2"]);
+    assert_eq!(list[1].parts.numerals.font, "Inter");
+    for bad in ["composite font 1", "  "] {
+        dialog(&mut app).fields.insert("name".into(), json!(bad));
+        frame(&mut app);
+        assert!(super::super::confirm(&mut app).is_err(), "{bad:?}");
+        assert!(app.ui.dialog.is_some());
+        assert!(names(&app).is_empty());
+    }
+    dialog(&mut app).fields.insert("name".into(), json!("UI Composite B"));
+    frame(&mut app);
+    super::super::confirm(&mut app).unwrap();
+    assert_eq!(names(&app), ["Composite Font 1", "UI Composite B"]);
+}
+
+/// The menu item shows only with Show East Asian Options on, and needs a document.
+#[test]
+fn the_menu_item_shows_with_east_asian_options() {
+    let mut app = VectorcraftApp::new(Session::new(), Default::default());
+    app.session.prefs.show_east_asian_options = true;
+    assert_eq!(crate::menus::shown_state(&app, COMMAND, &json!({})).map(|s| s.0), Some(false));
+    app.run("file.new", json!({})).unwrap();
+    assert_eq!(crate::menus::shown_state(&app, COMMAND, &json!({})).map(|s| s.0), Some(true));
+    app.session.prefs.show_east_asian_options = false;
+    assert_eq!(crate::menus::shown_state(&app, COMMAND, &json!({})), None);
+}
+
+/// Export… writes the font picked to a file; Import… adds the fonts of a file to the dialog's,
+/// replacing one of the same name, and opening the file adds them to the document.
+#[test]
+fn composite_fonts_go_through_files() {
+    let dir = std::env::temp_dir().join(format!("vc-composite-fonts-ui-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let file = dir.join("fonts.vccomposite").to_string_lossy().to_string();
+    let (saved, picked) = (file.clone(), file.clone());
+    let services = crate::Services {
+        pick_save: Some(Box::new(move |_: &FilePick| Some(saved.clone()))),
+        pick_open: Some(Box::new(move |_: &FilePick| Some(picked.clone()))),
+        write: Some(Box::new(|p: &str, b: &[u8]| std::fs::write(p, b).map_err(|e| e.to_string()))),
+        ..Default::default()
+    };
+    let mut app = VectorcraftApp::new(Session::new(), services);
+    app.run("file.new", json!({})).unwrap();
+    open(&mut app).unwrap();
+    press(&mut app, Action::New);
+    let d = dialog(&mut app);
+    let mut list = fonts(d);
+    list[0].name = "UI Composite IO".into();
+    list[0].parts.roman.baseline = -12.0;
+    put_fonts(d, &list);
+    press(&mut app, Action::Export);
+    assert!(std::fs::read_to_string(&file).unwrap().contains("UI Composite IO"));
+    // Import into the dialog: the same name is replaced, not added.
+    let d = dialog(&mut app);
+    let mut list = fonts(d);
+    list[0].parts.roman.baseline = 0.0;
+    put_fonts(d, &list);
+    press(&mut app, Action::Import);
+    let list = fonts(dialog(&mut app));
+    assert_eq!((list.len(), list[0].parts.roman.baseline), (1, -12.0));
+    super::super::cancel(&mut app);
+    assert!(names(&app).is_empty());
+    // Opening the file adds its fonts to the document.
+    let bytes = std::fs::read(&file).unwrap();
+    crate::io::open_bytes(&mut app, &file, &bytes, Some(file.clone())).unwrap();
+    assert_eq!(names(&app), ["UI Composite IO"]);
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+/// The dialog lists the fonts and draws its table without a document font picked too.
+#[test]
+fn the_dialog_draws_with_and_without_fonts() {
+    let mut app = app();
+    open(&mut app).unwrap();
+    frame(&mut app);
+    assert_eq!(dialog(&mut app).fields.get("fonts"), Some(&Value::Array(vec![])));
+    press(&mut app, Action::New);
+    frame(&mut app);
+    assert_eq!(fonts(dialog(&mut app)).len(), 1);
+}
diff --git a/crates/ui-egui/src/dialogs/shortcut_import.rs b/crates/ui-egui/src/dialogs/shortcut_import.rs
index 00ae1abe7..051669523 100644
--- a/crates/ui-egui/src/dialogs/shortcut_import.rs
+++ b/crates/ui-egui/src/dialogs/shortcut_import.rs
@@ -19,7 +19,7 @@
 //! at first when a code is not known), and `__query` and `__attention` (the filter of the rows shown).
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::sync::OnceLock;
+use std::sync::{Arc, Mutex};
 
 use craft_keymap::import::namematch::{Candidate, Matcher, Proposal};
 use craft_keymap::import::{MAX_IMPORT_TEXT, MAX_PATH_SEGMENTS};
@@ -363,10 +363,12 @@ fn single_key(chord: &str) -> bool {
 }
 
 /// What a name can stand for: Keyboard Shortcuts' entries, by their English labels and the labels in
-/// the interface language.
+/// the interface language. A filter plug-in's row is left out: a row of the file reaches it only
+/// when the user picks it as the target.
 pub fn candidates() -> Vec<Candidate> {
     shortcut_editor::entries()
         .iter()
+        .filter(|e| !e.key.starts_with("plugin:"))
         .map(|e| {
             let shown = tl!(&e.label);
             let labels = if shown == e.label { vec![e.label.clone()] } else { vec![e.label.clone(), shown.to_string()] };
@@ -375,10 +377,17 @@ pub fn candidates() -> Vec<Candidate> {
         .collect()
 }
 
-/// Keyboard Shortcuts' entry `key`.
-fn entry(key: &str) -> Option<&'static Entry> {
-    static BY_KEY: OnceLock<HashMap<&'static str, &'static Entry>> = OnceLock::new();
-    BY_KEY.get_or_init(|| shortcut_editor::entries().iter().map(|e| (e.key.as_str(), e)).collect()).get(key).copied()
+/// Keyboard Shortcuts' entry `key`, among the entries for the plug-ins installed now.
+fn entry(key: &str) -> Option<Entry> {
+    type Index = (Arc<[Entry]>, HashMap<String, usize>);
+    static BY_KEY: Mutex<Option<Index>> = Mutex::new(None);
+    let entries = shortcut_editor::entries();
+    let mut by = BY_KEY.lock().unwrap_or_else(|e| e.into_inner());
+    if by.as_ref().is_none_or(|(e, _)| !Arc::ptr_eq(e, &entries)) {
+        let index = entries.iter().enumerate().map(|(i, e)| (e.key.clone(), i)).collect();
+        *by = Some((entries, index));
+    }
+    by.as_ref().and_then(|(e, index)| index.get(key).and_then(|&i| e.get(i)).cloned())
 }
 
 /// A tool, command or panel that Keyboard Shortcuts can give a shortcut.
@@ -388,7 +397,7 @@ fn known(key: &str) -> bool {
 
 /// How Keyboard Shortcuts names entry `e`: a tool by its label, the others after their menu.
 fn shown(e: &Entry) -> String {
-    if e.is_tool || e.group.is_empty() { tl!(&e.label).to_string() } else { format!("{} › {}", tl!(&e.group), tl!(&e.label)) }
+    shortcut_editor::shown_name(e)
 }
 
 /// What a row's target shows.
@@ -396,7 +405,7 @@ fn target_label(target: Option<&str>) -> String {
     match target {
         None => tl!("Choose…").to_string(),
         Some("") => tl!("No equivalent").to_string(),
-        Some(t) => entry(t).map_or_else(|| t.to_string(), shown),
+        Some(t) => entry(t).map_or_else(|| t.to_string(), |e| shown(&e)),
     }
 }
 
@@ -934,6 +943,7 @@ pub(super) fn target_picker(ui: &mut egui::Ui, i: usize, r: &Row) -> Option<Stri
     let option = |ui: &mut egui::Ui, key: &str, label: &str| {
         ui.add(egui::Button::selectable(r.target.as_deref() == Some(key), label)).clicked().then(|| key.to_string())
     };
+    let all = shortcut_editor::entries();
     widgets::combo_menu(ui, ("shortcut-import-target", i), &current, TARGET_W, |menu| {
         menu.height(height).show_rows_with_header(
             |ui| {
@@ -946,12 +956,12 @@ pub(super) fn target_picker(ui: &mut egui::Ui, i: usize, r: &Row) -> Option<Stri
                 let mut picked = option(ui, "", tl!("No equivalent"));
                 let list: Vec<&Entry> = if q.is_empty() {
                     for e in r.choices.iter().filter_map(|c| entry(c)) {
-                        picked = option(ui, &e.key, &shown(e)).or(picked);
+                        picked = option(ui, &e.key, &shown(&e)).or(picked);
                     }
                     ui.separator();
-                    shortcut_editor::entries().iter().collect()
+                    all.iter().collect()
                 } else {
-                    shortcut_editor::entries().iter().filter(|e| shown(e).to_lowercase().contains(&q) || e.key.to_lowercase().contains(&q)).collect()
+                    all.iter().filter(|e| shown(e).to_lowercase().contains(&q) || e.key.to_lowercase().contains(&q)).collect()
                 };
                 ui.data_mut(|d| d.insert_temp(header_id, ui.min_rect().height()));
                 (list, picked)
diff --git a/crates/ui-egui/src/dialogs/tests_shortcut_import.rs b/crates/ui-egui/src/dialogs/tests_shortcut_import.rs
index 77842ec8d..066f7f468 100644
--- a/crates/ui-egui/src/dialogs/tests_shortcut_import.rs
+++ b/crates/ui-egui/src/dialogs/tests_shortcut_import.rs
@@ -596,6 +596,30 @@ fn long_names_match_and_apply() {
     assert_eq!((out["applied"].clone(), ov), (json!(1), json!({"edit.copy": "Cmd+Alt+Shift+F11"})));
 }
 
+/// A filter plug-in's row takes an imported shortcut when the user picks it, stored under its
+/// `plugin.dialog {id}` key. A file's row with the plug-in's name does not match it by itself, and
+/// a removed plug-in is not a target.
+#[test]
+fn an_imported_shortcut_reaches_a_filter_plugin_picked_as_its_target() {
+    use vectorcraft_plugins::wat as tpl;
+    let id = "test.UI.import_filter-one";
+    let key = format!("plugin:{id}");
+    let manifest = format!(r#"{{"id":"{id}","name":"Acme Import Filter","version":"1","kind":"filter","params":{{}}}}"#);
+    vectorcraft_plugins::registry::install_bytes(&wat::parse_str(tpl::returning(&manifest, r#"{"objects":[]}"#)).unwrap()).unwrap();
+    assert!(shortcut_editor::entry(&key).is_some(), "a target the picker lists");
+    assert!(super::shortcut_import::candidates().iter().all(|c| c.id != key), "a name alone does not match it");
+
+    let mut app = app();
+    let (out, ov) = apply_rows(&mut app, "defaults", &[("Anything", "Menus", &key, "Cmd+Alt+Shift+F11")]);
+    assert_eq!(out["applied"], 1);
+    assert_eq!(ov, json!({ key.as_str(): "Cmd+Alt+Shift+F11" }), "not a binding of plugin.dialog without its id");
+    let reloaded = crate::keymap::stored::from_value(ov);
+    assert_eq!(reloaded.get(&crate::keymap::stored_key(&key)).map(<[String]>::len), Some(1), "read back under the filter's id");
+
+    vectorcraft_plugins::registry::remove(id);
+    assert!(shortcut_editor::entries().iter().all(|e| e.key != key), "a removed filter is no target");
+}
+
 /// A search in a row's target picker that matches nothing shrinks its menu to the search field
 /// and "No equivalent"; clearing the search lists every entry again, and the menu grows back to
 /// its height before the search (egui#5225). The search field stays where it was throughout.
diff --git a/crates/ui-egui/src/find_font.rs b/crates/ui-egui/src/find_font.rs
index d63905e48..0c17c6e92 100644
--- a/crates/ui-egui/src/find_font.rs
+++ b/crates/ui-egui/src/find_font.rs
@@ -1087,7 +1087,8 @@ mod tests {
         let system = replacement_rows(&app, "system", &used);
         assert!(system.iter().any(|r| r.family == "Source Sans 3" && r.style == "Regular"), "{system:?}");
         assert!(!system.iter().any(|r| r.family.starts_with('.')), "the font menu's hidden families stay out");
-        assert!(system.iter().all(|r| !r.style.is_empty()), "no nameless rows: {system:?}");
+        // A composite font is a family without styles of its own, listed by its name alone.
+        assert!(system.iter().all(|r| !r.style.is_empty() || db.styles(&r.family).is_empty()), "no nameless rows: {system:?}");
         let menu = db.menu_family_list();
         let listed: std::collections::BTreeSet<&str> = system.iter().map(|r| r.family.as_str()).collect();
         assert_eq!(listed.len(), menu.len(), "every family the font menu shows is listed");
diff --git a/crates/ui-egui/src/i18n/bg.tsv b/crates/ui-egui/src/i18n/bg.tsv
index d9536d7a0..75f2637a4 100644
--- a/crates/ui-egui/src/i18n/bg.tsv
+++ b/crates/ui-egui/src/i18n/bg.tsv
@@ -3375,6 +3375,15 @@ digits	Malayalam	Малаялам
 	Tate-chu-yoko	Тате-чу-йоко
 	Tate-chu-yoko Settings…	Настройки на Тате-чу-йоко…
 	Tate-chu-yoko Settings	Настройки на Тате-чу-йоко
+	Composite Fonts…	Съставни шрифтове…
+	Composite Fonts	Съставни шрифтове
+	Export Composite Fonts	Експортиране на съставни шрифтове
+	Import Composite Fonts	Импортиране на съставни шрифтове
+	Delete Font	Изтриване на шрифт
+	Kanji	Канджи
+	Kana	Кана
+	Numerals	Цифри
+	Scale at Center	Мащабиране от центъра
 	Up/Down:	Нагоре/надолу:
 	Left/Right:	Наляво/надясно:
 	Temperature	Температура
@@ -4580,6 +4589,7 @@ axis	Both	И двете
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	градиентът „{name}“ не е дефиниран във файла: заменен е с обикновен цвят
 @msg	an image VectorCraft can't read was left out	изображение, което VectorCraft не може да разчете, беше пропуснато
 @msg	an image whose data is cut short was left out	изображение с непълни данни беше пропуснато
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	вградено изображение от {_1} × {_2} пиксела беше намалено до {_3} × {_4} пиксела, за да се запазят слоевете
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	свързаните картини показват записания във файла предварителен преглед с ниска резолюция, докато файловете им бъдат намерени: презакачете ги в панела „Връзки“
 @msg	linked type areas past VectorCraft's limits were left out	свързаните текстови области извън ограниченията на VectorCraft бяха пропуснати
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, който сменя посоката на писане в рамките на текстов обект, се отваря в посоката на първия си знак
@@ -4656,6 +4666,7 @@ axis	Both	И двете
 @msg	object ids are non-negative integers, not {v}	идентификаторите на обектите са неотрицателни цели числа, а не {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} трябва да бъде масив от идентификатори на обекти, които са неотрицателни цели числа
 @msg	invalid object id {value}: expected a non-negative integer	невалиден идентификатор на обект {value}: очаква се неотрицателно цяло число
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	елемент {index} на `{key}` е {value}, а не идентификатор на обект (неотрицателно цяло число)
 @msg	no such object id {value}	няма обект с идентификатор {value}
 @msg	automation filesystem access is not granted: read authority is absent: {path}	достъпът на автоматизацията до файловата система не е разрешен: липсва право за четене: {path}
 @msg	automation filesystem access is not granted: write authority is absent: {path}	достъпът на автоматизацията до файловата система не е разрешен: липсва право за запис: {path}
@@ -5729,6 +5740,8 @@ axis	Y Axis	Y ос
 	Install “{name}”, which asks for these permissions?	Да се инсталира ли „{name}“, който иска тези права?
 	ID: {id}	ID: {id}
 	Version: {version}	Версия: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Да се инсталира ли „{name}“ на мястото на приставката със същия ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Този файл не е приставката, инсталирана преди с този ID. Той получава настройките и кеша, пазени за този ID.
 	File SHA-256: {hash}	SHA-256 на файла: {hash}
 	Read the objects it is given	Четене на обектите, които получава
 	Change, add and delete objects in the document	Промяна, добавяне и изтриване на обекти в документа
@@ -5736,6 +5749,9 @@ axis	Y Axis	Y ос
 	Change how the objects its effect is applied to are drawn	Промяна на начина, по който се рисуват обектите, към които е приложен ефектът му
 	Write the document as a file in its own format	Записване на документа като файл в собствен формат
 	Show its progress, see Cancel and write log lines	Показване на напредъка, разпознаване на отказ и записване на редове в дневника
+	Keep settings of its own	Съхраняване на собствени настройки
+	Keep a cache of its own, which you can clear	Съхраняване на собствен кеш, който можете да изчистите
+	Clear Plug-in Cache	Изчистване на кеша на добавката
 # Actions panel: action sets (#3712).
 	New Set…	Нов набор…
 	New Set	Нов набор
diff --git a/crates/ui-egui/src/i18n/bs.tsv b/crates/ui-egui/src/i18n/bs.tsv
index ce486cb67..4eadaff15 100644
--- a/crates/ui-egui/src/i18n/bs.tsv
+++ b/crates/ui-egui/src/i18n/bs.tsv
@@ -1501,6 +1501,15 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Postavke za Tate-chu-yoko…
 	Tate-chu-yoko Settings	Postavke za Tate-chu-yoko
+	Composite Fonts…	Kompozitni fontovi…
+	Composite Fonts	Kompozitni fontovi
+	Export Composite Fonts	Izvezi kompozitne fontove
+	Import Composite Fonts	Uvezi kompozitne fontove
+	Delete Font	Izbriši font
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Brojevi
+	Scale at Center	Skaliraj od centra
 	Up/Down:	Gore/dolje:
 	Left/Right:	Lijevo/desno:
 	Underline	Podvučeno
@@ -4978,6 +4987,7 @@ imageTrace	Outline	Obris
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	gradijent „{name}” nije definisan u datoteci: umjesto njega koristi se obična boja
 @msg	an image VectorCraft can't read was left out	izostavljena je slika koju VectorCraft ne može pročitati
 @msg	an image whose data is cut short was left out	izostavljena je slika čiji su podaci skraćeni
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	ugrađena slika od {_1} × {_2} piksela smanjena je na {_3} × {_4} piksela kako bi se zadržali slojevi
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	povezane slike prikazuju pregled niske rezolucije sačuvan u datoteci dok se njihove datoteke ne pronađu: ponovo ih povežite u panelu Veze
 @msg	linked type areas past VectorCraft's limits were left out	povezana područja teksta izvan ograničenja programa VectorCraft su izostavljena
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst koji mijenja smjer pisanja unutar tekstualnog objekta otvara se u smjeru svog prvog znaka
@@ -5013,6 +5023,7 @@ imageTrace	Outline	Obris
 @msg	object ids are non-negative integers, not {v}	ID-ovi objekata su nenegativni cijeli brojevi, a ne {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} mora biti niz nenegativnih cjelobrojnih ID-ova objekata
 @msg	invalid object id {value}: expected a non-negative integer	nevažeći ID objekta {value}: očekuje se nenegativan cijeli broj
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	stavka {index} u `{key}` je {value}, a ne ID objekta (nenegativan cijeli broj)
 @msg	no such object id {value}	nema objekta s ID-om {value}
 @msg	id {value} is a layer, not an object	id {value} je sloj, a ne objekat
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} je sloj, a ne objekat; slojeve pomjerajte s layer.move
@@ -5752,6 +5763,9 @@ axis	Y Axis	Y osa
 	Install “{name}”, which asks for these permissions?	Instalirati „{name}”, koji traži ove dozvole?
 	ID: {id}	ID: {id}
 	Version: {version}	Verzija: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Instalirati „{name}” umjesto dodatka s istim ID-om?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Ova datoteka nije dodatak ranije instaliran s ovim ID-om. Dobija postavke i predmemoriju sačuvane za taj ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	„{name}” je drugi modul od dodatka s ID-om {_1} i dobio bi postavke i predmemoriju sačuvane za njega: instalirajte ga s `replace: true` kada korisnik pristane
 	File SHA-256: {hash}	SHA-256 datoteke: {hash}
 	Read the objects it is given	Čitati objekte koje dobije
 	Change, add and delete objects in the document	Mijenjati, dodavati i brisati objekte u dokumentu
@@ -5759,10 +5773,13 @@ axis	Y Axis	Y osa
 	Change how the objects its effect is applied to are drawn	Mijenjati kako se crtaju objekti na koje je primijenjen njegov efekt
 	Write the document as a file in its own format	Zapisati dokument kao datoteku u vlastitom formatu
 	Show its progress, see Cancel and write log lines	Prikazati napredak, prepoznati otkazivanje i zapisivati redove dnevnika
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	dozvola `progress` zahtijeva nivo API-ja dodataka {PROGRESS_API}: navedite `api` {PROGRESS_API}
+	Keep settings of its own	Čuvati vlastite postavke
+	Keep a cache of its own, which you can clear	Čuvati vlastitu predmemoriju koju možete očistiti
+	Clear Plug-in Cache	Očisti predmemoriju dodatka
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	dozvola `{permission}` zahtijeva nivo API-ja dodataka {PROGRESS_API}: navedite `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	modul uvozi `env.{name}` s drugim tipom od domaćinovog: domaćinov tip je {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	modul uvozi `env.{name}`, koji dodatak smije koristiti samo na nivou API-ja dodataka {PROGRESS_API} (`api` {PROGRESS_API}) i s dozvolom `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	modul uvozi `{from}.{name}`, koji domaćin ne nudi: dodatak smije uvoziti samo `env.vc_progress`, `env.vc_cancelled` i `env.vc_log` (nivo API-ja dodataka 2), a nikakav WASI, datoteke ni mrežu
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	modul uvozi `env.{name}`, koji dodatak smije koristiti samo na nivou API-ja dodataka {PROGRESS_API} (`api` {PROGRESS_API}) i s dozvolom `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	modul uvozi `{from}.{name}`, koji domaćin ne nudi: dodatak smije uvoziti samo funkcije `env.vc_*` koje navodi docs/plugins.md (nivo API-ja dodataka 2), a nikakav WASI, datoteke ni mrežu
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` je {_1}; ovaj domaćin podržava nivoe API-ja dodataka od 1 do {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` mora biti lista naziva dozvola
 @msg	`grant` names an unknown permission `{shown}`	`grant` navodi nepoznatu dozvolu `{shown}`
diff --git a/crates/ui-egui/src/i18n/ca.tsv b/crates/ui-egui/src/i18n/ca.tsv
index b2b88879c..d598de47b 100644
--- a/crates/ui-egui/src/i18n/ca.tsv
+++ b/crates/ui-egui/src/i18n/ca.tsv
@@ -4318,6 +4318,15 @@ digits	Malayalam	Malaiàlam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Configuració de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Configuració de Tate-chu-yoko
+	Composite Fonts…	Tipus de lletra compostos…
+	Composite Fonts	Tipus de lletra compostos
+	Export Composite Fonts	Exporta tipus de lletra compostos
+	Import Composite Fonts	Importa tipus de lletra compostos
+	Delete Font	Suprimeix el tipus de lletra
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Xifres
+	Scale at Center	Escala des del centre
 	Up/Down:	Amunt/avall:
 	Left/Right:	Esquerra/dreta:
 	Technical Drawing	Dibuix tècnic
@@ -5036,6 +5045,7 @@ digits	Malayalam	Malaiàlam
 @msg	an image VectorCraft can't read was left out	s’ha omès una imatge que VectorCraft no pot llegir
 @msg	graphs come in as plain art, without their data or settings	els gràfics s’importen com a il·lustració normal, sense les seves dades ni la seva configuració
 @msg	an image whose data is cut short was left out	s’ha omès una imatge les dades de la qual estan tallades
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	una imatge incrustada de {_1} × {_2} píxels s’ha reduït a {_3} × {_4} píxels per conservar les capes
 @msg	an object can't be read	no es pot llegir un objecte
 @msg	an object in perspective would leave the edited grid	un objecte en perspectiva sortiria de la quadrícula editada
 @msg	An object takes one 3D effect. Edit the existing effect's options, or remove it first.	Un objecte admet un efecte 3D. Editeu les opcions de l’efecte existent o suprimiu-lo primer.
@@ -5206,6 +5216,7 @@ digits	Malayalam	Malaiàlam
 @msg	invalid image data for `{0}`	dades d’imatge no vàlides per a `{0}`
 @msg	invalid native panel set	conjunt de panells natius no vàlid
 @msg	invalid object id {value}: expected a non-negative integer	id d’objecte {value} no vàlid: s’esperava un enter no negatiu
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	l’entrada {index} de `{key}` és {value}, no un id d’objecte (un enter no negatiu)
 @msg	Invalid panel layout; restored the default dock	Disposició de panells no vàlida; s’ha restaurat l’acoblament per defecte
 @msg	invalid parameters for `{cmd}`: {msg}	paràmetres no vàlids per a `{cmd}`: {msg}
 @msg	invalid PDF setting: {0}	configuració del PDF no vàlida: {0}
@@ -5875,6 +5886,9 @@ digits	Malayalam	Malaiàlam
 	Install “{name}”, which asks for these permissions?	Instal·la «{name}», que demana aquests permisos?
 	ID: {id}	ID: {id}
 	Version: {version}	Versió: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Instal·la «{name}» en lloc del complement amb el mateix ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Aquest fitxer no és el complement instal·lat abans amb aquest ID. Rep la configuració i la memòria cau desades per a aquest ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	«{name}» és un mòdul diferent del complement amb l’ID {_1} i rebria la configuració i la memòria cau desades per a aquest: instal·la’l amb `replace: true` quan l’usuari hi estigui d’acord
 	File SHA-256: {hash}	SHA-256 del fitxer: {hash}
 	Read the objects it is given	Llegir els objectes que rep
 	Change, add and delete objects in the document	Canviar, afegir i suprimir objectes del document
@@ -5882,10 +5896,13 @@ digits	Malayalam	Malaiàlam
 	Change how the objects its effect is applied to are drawn	Canviar com es dibuixen els objectes als quals s’aplica el seu efecte
 	Write the document as a file in its own format	Escriure el document com un fitxer en un format propi
 	Show its progress, see Cancel and write log lines	Mostrar el progrés, detectar la cancel·lació i escriure línies de registre
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	el permís `progress` necessita el nivell d’API de complements {PROGRESS_API}: indiqueu `api` {PROGRESS_API}
+	Keep settings of its own	Desar una configuració pròpia
+	Keep a cache of its own, which you can clear	Desar una memòria cau pròpia, que podeu buidar
+	Clear Plug-in Cache	Buida la memòria cau del complement
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	el permís `{permission}` necessita el nivell d’API de complements {PROGRESS_API}: indiqueu `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	el mòdul importa `env.{name}` amb un tipus diferent del de l’amfitrió: el de l’amfitrió és {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	el mòdul importa `env.{name}`, que un complement només pot fer servir al nivell d’API de complements {PROGRESS_API} (`api` {PROGRESS_API}) i amb el permís `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	el mòdul importa `{from}.{name}`, que l’amfitrió no ofereix: un complement només pot importar `env.vc_progress`, `env.vc_cancelled` i `env.vc_log` (nivell d’API de complements 2), i cap WASI, fitxer ni xarxa
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	el mòdul importa `env.{name}`, que un complement només pot fer servir al nivell d’API de complements {PROGRESS_API} (`api` {PROGRESS_API}) i amb el permís `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	el mòdul importa `{from}.{name}`, que l’amfitrió no ofereix: un complement només pot importar les funcions `env.vc_*` que enumera docs/plugins.md (nivell d’API de complements 2), i cap WASI, fitxer ni xarxa
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` és {_1}; aquest amfitrió admet els nivells d’API de complements de l’1 al {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` ha de ser una llista de noms de permisos
 @msg	`grant` names an unknown permission `{shown}`	`grant` esmenta un permís desconegut `{shown}`
diff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsv
index 089cc5e33..e24e74929 100644
--- a/crates/ui-egui/src/i18n/cs.tsv
+++ b/crates/ui-egui/src/i18n/cs.tsv
@@ -1525,6 +1525,15 @@ digits	Malayalam	Malajálamské
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Nastavení Tate-chu-yoko…
 	Tate-chu-yoko Settings	Nastavení Tate-chu-yoko
+	Composite Fonts…	Složená písma…
+	Composite Fonts	Složená písma
+	Export Composite Fonts	Exportovat složená písma
+	Import Composite Fonts	Importovat složená písma
+	Delete Font	Odstranit písmo
+	Kanji	Kandži
+	Kana	Kana
+	Numerals	Číslice
+	Scale at Center	Měřítko od středu
 	Up/Down:	Nahoru/dolů:
 	Left/Right:	Vlevo/vpravo:
 	Underline	Podtržení
@@ -5045,6 +5054,7 @@ imageTrace	Outline	Obrys
 @msg	an image VectorCraft can't read was left out	obrázek, který VectorCraft neumí přečíst, byl vynechán
 @msg	graphs come in as plain art, without their data or settings	grafy se načtou jako obyčejná grafika, bez svých dat a nastavení
 @msg	an image whose data is cut short was left out	obrázek s useknutými daty byl vynechán
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	vložený obrázek o rozměrech {_1} × {_2} pixelů byl zmenšen na {_3} × {_4} pixelů, aby se zachovaly vrstvy
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	propojené obrázky se zobrazují jako náhled v nízkém rozlišení uložený v souboru, dokud se nenajdou jejich soubory: znovu je propojte v panelu Propojení
 @msg	linked type areas past VectorCraft's limits were left out	propojené textové oblasti nad limity aplikace VectorCraft byly vynechány
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	text, který mění směr psaní uvnitř textového objektu, se otevře ve směru svého prvního znaku
@@ -5080,6 +5090,7 @@ imageTrace	Outline	Obrys
 @msg	object ids are non-negative integers, not {v}	ID objektů jsou nezáporná celá čísla, ne {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} musí být pole ID objektů, která jsou nezáporná celá čísla
 @msg	invalid object id {value}: expected a non-negative integer	neplatné ID objektu {value}: očekává se nezáporné celé číslo
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	položka {index} v `{key}` je {value}, nikoli ID objektu (nezáporné celé číslo)
 @msg	no such object id {value}	objekt s ID {value} neexistuje
 @msg	id {value} is a layer, not an object	ID {value} je vrstva, nikoli objekt
 @msg	id {value} is a layer, not an object; move layers with layer.move	ID {value} je vrstva, nikoli objekt; vrstvy přesunete pomocí layer.move
@@ -5861,6 +5872,9 @@ axis	Y Axis	osa Y
 	Install “{name}”, which asks for these permissions?	Nainstalovat „{name}“, který žádá o tato oprávnění?
 	ID: {id}	ID: {id}
 	Version: {version}	Verze: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Nainstalovat „{name}“ místo zásuvného modulu se stejným ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Tento soubor není zásuvný modul dříve nainstalovaný s tímto ID. Získá nastavení a mezipaměť uchovávané pro toto ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	„{name}“ je jiný modul než zásuvný modul s ID {_1} a získal by nastavení a mezipaměť uchovávané pro něj: nainstalujte ho s `replace: true`, jakmile uživatel souhlasí
 	File SHA-256: {hash}	SHA-256 souboru: {hash}
 	Read the objects it is given	Číst objekty, které dostane
 	Change, add and delete objects in the document	Měnit, přidávat a mazat objekty v dokumentu
@@ -5868,10 +5882,13 @@ axis	Y Axis	osa Y
 	Change how the objects its effect is applied to are drawn	Měnit, jak se kreslí objekty, na které je použit jeho efekt
 	Write the document as a file in its own format	Zapsat dokument jako soubor ve vlastním formátu
 	Show its progress, see Cancel and write log lines	Zobrazit průběh, rozpoznat zrušení a zapisovat řádky protokolu
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	oprávnění `progress` vyžaduje úroveň API zásuvných modulů {PROGRESS_API}: uveďte `api` {PROGRESS_API}
+	Keep settings of its own	Uchovávat vlastní nastavení
+	Keep a cache of its own, which you can clear	Uchovávat vlastní mezipaměť, kterou můžete vymazat
+	Clear Plug-in Cache	Vymazat mezipaměť zásuvného modulu
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	oprávnění `{permission}` vyžaduje úroveň API zásuvných modulů {PROGRESS_API}: uveďte `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	modul importuje `env.{name}` s jiným typem, než má hostitel: typ hostitele je {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	modul importuje `env.{name}`, který zásuvný modul smí používat jen na úrovni API zásuvných modulů {PROGRESS_API} (`api` {PROGRESS_API}) a s oprávněním `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	modul importuje `{from}.{name}`, který hostitel nenabízí: zásuvný modul smí importovat jen `env.vc_progress`, `env.vc_cancelled` a `env.vc_log` (úroveň API zásuvných modulů 2), a žádné WASI, soubory ani síť
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	modul importuje `env.{name}`, který zásuvný modul smí používat jen na úrovni API zásuvných modulů {PROGRESS_API} (`api` {PROGRESS_API}) a s oprávněním `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	modul importuje `{from}.{name}`, který hostitel nenabízí: zásuvný modul smí importovat jen funkce `env.vc_*`, které uvádí docs/plugins.md (úroveň API zásuvných modulů 2), a žádné WASI, soubory ani síť
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` je {_1}; tento hostitel podporuje úrovně API zásuvných modulů 1 až {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` musí být seznam názvů oprávnění
 @msg	`grant` names an unknown permission `{shown}`	`grant` uvádí neznámé oprávnění `{shown}`
diff --git a/crates/ui-egui/src/i18n/da.tsv b/crates/ui-egui/src/i18n/da.tsv
index c8c6db18b..c3fb0ffbe 100644
--- a/crates/ui-egui/src/i18n/da.tsv
+++ b/crates/ui-egui/src/i18n/da.tsv
@@ -1435,6 +1435,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Indstillinger for Tate-chu-yoko…
 	Tate-chu-yoko Settings	Indstillinger for Tate-chu-yoko
+	Composite Fonts…	Sammensatte skrifttyper…
+	Composite Fonts	Sammensatte skrifttyper
+	Export Composite Fonts	Eksportér sammensatte skrifttyper
+	Import Composite Fonts	Importér sammensatte skrifttyper
+	Delete Font	Slet skrifttype
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Tal
+	Scale at Center	Skalér fra midten
 	Up/Down:	Op/ned:
 	Left/Right:	Venstre/højre:
 	Underline	Understreget
@@ -4668,6 +4677,7 @@ imageTrace	Outline	Kontur
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	gradienten »{name}« er ikke defineret i filen: der bruges en flad farve i stedet
 @msg	an image VectorCraft can't read was left out	et billede, som VectorCraft ikke kan læse, blev udeladt
 @msg	an image whose data is cut short was left out	et billede, hvis data er afkortet, blev udeladt
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	et indlejret billede på {_1} × {_2} pixel blev formindsket til {_3} × {_4} pixel for at bevare lagene
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	linkede billeder viser den gemte forhåndsvisning i lav opløsning, indtil deres filer findes: link dem igen i Links-panelet
 @msg	linked type areas past VectorCraft's limits were left out	sammenkædede tekstområder ud over VectorCrafts grænser blev udeladt
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst, der skifter skriveretning inde i et tekstobjekt, åbnes i retningen for sit første tegn
@@ -4703,6 +4713,7 @@ imageTrace	Outline	Kontur
 @msg	object ids are non-negative integers, not {v}	objekt-id'er er ikke-negative heltal, ikke {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} skal være et array af objekt-id'er, der er ikke-negative heltal
 @msg	invalid object id {value}: expected a non-negative integer	ugyldigt objekt-id {value}: et ikke-negativt heltal var forventet
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	element {index} i `{key}` er {value}, ikke et objekt-id (et ikke-negativt heltal)
 @msg	no such object id {value}	der findes intet objekt med id {value}
 @msg	automation filesystem access is not granted: read authority is absent: {path}	automatiseringens adgang til filsystemet er ikke tildelt: læserettighed mangler: {path}
 @msg	automation filesystem access is not granted: write authority is absent: {path}	automatiseringens adgang til filsystemet er ikke tildelt: skriverettighed mangler: {path}
@@ -5744,6 +5755,8 @@ axis	Y Axis	Y-akse
 	Install “{name}”, which asks for these permissions?	Installér »{name}«, som beder om disse rettigheder?
 	ID: {id}	ID: {id}
 	Version: {version}	Version: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Installér »{name}« i stedet for det plug-in, der har samme id?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Denne fil er ikke det plug-in, der før var installeret med dette id. Den får de indstillinger og den cache, der er gemt for dette id.
 	File SHA-256: {hash}	Filens SHA-256: {hash}
 	Read the objects it is given	Læse de objekter, den får
 	Change, add and delete objects in the document	Ændre, tilføje og slette objekter i dokumentet
@@ -5751,6 +5764,9 @@ axis	Y Axis	Y-akse
 	Change how the objects its effect is applied to are drawn	Ændre, hvordan de objekter, dens effekt er anvendt på, tegnes
 	Write the document as a file in its own format	Skrive dokumentet som en fil i sit eget format
 	Show its progress, see Cancel and write log lines	Vise sin fremdrift, se en annullering og skrive logrækker
+	Keep settings of its own	Gemme sine egne indstillinger
+	Keep a cache of its own, which you can clear	Gemme sin egen cache, som du kan rydde
+	Clear Plug-in Cache	Ryd plug-in-cache
 # Actions panel: action sets (#3712).
 	New Set…	Nyt sæt…
 	New Set	Nyt sæt
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index ea1f60441..f83f7f74a 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -3407,6 +3407,15 @@ effect	Points	Punkte
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-Einstellungen…
 	Tate-chu-yoko Settings	Tate-chu-yoko-Einstellungen
+	Composite Fonts…	Zusammengesetzte Schriften…
+	Composite Fonts	Zusammengesetzte Schriften
+	Export Composite Fonts	Zusammengesetzte Schriften exportieren
+	Import Composite Fonts	Zusammengesetzte Schriften importieren
+	Delete Font	Schrift löschen
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Ziffern
+	Scale at Center	Von der Mitte aus skalieren
 	Up/Down:	Oben/Unten:
 	Left/Right:	Links/Rechts:
 	Temperature	Temperatur
@@ -4652,6 +4661,7 @@ theme	Appearance	Erscheinungsbild
 @msg	an image VectorCraft can't read was left out	ein Bild, das VectorCraft nicht lesen kann, wurde ausgelassen
 @msg	graphs come in as plain art, without their data or settings	Diagramme werden als einfache Grafik übernommen, ohne ihre Daten und Einstellungen
 @msg	an image whose data is cut short was left out	ein Bild mit abgeschnittenen Daten wurde ausgelassen
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	ein eingebettetes Bild mit {_1} × {_2} Pixeln wurde auf {_3} × {_4} Pixel verkleinert, damit die Ebenen erhalten bleiben
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	verknüpfte Bilder zeigen die in der Datei gespeicherte Vorschau in niedriger Auflösung, bis ihre Dateien gefunden werden: Verknüpfen Sie sie im Bedienfeld „Verknüpfungen“ neu
 @msg	linked type areas past VectorCraft's limits were left out	verkettete Textbereiche jenseits der Grenzen von VectorCraft wurden ausgelassen
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	Text, der innerhalb eines Textobjekts die Schreibrichtung wechselt, wird in der Richtung seines ersten Zeichens geöffnet
@@ -4734,6 +4744,7 @@ theme	Appearance	Erscheinungsbild
 @msg	object ids are non-negative integers, not {v}	Objekt-IDs sind nicht negative ganze Zahlen, nicht {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} muss ein Array von Objekt-IDs sein, die nicht negative ganze Zahlen sind
 @msg	invalid object id {value}: expected a non-negative integer	ungültige Objekt-ID {value}: erwartet wird eine nicht negative ganze Zahl
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	Eintrag {index} von `{key}` ist {value}, keine Objekt-ID (nicht negative ganze Zahl)
 @msg	no such object id {value}	kein Objekt mit der ID {value}
 @msg	id {value} is a layer, not an object	die ID {value} ist eine Ebene, kein Objekt
 @msg	id {value} is a layer, not an object; move layers with layer.move	die ID {value} ist eine Ebene, kein Objekt; verschieben Sie Ebenen mit layer.move
@@ -5443,6 +5454,9 @@ axis	Y Axis	Y-Achse
 	Install “{name}”, which asks for these permissions?	„{name}“ installieren, das diese Berechtigungen verlangt?
 	ID: {id}	ID: {id}
 	Version: {version}	Version: {version}
+	Install “{name}” in place of the plug-in with the same ID?	„{name}“ anstelle des Plug-ins mit derselben ID installieren?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Diese Datei ist nicht das Plug-in, das vorher mit dieser ID installiert war. Sie erhält die Einstellungen und den Cache, die für diese ID gespeichert sind.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	„{name}“ ist ein anderes Modul als das Plug-in mit der ID {_1} und würde die dafür gespeicherten Einstellungen und den Cache erhalten: Installieren Sie es mit `replace: true`, sobald der Benutzer zustimmt
 	File SHA-256: {hash}	Datei-SHA-256: {hash}
 	Read the objects it is given	Die Objekte lesen, die es erhält
 	Change, add and delete objects in the document	Objekte im Dokument ändern, hinzufügen und löschen
@@ -5450,10 +5464,13 @@ axis	Y Axis	Y-Achse
 	Change how the objects its effect is applied to are drawn	Ändern, wie die Objekte gezeichnet werden, auf die sein Effekt angewendet ist
 	Write the document as a file in its own format	Das Dokument als Datei in einem eigenen Format schreiben
 	Show its progress, see Cancel and write log lines	Den Fortschritt anzeigen, ein Abbrechen erkennen und Protokollzeilen schreiben
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	die Berechtigung `progress` braucht die Plug-in-API-Stufe {PROGRESS_API}: Geben Sie `api` {PROGRESS_API} an
+	Keep settings of its own	Eigene Einstellungen speichern
+	Keep a cache of its own, which you can clear	Einen eigenen Cache anlegen, den Sie leeren können
+	Clear Plug-in Cache	Plug-in-Cache leeren
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	die Berechtigung `{permission}` braucht die Plug-in-API-Stufe {PROGRESS_API}: Geben Sie `api` {PROGRESS_API} an
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	das Modul importiert `env.{name}` mit einem anderen Typ als dem des Hosts: Der Typ des Hosts ist {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	das Modul importiert `env.{name}`, das ein Plug-in nur auf der Plug-in-API-Stufe {PROGRESS_API} (`api` {PROGRESS_API}) und mit der Berechtigung `progress` verwenden darf
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	das Modul importiert `{from}.{name}`, das der Host nicht anbietet: Ein Plug-in darf nur `env.vc_progress`, `env.vc_cancelled` und `env.vc_log` importieren (Plug-in-API-Stufe 2), aber kein WASI, keine Dateien und kein Netzwerk
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	das Modul importiert `env.{name}`, das ein Plug-in nur auf der Plug-in-API-Stufe {PROGRESS_API} (`api` {PROGRESS_API}) und mit der Berechtigung `{permission}` verwenden darf
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	das Modul importiert `{from}.{name}`, das der Host nicht anbietet: Ein Plug-in darf nur die `env.vc_*`-Funktionen importieren, die docs/plugins.md aufführt (Plug-in-API-Stufe 2), aber kein WASI, keine Dateien und kein Netzwerk
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` ist {_1}; dieser Host unterstützt die Plug-in-API-Stufen 1 bis {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` muss eine Liste von Berechtigungsnamen sein
 @msg	`grant` names an unknown permission `{shown}`	`grant` nennt eine unbekannte Berechtigung `{shown}`
diff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsv
index a24e6fb51..9e30d25f9 100644
--- a/crates/ui-egui/src/i18n/el.tsv
+++ b/crates/ui-egui/src/i18n/el.tsv
@@ -3809,6 +3809,15 @@ digits	Malayalam	Μαλαγιάλαμ
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ρυθμίσεις Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ρυθμίσεις Tate-chu-yoko
+	Composite Fonts…	Σύνθετες γραμματοσειρές…
+	Composite Fonts	Σύνθετες γραμματοσειρές
+	Export Composite Fonts	Εξαγωγή σύνθετων γραμματοσειρών
+	Import Composite Fonts	Εισαγωγή σύνθετων γραμματοσειρών
+	Delete Font	Διαγραφή γραμματοσειράς
+	Kanji	Κάντζι
+	Kana	Κάνα
+	Numerals	Αριθμοί
+	Scale at Center	Κλιμάκωση από το κέντρο
 	Up/Down:	Πάνω/Κάτω:
 	Left/Right:	Αριστερά/Δεξιά:
 	Temperature/Tint…	Θερμοκρασία/Απόχρωση…
@@ -4685,6 +4694,7 @@ digits	Malayalam	Μαλαγιάλαμ
 @msg	an image VectorCraft can't read was left out	παραλείφθηκε εικόνα που δεν μπορεί να διαβάσει το VectorCraft
 @msg	graphs come in as plain art, without their data or settings	τα γραφήματα εισάγονται ως απλή γραφική, χωρίς τα δεδομένα και τις ρυθμίσεις τους
 @msg	an image whose data is cut short was left out	παραλείφθηκε εικόνα με περικομμένα δεδομένα
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	μια ενσωματωμένη εικόνα {_1} × {_2} pixel μειώθηκε σε {_3} × {_4} pixel για να διατηρηθούν τα επίπεδα
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	οι συνδεδεμένες εικόνες εμφανίζουν την προεπισκόπηση χαμηλής ανάλυσης που έχει αποθηκευτεί, μέχρι να βρεθούν τα αρχεία τους: επανασυνδέστε τις στον πίνακα Σύνδεσμοι
 @msg	linked type areas past VectorCraft's limits were left out	οι συνδεδεμένες περιοχές κειμένου πέρα από τα όρια του VectorCraft παραλείφθηκαν
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	το κείμενο που αλλάζει κατεύθυνση γραφής μέσα σε ένα αντικείμενο κειμένου ανοίγει με την κατεύθυνση του πρώτου χαρακτήρα του
@@ -4758,6 +4768,7 @@ digits	Malayalam	Μαλαγιάλαμ
 @msg	object ids are non-negative integers, not {v}	τα αναγνωριστικά αντικειμένων πρέπει να είναι μη αρνητικοί ακέραιοι, όχι {v}
 @msg	{key} must be an array of non-negative integer object ids	{key}: πρέπει να είναι πίνακας αναγνωριστικών αντικειμένων που είναι μη αρνητικοί ακέραιοι
 @msg	invalid object id {value}: expected a non-negative integer	μη έγκυρο αναγνωριστικό αντικειμένου {value}: αναμένεται μη αρνητικός ακέραιος
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	το στοιχείο {index} του `{key}` είναι {value}, όχι αναγνωριστικό αντικειμένου (μη αρνητικός ακέραιος)
 @msg	no such object id {value}	δεν υπάρχει αντικείμενο με αναγνωριστικό {value}
 @msg	id {value} is a layer, not an object	το αναγνωριστικό {value} είναι επίπεδο, όχι αντικείμενο
 @msg	id {value} is a layer, not an object; move layers with layer.move	το αναγνωριστικό {value} είναι επίπεδο, όχι αντικείμενο· μετακινήστε τα επίπεδα με το layer.move
@@ -5812,6 +5823,9 @@ axis	Y Axis	Άξονας Y
 	Install “{name}”, which asks for these permissions?	Να εγκατασταθεί το «{name}», που ζητά αυτά τα δικαιώματα;
 	ID: {id}	Αναγνωριστικό: {id}
 	Version: {version}	Έκδοση: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Να εγκατασταθεί το «{name}» στη θέση του πρόσθετου με το ίδιο αναγνωριστικό;
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Αυτό το αρχείο δεν είναι το πρόσθετο που ήταν εγκατεστημένο πριν με αυτό το αναγνωριστικό. Παίρνει τις ρυθμίσεις και την κρυφή μνήμη που διατηρούνται για αυτό το αναγνωριστικό.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	το «{name}» είναι άλλη λειτουργική μονάδα από το πρόσθετο με αναγνωριστικό {_1} και θα έπαιρνε τις ρυθμίσεις και την κρυφή μνήμη που διατηρούνται για αυτό: εγκαταστήστε το με `replace: true` μόλις συμφωνήσει ο χρήστης
 	File SHA-256: {hash}	SHA-256 αρχείου: {hash}
 	Read the objects it is given	Ανάγνωση των αντικειμένων που του δίνονται
 	Change, add and delete objects in the document	Αλλαγή, προσθήκη και διαγραφή αντικειμένων στο έγγραφο
@@ -5819,10 +5833,13 @@ axis	Y Axis	Άξονας Y
 	Change how the objects its effect is applied to are drawn	Αλλαγή του τρόπου σχεδίασης των αντικειμένων στα οποία εφαρμόζεται το εφέ του
 	Write the document as a file in its own format	Εγγραφή του εγγράφου ως αρχείου σε δική του μορφή
 	Show its progress, see Cancel and write log lines	Εμφάνιση της προόδου, αναγνώριση της ακύρωσης και εγγραφή γραμμών καταγραφής
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	το δικαίωμα `progress` χρειάζεται το επίπεδο API προσθέτων {PROGRESS_API}: δώστε `api` {PROGRESS_API}
+	Keep settings of its own	Διατήρηση δικών του ρυθμίσεων
+	Keep a cache of its own, which you can clear	Διατήρηση δικής του κρυφής μνήμης, την οποία μπορείτε να εκκαθαρίσετε
+	Clear Plug-in Cache	Εκκαθάριση κρυφής μνήμης προσθέτου
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	το δικαίωμα `{permission}` χρειάζεται το επίπεδο API προσθέτων {PROGRESS_API}: δώστε `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	η λειτουργική μονάδα εισάγει το `env.{name}` με άλλον τύπο από αυτόν του κεντρικού υπολογιστή: ο τύπος του είναι {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	η λειτουργική μονάδα εισάγει το `env.{name}`, το οποίο ένα πρόσθετο μπορεί να χρησιμοποιεί μόνο στο επίπεδο API προσθέτων {PROGRESS_API} (`api` {PROGRESS_API}) και με το δικαίωμα `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	η λειτουργική μονάδα εισάγει το `{from}.{name}`, το οποίο δεν προσφέρει ο κεντρικός υπολογιστής: ένα πρόσθετο μπορεί να εισάγει μόνο τα `env.vc_progress`, `env.vc_cancelled` και `env.vc_log` (επίπεδο API προσθέτων 2) και κανένα WASI, αρχεία ή δίκτυο
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	η λειτουργική μονάδα εισάγει το `env.{name}`, το οποίο ένα πρόσθετο μπορεί να χρησιμοποιεί μόνο στο επίπεδο API προσθέτων {PROGRESS_API} (`api` {PROGRESS_API}) και με το δικαίωμα `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	η λειτουργική μονάδα εισάγει το `{from}.{name}`, το οποίο δεν προσφέρει ο κεντρικός υπολογιστής: ένα πρόσθετο μπορεί να εισάγει μόνο τις συναρτήσεις `env.vc_*` που απαριθμεί το docs/plugins.md (επίπεδο API προσθέτων 2) και κανένα WASI, αρχεία ή δίκτυο
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	το `api` είναι {_1}· αυτός ο κεντρικός υπολογιστής υποστηρίζει τα επίπεδα API προσθέτων 1 έως {API_LEVEL}
 @msg	`grant` must be a list of permission names	το `grant` πρέπει να είναι λίστα ονομάτων δικαιωμάτων
 @msg	`grant` names an unknown permission `{shown}`	το `grant` αναφέρει άγνωστο δικαίωμα `{shown}`
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index b20bbb6b7..5122c5acb 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -3463,6 +3463,15 @@ digits	Malayalam	Malayálam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ajustes de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ajustes de Tate-chu-yoko
+	Composite Fonts…	Fuentes compuestas…
+	Composite Fonts	Fuentes compuestas
+	Export Composite Fonts	Exportar fuentes compuestas
+	Import Composite Fonts	Importar fuentes compuestas
+	Delete Font	Eliminar fuente
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Números
+	Scale at Center	Escalar desde el centro
 	Up/Down:	Arriba/abajo:
 	Left/Right:	Izquierda/derecha:
 	Temperature	Temperatura
@@ -4736,6 +4745,7 @@ axis	Both	Ambos
 @msg	an image VectorCraft can't read was left out	se omitió una imagen que VectorCraft no puede leer
 @msg	graphs come in as plain art, without their data or settings	los gráficos se importan como ilustración normal, sin sus datos ni sus ajustes
 @msg	an image whose data is cut short was left out	se omitió una imagen con datos incompletos
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	una imagen incrustada de {_1} × {_2} píxeles se redujo a {_3} × {_4} píxeles para conservar las capas
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	las imágenes vinculadas muestran la vista previa de baja resolución guardada en el archivo hasta que se encuentren sus archivos: vuelva a vincularlas en el panel Vínculos
 @msg	linked type areas past VectorCraft's limits were left out	se omitieron las áreas de texto enlazadas que superan los límites de VectorCraft
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	el texto que cambia de dirección de escritura dentro de un objeto de texto se abre en la dirección de su primer carácter
@@ -4797,6 +4807,7 @@ axis	Both	Ambos
 @msg	object ids are non-negative integers, not {v}	los identificadores de objeto son enteros no negativos, no {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} debe ser una lista de identificadores de objeto que sean enteros no negativos
 @msg	invalid object id {value}: expected a non-negative integer	identificador de objeto no válido {value}: se esperaba un entero no negativo
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	la entrada {index} de `{key}` es {value}, no un identificador de objeto (un entero no negativo)
 @msg	no such object id {value}	no existe el objeto con el identificador {value}
 @msg	id {value} is a layer, not an object	el identificador {value} es una capa, no un objeto
 @msg	id {value} is a layer, not an object; move layers with layer.move	el identificador {value} es una capa, no un objeto; mueva las capas con layer.move
@@ -5802,6 +5813,9 @@ axis	Y Axis	Eje Y
 	Install “{name}”, which asks for these permissions?	¿Instalar “{name}”, que pide estos permisos?
 	ID: {id}	ID: {id}
 	Version: {version}	Versión: {version}
+	Install “{name}” in place of the plug-in with the same ID?	¿Instalar “{name}” en lugar del plugin con el mismo ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Este archivo no es el plugin instalado antes con este ID. Recibe la configuración y la caché guardadas para ese ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}” es un módulo distinto del plugin con ID {_1} y recibiría la configuración y la caché guardadas para él: instálalo con `replace: true` cuando el usuario lo acepte
 	File SHA-256: {hash}	SHA-256 del archivo: {hash}
 	Read the objects it is given	Leer los objetos que recibe
 	Change, add and delete objects in the document	Cambiar, añadir y eliminar objetos del documento
@@ -5809,10 +5823,13 @@ axis	Y Axis	Eje Y
 	Change how the objects its effect is applied to are drawn	Cambiar cómo se dibujan los objetos a los que se aplica su efecto
 	Write the document as a file in its own format	Escribir el documento como un archivo en su propio formato
 	Show its progress, see Cancel and write log lines	Mostrar su progreso, detectar la cancelación y escribir líneas de registro
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	el permiso `progress` necesita el nivel de API de plugins {PROGRESS_API}: indique `api` {PROGRESS_API}
+	Keep settings of its own	Guardar una configuración propia
+	Keep a cache of its own, which you can clear	Guardar una caché propia, que usted puede vaciar
+	Clear Plug-in Cache	Vaciar caché del plugin
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	el permiso `{permission}` necesita el nivel de API de plugins {PROGRESS_API}: indique `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	el módulo importa `env.{name}` con un tipo distinto del del host: el del host es {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	el módulo importa `env.{name}`, que un plugin solo puede usar en el nivel de API de plugins {PROGRESS_API} (`api` {PROGRESS_API}) y con el permiso `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	el módulo importa `{from}.{name}`, que el host no ofrece: un plugin solo puede importar `env.vc_progress`, `env.vc_cancelled` y `env.vc_log` (nivel de API de plugins 2), y ningún WASI, archivo ni red
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	el módulo importa `env.{name}`, que un plugin solo puede usar en el nivel de API de plugins {PROGRESS_API} (`api` {PROGRESS_API}) y con el permiso `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	el módulo importa `{from}.{name}`, que el host no ofrece: un plugin solo puede importar las funciones `env.vc_*` que enumera docs/plugins.md (nivel de API de plugins 2), y ningún WASI, archivo ni red
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` es {_1}; este host admite los niveles de API de plugins de 1 a {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` debe ser una lista de nombres de permisos
 @msg	`grant` names an unknown permission `{shown}`	`grant` nombra un permiso desconocido `{shown}`
diff --git a/crates/ui-egui/src/i18n/fi.tsv b/crates/ui-egui/src/i18n/fi.tsv
index 8e1c377f9..4265fcbde 100644
--- a/crates/ui-egui/src/i18n/fi.tsv
+++ b/crates/ui-egui/src/i18n/fi.tsv
@@ -1498,6 +1498,15 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-asetukset…
 	Tate-chu-yoko Settings	Tate-chu-yoko-asetukset
+	Composite Fonts…	Yhdistelmäfontit…
+	Composite Fonts	Yhdistelmäfontit
+	Export Composite Fonts	Vie yhdistelmäfontit
+	Import Composite Fonts	Tuo yhdistelmäfontit
+	Delete Font	Poista fontti
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Numerot
+	Scale at Center	Skaalaa keskeltä
 	Up/Down:	Ylös/alas:
 	Left/Right:	Vasen/oikea:
 	Underline	Alleviivaus
@@ -4947,6 +4956,7 @@ imageTrace	Outline	Ääriviiva
 @msg	an image VectorCraft can't read was left out	kuva, jota VectorCraft ei voi lukea, jätettiin pois
 @msg	graphs come in as plain art, without their data or settings	kaaviot tuodaan tavallisena grafiikkana ilman niiden tietoja ja asetuksia
 @msg	an image whose data is cut short was left out	kuva, jonka data on katkennut, jätettiin pois
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	upotettu {_1} × {_2} kuvapisteen kuva pienennettiin kokoon {_3} × {_4} kuvapistettä, jotta tasot säilyvät
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	linkitetyt kuvat näyttävät tiedostoon tallennetun matalan tarkkuuden esikatselun, kunnes niiden tiedostot löytyvät: linkitä ne uudelleen Linkit-paneelissa
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraftin rajat ylittävät linkitetyt tekstialueet jätettiin pois
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	tekstiobjektin sisällä kirjoitussuuntaa vaihtava teksti avautuu ensimmäisen merkkinsä suuntaan
@@ -4982,6 +4992,7 @@ imageTrace	Outline	Ääriviiva
 @msg	object ids are non-negative integers, not {v}	objektitunnukset ovat ei-negatiivisia kokonaislukuja, ei {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} on oltava taulukko objektitunnuksia, jotka ovat ei-negatiivisia kokonaislukuja
 @msg	invalid object id {value}: expected a non-negative integer	virheellinen objektitunnus {value}: odotettiin ei-negatiivista kokonaislukua
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}`-luettelon kohde {index} on {value}, ei objektitunnus (ei-negatiivinen kokonaisluku)
 @msg	no such object id {value}	objektia tunnuksella {value} ei ole
 @msg	id {value} is a layer, not an object	tunnus {value} on taso, ei objekti
 @msg	id {value} is a layer, not an object; move layers with layer.move	tunnus {value} on taso, ei objekti; siirrä tasoja komennolla layer.move
@@ -5891,6 +5902,9 @@ axis	Y Axis	Y-akseli
 	Install “{name}”, which asks for these permissions?	Asennetaanko ”{name}”, joka pyytää näitä käyttöoikeuksia?
 	ID: {id}	Tunnus: {id}
 	Version: {version}	Versio: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Asennetaanko ”{name}” samaa tunnusta käyttävän laajennuksen tilalle?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Tämä tiedosto ei ole laajennus, joka oli aiemmin asennettu tällä tunnuksella. Se saa tälle tunnukselle säilytetyt asetukset ja välimuistin.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	”{name}” on eri moduuli kuin laajennus, jonka tunnus on {_1}, ja se saisi sille säilytetyt asetukset ja välimuistin: asenna se asetuksella `replace: true`, kun käyttäjä hyväksyy
 	File SHA-256: {hash}	Tiedoston SHA-256: {hash}
 	Read the objects it is given	Lukea sille annetut objektit
 	Change, add and delete objects in the document	Muuttaa, lisätä ja poistaa asiakirjan objekteja
@@ -5898,10 +5912,13 @@ axis	Y Axis	Y-akseli
 	Change how the objects its effect is applied to are drawn	Muuttaa sitä, miten objektit, joihin sen tehostetta on käytetty, piirretään
 	Write the document as a file in its own format	Kirjoittaa asiakirjan tiedostoksi omassa muodossaan
 	Show its progress, see Cancel and write log lines	Näyttää edistymisensä, havaita peruutuksen ja kirjoittaa lokirivejä
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	käyttöoikeus `progress` vaatii laajennus-API:n tason {PROGRESS_API}: anna `api` {PROGRESS_API}
+	Keep settings of its own	Säilyttää omat asetuksensa
+	Keep a cache of its own, which you can clear	Säilyttää oman välimuistin, jonka voit tyhjentää
+	Clear Plug-in Cache	Tyhjennä laajennuksen välimuisti
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	käyttöoikeus `{permission}` vaatii laajennus-API:n tason {PROGRESS_API}: anna `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	moduuli tuo kohteen `env.{name}` eri tyyppisenä kuin isäntä: isännän tyyppi on {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	moduuli tuo kohteen `env.{name}`, jota laajennus saa käyttää vain laajennus-API:n tasolla {PROGRESS_API} (`api` {PROGRESS_API}) ja käyttöoikeudella `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	moduuli tuo kohteen `{from}.{name}`, jota isäntä ei tarjoa: laajennus saa tuoda vain kohteet `env.vc_progress`, `env.vc_cancelled` ja `env.vc_log` (laajennus-API:n taso 2) eikä mitään WASIa, tiedostoja tai verkkoa
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	moduuli tuo kohteen `env.{name}`, jota laajennus saa käyttää vain laajennus-API:n tasolla {PROGRESS_API} (`api` {PROGRESS_API}) ja käyttöoikeudella `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	moduuli tuo kohteen `{from}.{name}`, jota isäntä ei tarjoa: laajennus saa tuoda vain docs/plugins.md-tiedostossa luetellut `env.vc_*`-funktiot (laajennus-API:n taso 2) eikä mitään WASIa, tiedostoja tai verkkoa
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` on {_1}; tämä isäntä tukee laajennus-API:n tasoja 1 ja {API_LEVEL} välillä
 @msg	`grant` must be a list of permission names	`grant` on oltava luettelo käyttöoikeuksien nimistä
 @msg	`grant` names an unknown permission `{shown}`	`grant` nimeää tuntemattoman käyttöoikeuden `{shown}`
diff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsv
index a424b7e26..107f49a8b 100644
--- a/crates/ui-egui/src/i18n/fr.tsv
+++ b/crates/ui-egui/src/i18n/fr.tsv
@@ -3455,6 +3455,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Paramètres Tate-chu-yoko…
 	Tate-chu-yoko Settings	Paramètres Tate-chu-yoko
+	Composite Fonts…	Polices composites…
+	Composite Fonts	Polices composites
+	Export Composite Fonts	Exporter des polices composites
+	Import Composite Fonts	Importer des polices composites
+	Delete Font	Supprimer la police
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Chiffres
+	Scale at Center	Mettre à l’échelle depuis le centre
 	Up/Down:	Haut/bas :
 	Left/Right:	Gauche/droite :
 	Temperature	Température
@@ -4724,6 +4733,7 @@ axis	Both	Les deux
 @msg	an image VectorCraft can't read was left out	une image que VectorCraft ne peut pas lire a été ignorée
 @msg	graphs come in as plain art, without their data or settings	les graphes sont importés comme illustration ordinaire, sans leurs données ni leurs réglages
 @msg	an image whose data is cut short was left out	une image aux données tronquées a été ignorée
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	une image incorporée de {_1} × {_2} pixels a été réduite à {_3} × {_4} pixels pour conserver les calques
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	les images liées affichent l’aperçu basse résolution enregistré dans le fichier tant que leurs fichiers ne sont pas trouvés : liez-les à nouveau dans le panneau Liens
 @msg	linked type areas past VectorCraft's limits were left out	les zones de texte liées au-delà des limites de VectorCraft ont été omises
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	le texte qui change de sens d’écriture dans un objet texte s’ouvre dans le sens de son premier caractère
@@ -4805,6 +4815,7 @@ axis	Both	Les deux
 @msg	object ids are non-negative integers, not {v}	les identifiants d’objet sont des entiers positifs ou nuls, pas {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} doit être un tableau d’identifiants d’objet, entiers positifs ou nuls
 @msg	invalid object id {value}: expected a non-negative integer	identifiant d’objet {value} non valide (un entier positif ou nul est attendu)
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	l’entrée {index} de `{key}` vaut {value}, pas un identifiant d’objet (entier positif ou nul)
 @msg	no such object id {value}	aucun objet ne porte l’identifiant {value}
 @msg	id {value} is a layer, not an object	l’identifiant {value} désigne un calque, pas un objet
 @msg	id {value} is a layer, not an object; move layers with layer.move	l’identifiant {value} désigne un calque, pas un objet ; déplacez les calques avec layer.move
@@ -5856,6 +5867,9 @@ axis	Y Axis	Axe Y
 	Install “{name}”, which asks for these permissions?	Installer « {name} », qui demande ces autorisations ?
 	ID: {id}	ID : {id}
 	Version: {version}	Version : {version}
+	Install “{name}” in place of the plug-in with the same ID?	Installer « {name} » à la place du module externe qui a le même ID ?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Ce fichier n’est pas le module externe installé auparavant avec cet ID. Il reçoit les réglages et le cache conservés pour cet ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	« {name} » est un autre module que le module externe d’ID {_1} et recevrait les réglages et le cache conservés pour celui-ci : installez-le avec `replace: true` une fois que l’utilisateur l’accepte
 	File SHA-256: {hash}	SHA-256 du fichier : {hash}
 	Read the objects it is given	Lire les objets qui lui sont transmis
 	Change, add and delete objects in the document	Modifier, ajouter et supprimer des objets du document
@@ -5863,10 +5877,13 @@ axis	Y Axis	Axe Y
 	Change how the objects its effect is applied to are drawn	Modifier le rendu des objets auxquels son effet est appliqué
 	Write the document as a file in its own format	Écrire le document dans un fichier à son propre format
 	Show its progress, see Cancel and write log lines	Afficher sa progression, détecter l’annulation et écrire des lignes de journal
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	l’autorisation `progress` nécessite le niveau d’API de module externe {PROGRESS_API} : indiquez `api` {PROGRESS_API}
+	Keep settings of its own	Conserver ses propres réglages
+	Keep a cache of its own, which you can clear	Conserver son propre cache, que vous pouvez vider
+	Clear Plug-in Cache	Vider le cache du module externe
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	l’autorisation `{permission}` nécessite le niveau d’API de module externe {PROGRESS_API} : indiquez `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	le module importe `env.{name}` avec un autre type que celui de l’hôte : celui de l’hôte est {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	le module importe `env.{name}`, qu’un module externe ne peut utiliser qu’au niveau d’API de module externe {PROGRESS_API} (`api` {PROGRESS_API}) et avec l’autorisation `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	le module importe `{from}.{name}`, que l’hôte ne propose pas : un module externe ne peut importer que `env.vc_progress`, `env.vc_cancelled` et `env.vc_log` (niveau d’API de module externe 2), et aucun WASI, fichier ni réseau
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	le module importe `env.{name}`, qu’un module externe ne peut utiliser qu’au niveau d’API de module externe {PROGRESS_API} (`api` {PROGRESS_API}) et avec l’autorisation `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	le module importe `{from}.{name}`, que l’hôte ne propose pas : un module externe ne peut importer que les fonctions `env.vc_*` que liste docs/plugins.md (niveau d’API de module externe 2), et aucun WASI, fichier ni réseau
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` vaut {_1} ; cet hôte prend en charge les niveaux d’API de module externe 1 à {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` doit être une liste de noms d’autorisations
 @msg	`grant` names an unknown permission `{shown}`	`grant` nomme une autorisation inconnue `{shown}`
diff --git a/crates/ui-egui/src/i18n/hi.tsv b/crates/ui-egui/src/i18n/hi.tsv
index a9523b13c..5db92a70e 100644
--- a/crates/ui-egui/src/i18n/hi.tsv
+++ b/crates/ui-egui/src/i18n/hi.tsv
@@ -4694,6 +4694,15 @@
 	Tate-chu-yoko	ताते-चू-योको
 	Tate-chu-yoko Settings	ताते-चू-योको सेटिंग्स
 	Tate-chu-yoko Settings…	ताते-चू-योको सेटिंग्स…
+	Composite Fonts…	कंपोज़िट फ़ॉन्ट…
+	Composite Fonts	कंपोज़िट फ़ॉन्ट
+	Export Composite Fonts	कंपोज़िट फ़ॉन्ट एक्सपोर्ट करें
+	Import Composite Fonts	कंपोज़िट फ़ॉन्ट इम्पोर्ट करें
+	Delete Font	फ़ॉन्ट हटाएँ
+	Kanji	कांजी
+	Kana	काना
+	Numerals	अंक
+	Scale at Center	केंद्र से आकार बदलें
 	Technical Drawing	तकनीकी ड्राइंग
 	Telugu	तेलुगु
 	Temperature	तापमान
@@ -5230,6 +5239,9 @@
 	Install “{name}”, which asks for these permissions?	"{name}" स्थापित करें, जो ये अनुमतियां मांगता है?
 	ID: {id}	ID: {id}
 	Version: {version}	संस्करण: {version}
+	Install “{name}” in place of the plug-in with the same ID?	समान ID वाले प्लग-इन की जगह “{name}” इंस्टॉल करें?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	यह फ़ाइल इस ID के साथ पहले इंस्टॉल किया गया प्लग-इन नहीं है। इसे उस ID के लिए रखी गई सेटिंग्स और कैश मिलते हैं।
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}” आईडी {_1} वाले प्लग-इन से अलग मॉड्यूल है और उसके लिए रखी गई सेटिंग्स और कैश पा लेगा: उपयोगकर्ता की सहमति मिलने पर इसे `replace: true` से इंस्टॉल करें
 	File SHA-256: {hash}	फ़ाइल SHA-256: {hash}
 	Read the objects it is given	उसे दिए गए ऑब्जेक्ट्स पढ़ना
 	Change, add and delete objects in the document	डॉक्यूमेंट में ऑब्जेक्ट्स बदलना, जोड़ना और हटाना
@@ -5237,10 +5249,13 @@
 	Change how the objects its effect is applied to are drawn	जिन ऑब्जेक्ट्स पर उसका इफ़ेक्ट लगा है, उनके बनाए जाने का तरीका बदलना
 	Write the document as a file in its own format	डॉक्यूमेंट को अपने फ़ॉर्मेट की फ़ाइल के रूप में लिखना
 	Show its progress, see Cancel and write log lines	अपनी प्रगति दिखाना, रद्द करने का अनुरोध देखना और लॉग पंक्तियाँ लिखना
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	अनुमति `progress` के लिए प्लग-इन API स्तर {PROGRESS_API} चाहिए: `api` {PROGRESS_API} दें
+	Keep settings of its own	अपनी सेटिंग्स रखना
+	Keep a cache of its own, which you can clear	अपना कैश रखना, जिसे आप साफ़ कर सकते हैं
+	Clear Plug-in Cache	प्लग-इन कैश साफ़ करें
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	अनुमति `{permission}` के लिए प्लग-इन API स्तर {PROGRESS_API} चाहिए: `api` {PROGRESS_API} दें
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	मॉड्यूल `env.{name}` को होस्ट से अलग प्रकार के साथ आयात करता है: होस्ट का प्रकार {signature} है
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	मॉड्यूल `env.{name}` आयात करता है, जिसे प्लग-इन केवल प्लग-इन API स्तर {PROGRESS_API} (`api` {PROGRESS_API}) पर और अनुमति `progress` के साथ उपयोग कर सकता है
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	मॉड्यूल `{from}.{name}` आयात करता है, जिसे होस्ट उपलब्ध नहीं कराता: प्लग-इन केवल `env.vc_progress`, `env.vc_cancelled` और `env.vc_log` (प्लग-इन API स्तर 2) आयात कर सकता है, और कोई WASI, फ़ाइल या नेटवर्क नहीं
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	मॉड्यूल `env.{name}` आयात करता है, जिसे प्लग-इन केवल प्लग-इन API स्तर {PROGRESS_API} (`api` {PROGRESS_API}) पर और अनुमति `{permission}` के साथ उपयोग कर सकता है
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	मॉड्यूल `{from}.{name}` आयात करता है, जिसे होस्ट उपलब्ध नहीं कराता: प्लग-इन केवल वे `env.vc_*` फ़ंक्शन आयात कर सकता है जो docs/plugins.md में सूचीबद्ध हैं (प्लग-इन API स्तर 2), और कोई WASI, फ़ाइल या नेटवर्क नहीं
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` {_1} है; यह होस्ट प्लग-इन API स्तर 1 से {API_LEVEL} तक का समर्थन करता है
 @msg	`grant` must be a list of permission names	`grant` अनुमति नामों की सूची होनी चाहिए
 @msg	`grant` names an unknown permission `{shown}`	`grant` एक अज्ञात अनुमति `{shown}` बताता है
@@ -6379,6 +6394,7 @@
 @msg	invalid image data for `{0}`	`{0}` के लिए अमान्य इमेज डेटा
 @msg	invalid native panel set	अमान्य मूल पैनल सेट
 @msg	invalid object id {value}: expected a non-negative integer	अमान्य ऑब्जेक्ट id {value}: एक गैर-नकारात्मक पूर्णांक की उम्मीद
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` की प्रविष्टि {index} {value} है, गैर-नकारात्मक पूर्णांक ऑब्जेक्ट id नहीं
 @msg	Invalid panel layout; restored the default dock	अमान्य पैनल लेआउट; डिफ़ॉल्ट डॉक पुनर्स्थापित किया गया
 @msg	invalid parameter name {k}	अमान्य पैरामीटर नाम {k}
 @msg	invalid parameters for `{cmd}`: {msg}	`{cmd}` के लिए अमान्य पैरामीटर: {msg}
diff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsv
index 49cd602d7..43ca6a06d 100644
--- a/crates/ui-egui/src/i18n/hu.tsv
+++ b/crates/ui-egui/src/i18n/hu.tsv
@@ -4116,6 +4116,15 @@ mark-style	Japanese	Japán
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko beállításai…
 	Tate-chu-yoko Settings	Tate-chu-yoko beállításai
+	Composite Fonts…	Összetett betűtípusok…
+	Composite Fonts	Összetett betűtípusok
+	Export Composite Fonts	Összetett betűtípusok exportálása
+	Import Composite Fonts	Összetett betűtípusok importálása
+	Delete Font	Betűtípus törlése
+	Kanji	Kandzsi
+	Kana	Kana
+	Numerals	Számjegyek
+	Scale at Center	Méretezés középről
 	Up/Down:	Fel/le:
 	Left/Right:	Balra/jobbra:
 	Technical Drawing	Műszaki rajz
@@ -4748,6 +4757,7 @@ imageTrace	Outline	Körvonal
 @msg	an image VectorCraft can't read was left out	kimaradt egy kép, amelyet a VectorCraft nem tud olvasni
 @msg	graphs come in as plain art, without their data or settings	a diagramok egyszerű grafikaként kerülnek be, adataik és beállításaik nélkül
 @msg	an image whose data is cut short was left out	kimaradt egy csonka adatú kép
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	egy {_1} × {_2} képpontos beágyazott kép {_3} × {_4} képpontosra lett kicsinyítve, hogy a rétegek megmaradjanak
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	a csatolt képek a fájlban mentett kis felbontású előnézetet mutatják, amíg a fájljaik elő nem kerülnek: csatold őket újra a Csatolások panelen
 @msg	linked type areas past VectorCraft's limits were left out	a VectorCraft korlátain túli csatolt szövegterületek kimaradtak
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	a szövegobjektumon belül írásirányt váltó szöveg az első karakterének irányában nyílik meg
@@ -5118,6 +5128,7 @@ imageTrace	Outline	Körvonal
 @msg	object ids are non-negative integers, not {v}	az objektumazonosító nemnegatív egész szám, ez nem az: {v}
 @msg	{key} must be an array of non-negative integer object ids	{key}: objektumazonosítók tömbje kell, mindegyik nemnegatív egész szám
 @msg	invalid object id {value}: expected a non-negative integer	érvénytelen objektumazonosító: {value} (nemnegatív egész szám kell)
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` {index} indexű eleme {value}, nem objektumazonosító (nemnegatív egész szám kell)
 @msg	no such object id {value}	nincs ilyen objektumazonosító: {value}
 @msg	id {value} is a layer, not an object	a(z) {value} azonosító egy réteg, nem objektum
 @msg	id {value} is a layer, not an object; move layers with layer.move	a(z) {value} azonosító egy réteg, nem objektum; a rétegeket a layer.move paranccsal helyezheti át
@@ -5844,6 +5855,9 @@ axis	Y Axis	Y tengely
 	Install “{name}”, which asks for these permissions?	Telepíted a(z) „{name}” bővítményt, amely ezeket az engedélyeket kéri?
 	ID: {id}	Azonosító: {id}
 	Version: {version}	Verzió: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Telepíted a(z) „{name}” bővítményt az azonos azonosítójú bővítmény helyére?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Ez a fájl nem az a bővítmény, amely korábban ezzel az azonosítóval volt telepítve. Megkapja az ehhez az azonosítóhoz tárolt beállításokat és gyorsítótárat.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	a(z) „{name}” más modul, mint a(z) {_1} azonosítójú bővítmény, és megkapná az ahhoz tárolt beállításokat és gyorsítótárat: telepítsd a `replace: true` megadásával, miután a felhasználó beleegyezett
 	File SHA-256: {hash}	A fájl SHA-256 értéke: {hash}
 	Read the objects it is given	Olvashatja a kapott objektumokat
 	Change, add and delete objects in the document	Módosíthat, hozzáadhat és törölhet objektumokat a dokumentumban
@@ -5851,10 +5865,13 @@ axis	Y Axis	Y tengely
 	Change how the objects its effect is applied to are drawn	Módosíthatja, hogyan rajzolódnak ki az objektumok, amelyekre az effektusa alkalmazva van
 	Write the document as a file in its own format	Saját formátumú fájlba írhatja a dokumentumot
 	Show its progress, see Cancel and write log lines	Megjelenítheti az előrehaladását, észlelheti a megszakítást és naplósorokat írhat
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	a `progress` engedélyhez {PROGRESS_API}. szintű bővítmény-API kell: adja meg az `api` {PROGRESS_API} értéket
+	Keep settings of its own	Saját beállításokat tárolhat
+	Keep a cache of its own, which you can clear	Saját gyorsítótárat tárolhat, amelyet Ön kiüríthet
+	Clear Plug-in Cache	Bővítmény gyorsítótárának kiürítése
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	a(z) `{permission}` engedélyhez {PROGRESS_API}. szintű bővítmény-API kell: adja meg az `api` {PROGRESS_API} értéket
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	a modul az `env.{name}` elemet a gazdaprogramétól eltérő típussal importálja: a gazdaprogram típusa {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	a modul importálja az `env.{name}` elemet, amelyet bővítmény csak {PROGRESS_API}. szintű bővítmény-API-val (`api` {PROGRESS_API}) és a `progress` engedéllyel használhat
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	a modul importálja a(z) `{from}.{name}` elemet, amelyet a gazdaprogram nem kínál: bővítmény csak az `env.vc_progress`, `env.vc_cancelled` és `env.vc_log` elemet importálhatja (2. szintű bővítmény-API), WASI-t, fájlokat és hálózatot nem
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	a modul importálja az `env.{name}` elemet, amelyet bővítmény csak {PROGRESS_API}. szintű bővítmény-API-val (`api` {PROGRESS_API}) és a(z) `{permission}` engedéllyel használhat
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	a modul importálja a(z) `{from}.{name}` elemet, amelyet a gazdaprogram nem kínál: bővítmény csak a docs/plugins.md által felsorolt `env.vc_*` függvényeket importálhatja (2. szintű bővítmény-API), WASI-t, fájlokat és hálózatot nem
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	az `api` értéke {_1}; ez a gazdaprogram az 1 és {API_LEVEL} közötti bővítmény-API-szinteket támogatja
 @msg	`grant` must be a list of permission names	a `grant` értékének engedélynevek listájának kell lennie
 @msg	`grant` names an unknown permission `{shown}`	a `grant` ismeretlen engedélyt nevez meg: `{shown}`
diff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsv
index c02f16b52..22b8db56b 100644
--- a/crates/ui-egui/src/i18n/id.tsv
+++ b/crates/ui-egui/src/i18n/id.tsv
@@ -1435,6 +1435,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Pengaturan Tate-chu-yoko…
 	Tate-chu-yoko Settings	Pengaturan Tate-chu-yoko
+	Composite Fonts…	Font komposit…
+	Composite Fonts	Font komposit
+	Export Composite Fonts	Ekspor font komposit
+	Import Composite Fonts	Impor font komposit
+	Delete Font	Hapus font
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Angka
+	Scale at Center	Skalakan dari tengah
 	Up/Down:	Atas/bawah:
 	Left/Right:	Kiri/kanan:
 	Underline	Garis bawah
@@ -4668,6 +4677,7 @@ imageTrace	Outline	Kontur
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	gradien “{name}” tidak didefinisikan dalam berkas: warna polos dipakai sebagai pengganti
 @msg	an image VectorCraft can't read was left out	gambar yang tidak dapat dibaca VectorCraft tidak disertakan
 @msg	an image whose data is cut short was left out	gambar yang datanya terpotong tidak disertakan
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	gambar tersemat berukuran {_1} × {_2} piksel diperkecil menjadi {_3} × {_4} piksel agar lapisannya tetap terjaga
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	gambar tertaut menampilkan pratinjau resolusi rendah yang tersimpan dalam berkas sampai berkasnya ditemukan: tautkan ulang di panel Tautan
 @msg	linked type areas past VectorCraft's limits were left out	area teks tertaut di luar batas VectorCraft dihilangkan
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	teks yang mengubah arah penulisan di dalam objek teks dibuka dengan arah karakter pertamanya
@@ -4703,6 +4713,7 @@ imageTrace	Outline	Kontur
 @msg	object ids are non-negative integers, not {v}	id objek adalah bilangan bulat non-negatif, bukan {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} harus berupa larik id objek yang berupa bilangan bulat non-negatif
 @msg	invalid object id {value}: expected a non-negative integer	id objek {value} tidak valid: harus berupa bilangan bulat non-negatif
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	entri {index} dari `{key}` adalah {value}, bukan id objek (bilangan bulat non-negatif)
 @msg	no such object id {value}	tidak ada objek dengan id {value}
 @msg	automation filesystem access is not granted: read authority is absent: {path}	akses sistem berkas otomatisasi tidak diberikan: otoritas baca tidak ada: {path}
 @msg	automation filesystem access is not granted: write authority is absent: {path}	akses sistem berkas otomatisasi tidak diberikan: otoritas tulis tidak ada: {path}
@@ -5744,6 +5755,8 @@ axis	Y Axis	Sumbu Y
 	Install “{name}”, which asks for these permissions?	Instal “{name}”, yang meminta izin berikut?
 	ID: {id}	ID: {id}
 	Version: {version}	Versi: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Instal “{name}” sebagai pengganti plug-in dengan ID yang sama?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	File ini bukan plug-in yang sebelumnya diinstal dengan ID ini. File ini mendapatkan pengaturan dan cache yang disimpan untuk ID tersebut.
 	File SHA-256: {hash}	SHA-256 file: {hash}
 	Read the objects it is given	Membaca objek yang diberikan kepadanya
 	Change, add and delete objects in the document	Mengubah, menambah, dan menghapus objek dalam dokumen
@@ -5751,6 +5764,9 @@ axis	Y Axis	Sumbu Y
 	Change how the objects its effect is applied to are drawn	Mengubah cara objek yang diberi efeknya digambar
 	Write the document as a file in its own format	Menulis dokumen sebagai file dalam formatnya sendiri
 	Show its progress, see Cancel and write log lines	Menampilkan kemajuannya, mengenali pembatalan, dan menulis baris log
+	Keep settings of its own	Menyimpan pengaturannya sendiri
+	Keep a cache of its own, which you can clear	Menyimpan cache-nya sendiri, yang dapat Anda kosongkan
+	Clear Plug-in Cache	Kosongkan cache plug-in
 # Actions panel: action sets (#3712).
 	New Set…	Set baru…
 	New Set	Set baru
diff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsv
index efd781f71..4f6375c4f 100644
--- a/crates/ui-egui/src/i18n/it.tsv
+++ b/crates/ui-egui/src/i18n/it.tsv
@@ -3499,6 +3499,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Impostazioni Tate-chu-yoko…
 	Tate-chu-yoko Settings	Impostazioni Tate-chu-yoko
+	Composite Fonts…	Font compositi…
+	Composite Fonts	Font compositi
+	Export Composite Fonts	Esporta font compositi
+	Import Composite Fonts	Importa font compositi
+	Delete Font	Elimina font
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Numeri
+	Scale at Center	Ridimensiona dal centro
 	Up/Down:	Su/giù:
 	Left/Right:	Sinistra/destra:
 	Temperature	Temperatura
@@ -4778,6 +4787,7 @@ axis	Both	Entrambi
 @msg	an image VectorCraft can't read was left out	un'immagine che VectorCraft non può leggere è stata omessa
 @msg	graphs come in as plain art, without their data or settings	i grafici vengono importati come grafica semplice, senza i loro dati e le loro impostazioni
 @msg	an image whose data is cut short was left out	un'immagine con dati incompleti è stata omessa
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	un'immagine incorporata di {_1} × {_2} pixel è stata ridotta a {_3} × {_4} pixel per mantenere i livelli
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	le immagini collegate mostrano l'anteprima a bassa risoluzione salvata nel file finché i loro file non vengono trovati: ricollegale nel pannello Collegamenti
 @msg	linked type areas past VectorCraft's limits were left out	le aree di testo concatenate oltre i limiti di VectorCraft sono state omesse
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	il testo che cambia direzione di scrittura all’interno di un oggetto di testo si apre nella direzione del suo primo carattere
@@ -4839,6 +4849,7 @@ axis	Both	Entrambi
 @msg	object ids are non-negative integers, not {v}	gli ID oggetto sono interi non negativi, non {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} deve essere un array di ID oggetto interi non negativi
 @msg	invalid object id {value}: expected a non-negative integer	ID oggetto {value} non valido: è richiesto un intero non negativo
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	la voce {index} di `{key}` è {value}, non un ID oggetto (intero non negativo)
 @msg	no such object id {value}	nessun oggetto con ID {value}
 @msg	id {value} is a layer, not an object	l’ID {value} è un livello, non un oggetto
 @msg	id {value} is a layer, not an object; move layers with layer.move	l’ID {value} è un livello, non un oggetto; sposta i livelli con layer.move
@@ -5477,6 +5488,9 @@ axis	Y Axis	Asse Y
 	Install “{name}”, which asks for these permissions?	Installare “{name}”, che chiede queste autorizzazioni?
 	ID: {id}	ID: {id}
 	Version: {version}	Versione: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Installare “{name}” al posto del plug-in con lo stesso ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Questo file non è il plug-in installato prima con questo ID. Riceve le impostazioni e la cache conservate per quell’ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}” è un modulo diverso dal plug-in con ID {_1} e riceverebbe le impostazioni e la cache conservate per esso: installalo con `replace: true` quando l’utente acconsente
 	File SHA-256: {hash}	SHA-256 del file: {hash}
 	Read the objects it is given	Leggere gli oggetti che riceve
 	Change, add and delete objects in the document	Modificare, aggiungere ed eliminare oggetti nel documento
@@ -5484,10 +5498,13 @@ axis	Y Axis	Asse Y
 	Change how the objects its effect is applied to are drawn	Cambiare il modo in cui vengono disegnati gli oggetti a cui è applicato il suo effetto
 	Write the document as a file in its own format	Scrivere il documento come file in un formato proprio
 	Show its progress, see Cancel and write log lines	Mostrare il proprio avanzamento, rilevare l’annullamento e scrivere righe di registro
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	l’autorizzazione `progress` richiede il livello API dei plug-in {PROGRESS_API}: indicare `api` {PROGRESS_API}
+	Keep settings of its own	Conservare impostazioni proprie
+	Keep a cache of its own, which you can clear	Conservare una cache propria, che è possibile svuotare
+	Clear Plug-in Cache	Svuota cache del plug-in
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	l’autorizzazione `{permission}` richiede il livello API dei plug-in {PROGRESS_API}: indicare `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	il modulo importa `env.{name}` con un tipo diverso da quello dell’host: quello dell’host è {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	il modulo importa `env.{name}`, che un plug-in può usare solo al livello API dei plug-in {PROGRESS_API} (`api` {PROGRESS_API}) e con l’autorizzazione `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	il modulo importa `{from}.{name}`, che l’host non offre: un plug-in può importare solo `env.vc_progress`, `env.vc_cancelled` e `env.vc_log` (livello API dei plug-in 2), e nessun WASI, file o rete
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	il modulo importa `env.{name}`, che un plug-in può usare solo al livello API dei plug-in {PROGRESS_API} (`api` {PROGRESS_API}) e con l’autorizzazione `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	il modulo importa `{from}.{name}`, che l’host non offre: un plug-in può importare solo le funzioni `env.vc_*` elencate in docs/plugins.md (livello API dei plug-in 2), e nessun WASI, file o rete
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` è {_1}; questo host supporta i livelli API dei plug-in da 1 a {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` deve essere un elenco di nomi di autorizzazioni
 @msg	`grant` names an unknown permission `{shown}`	`grant` indica un’autorizzazione sconosciuta `{shown}`
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index eea083135..8c73a1ae0 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -3823,6 +3823,15 @@ file-filter	Templates	テンプレート
 	Tate-chu-yoko	縦中横
 	Tate-chu-yoko Settings…	縦中横の設定…
 	Tate-chu-yoko Settings	縦中横の設定
+	Composite Fonts…	合成フォント…
+	Composite Fonts	合成フォント
+	Export Composite Fonts	合成フォントを書き出し
+	Import Composite Fonts	合成フォントを読み込み
+	Delete Font	フォントを削除
+	Kanji	漢字
+	Kana	かな
+	Numerals	数字
+	Scale at Center	中心から拡大・縮小
 	Up/Down:	上下:
 	Left/Right:	左右:
 	Temperature	色温度
@@ -4462,6 +4471,7 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	an image VectorCraft can't read was left out	VectorCraft で読み込めない画像は除外されました
 @msg	graphs come in as plain art, without their data or settings	グラフは通常のアートとして読み込まれ、データと設定は保持されません
 @msg	an image whose data is cut short was left out	データが途中で切れている画像は除外されました
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	レイヤーを保持するため、{_1} × {_2} ピクセルの埋め込み画像を {_3} × {_4} ピクセルに縮小しました
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	リンク画像は、元のファイルが見つかるまで、ファイルに保存された低解像度のプレビューで表示されます：リンクパネルで再リンクしてください
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft の上限を超えるリンクされたテキストエリアは省略されました
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	テキストオブジェクト内で書字方向が変わる文字は、最初の文字の方向で開きます
@@ -4880,6 +4890,7 @@ swatch	Bright Violet	ビビッドバイオレット
 @msg	object ids are non-negative integers, not {v}	オブジェクト ID は 0 以上の整数です ({v} は使えません)
 @msg	{key} must be an array of non-negative integer object ids	{key} にはオブジェクト ID (0 以上の整数) の配列を指定してください
 @msg	invalid object id {value}: expected a non-negative integer	オブジェクト ID {value} は正しくありません: 0 以上の整数を指定してください
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` の要素 {index} は {value} で、オブジェクト ID (0 以上の整数) ではありません
 @msg	no such object id {value}	ID が {value} のオブジェクトは見つかりません
 @msg	id {value} is a layer, not an object	ID {value} はオブジェクトではなくレイヤーです
 @msg	id {value} is a layer, not an object; move layers with layer.move	ID {value} はオブジェクトではなくレイヤーです。レイヤーは layer.move で移動してください
@@ -5542,6 +5553,9 @@ axis	Y Axis	Y 軸
 	Install “{name}”, which asks for these permissions?	これらの権限を求める「{name}」をインストールしますか？
 	ID: {id}	ID: {id}
 	Version: {version}	バージョン: {version}
+	Install “{name}” in place of the plug-in with the same ID?	同じ ID のプラグインの代わりに「{name}」をインストールしますか？
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	このファイルは、以前にこの ID でインストールされていたプラグインではありません。この ID 用に保持されている設定とキャッシュを引き継ぎます。
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	「{name}」は ID {_1} のプラグインとは別のモジュールで、そのプラグイン用に保持されている設定とキャッシュを引き継ぐことになります。ユーザーが同意したら `replace: true` を指定してインストールしてください
 	File SHA-256: {hash}	ファイルの SHA-256: {hash}
 	Read the objects it is given	渡されたオブジェクトの読み取り
 	Change, add and delete objects in the document	ドキュメント内のオブジェクトの変更、追加、削除
@@ -5549,10 +5563,13 @@ axis	Y Axis	Y 軸
 	Change how the objects its effect is applied to are drawn	効果が適用されたオブジェクトの描画方法の変更
 	Write the document as a file in its own format	ドキュメントを独自形式のファイルとして書き出し
 	Show its progress, see Cancel and write log lines	進行状況の表示、キャンセルの検知、ログ行の書き込み
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	権限 `progress` にはプラグイン API レベル {PROGRESS_API} が必要です。`api` {PROGRESS_API} を指定してください
+	Keep settings of its own	独自の設定の保持
+	Keep a cache of its own, which you can clear	消去できる独自のキャッシュの保持
+	Clear Plug-in Cache	プラグインのキャッシュを消去
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	権限 `{permission}` にはプラグイン API レベル {PROGRESS_API} が必要です。`api` {PROGRESS_API} を指定してください
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	モジュールが `env.{name}` をホストと異なる型でインポートしています。ホストの型は {signature} です
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	モジュールが `env.{name}` をインポートしていますが、プラグインがこれを使用できるのはプラグイン API レベル {PROGRESS_API} (`api` {PROGRESS_API}) で権限 `progress` がある場合だけです
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	モジュールがホストの提供しない `{from}.{name}` をインポートしています。プラグインがインポートできるのは `env.vc_progress`、`env.vc_cancelled`、`env.vc_log` (プラグイン API レベル 2) だけで、WASI、ファイル、ネットワークは使用できません
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	モジュールが `env.{name}` をインポートしていますが、プラグインがこれを使用できるのはプラグイン API レベル {PROGRESS_API} (`api` {PROGRESS_API}) で権限 `{permission}` がある場合だけです
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	モジュールがホストの提供しない `{from}.{name}` をインポートしています。プラグインがインポートできるのは docs/plugins.md に記載された `env.vc_*` 関数 (プラグイン API レベル 2) だけで、WASI、ファイル、ネットワークは使用できません
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` は {_1} です。このホストが対応するプラグイン API レベルは 1 から {API_LEVEL} です
 @msg	`grant` must be a list of permission names	`grant` は権限名のリストにしてください
 @msg	`grant` names an unknown permission `{shown}`	`grant` に不明な権限 `{shown}` が含まれています
diff --git a/crates/ui-egui/src/i18n/ka.tsv b/crates/ui-egui/src/i18n/ka.tsv
index bb6eeb41c..5d40de893 100644
--- a/crates/ui-egui/src/i18n/ka.tsv
+++ b/crates/ui-egui/src/i18n/ka.tsv
@@ -1360,6 +1360,15 @@ digits	Malayalam	მალაიალამური
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko პარამეტრები…
 	Tate-chu-yoko Settings	Tate-chu-yoko პარამეტრები
+	Composite Fonts…	კომპოზიტური შრიფტები…
+	Composite Fonts	კომპოზიტური შრიფტები
+	Export Composite Fonts	კომპოზიტური შრიფტების ექსპორტი
+	Import Composite Fonts	კომპოზიტური შრიფტების იმპორტი
+	Delete Font	შრიფტის წაშლა
+	Kanji	კანძი
+	Kana	კანა
+	Numerals	ციფრები
+	Scale at Center	ცენტრიდან მასშტაბირება
 	Up/Down:	ზემოთ/ქვემოთ:
 	Left/Right:	მარცხნივ/მარჯვნივ:
 	Underline	ხაზგასმული
@@ -4472,6 +4481,7 @@ font-technology	Variable	ცვლადი
 @msg	an image VectorCraft can't read was left out	გამოსახულება, რომელსაც VectorCraft ვერ კითხულობს, გამოტოვებულია
 @msg	graphs come in as plain art, without their data or settings	დიაგრამები შემოდის როგორც ჩვეულებრივი გრაფიკა, მათი მონაცემებისა და პარამეტრების გარეშე
 @msg	an image whose data is cut short was left out	გამოსახულება, რომლის მონაცემებიც შეკვეცილია, გამოტოვებულია
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	ჩაშენებული გამოსახულება ზომით {_1} × {_2} პიქსელი შემცირდა {_3} × {_4} პიქსელამდე, რომ შრეები შენარჩუნდეს
 @msg	its editing data doesn't say where its art is	მისი რედაქტირების მონაცემები არ მიუთითებს, სად არის მისი ნახატი
 @msg	this file was saved without PDF compatibility, and its editing data can't be read ({why})	ეს ფაილი PDF-თავსებადობის გარეშეა შენახული და მისი რედაქტირების მონაცემების წაკითხვა ვერ ხერხდება ({why})
 @msg	the PDF part couldn't be read ({_1}): the file opened from its editing data	PDF ნაწილის წაკითხვა ვერ მოხერხდა ({_1}): ფაილი რედაქტირების მონაცემებიდან გაიხსნა
@@ -4499,6 +4509,7 @@ font-technology	Variable	ცვლადი
 @msg	object ids are non-negative integers, not {v}	ობიექტების id არაუარყოფითი მთელი რიცხვებია და არა {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} უნდა იყოს ობიექტების id-ების მასივი, სადაც ყოველი id არაუარყოფითი მთელი რიცხვია
 @msg	invalid object id {value}: expected a non-negative integer	ობიექტის არასწორი id {value}: მოსალოდნელია არაუარყოფითი მთელი რიცხვი
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}`-ის ელემენტი {index} არის {value} და არა ობიექტის id (არაუარყოფითი მთელი რიცხვი)
 @msg	no such object id {value}	ობიექტი id-ით {value} არ არსებობს
 @msg	id {value} is a layer, not an object	id {value} შრეა და არა ობიექტი
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} შრეა და არა ობიექტი; შრეების გადასატანად გამოიყენეთ layer.move
@@ -5785,6 +5796,9 @@ axis	Y Axis	Y ღერძი
 	Install “{name}”, which asks for these permissions?	დავაყენოთ „{name}“, რომელიც ამ ნებართვებს ითხოვს?
 	ID: {id}	ID: {id}
 	Version: {version}	ვერსია: {version}
+	Install “{name}” in place of the plug-in with the same ID?	დავაყენოთ „{name}“ იმავე ID-ის მქონე პლაგინის ნაცვლად?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	ეს ფაილი არ არის ამ ID-ით ადრე დაყენებული პლაგინი. ის მიიღებს ამ ID-სთვის შენახულ პარამეტრებს და ქეშს.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	„{name}“ სხვა მოდულია, ვიდრე პლაგინი ID-ით {_1}, და მიიღებდა მისთვის შენახულ პარამეტრებს და ქეშს: მომხმარებლის თანხმობის შემდეგ დააყენეთ ის `replace: true` პარამეტრით
 	File SHA-256: {hash}	ფაილის SHA-256: {hash}
 	Read the objects it is given	მიღებული ობიექტების წაკითხვა
 	Change, add and delete objects in the document	დოკუმენტში ობიექტების შეცვლა, დამატება და წაშლა
@@ -5792,10 +5806,13 @@ axis	Y Axis	Y ღერძი
 	Change how the objects its effect is applied to are drawn	იმის შეცვლა, თუ როგორ იხატება ობიექტები, რომლებზეც მისი ეფექტია გამოყენებული
 	Write the document as a file in its own format	დოკუმენტის ჩაწერა ფაილად საკუთარ ფორმატში
 	Show its progress, see Cancel and write log lines	პროგრესის ჩვენება, გაუქმების შემჩნევა და ჟურნალის სტრიქონების ჩაწერა
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	ნებართვას `progress` სჭირდება პლაგინის API-ის დონე {PROGRESS_API}: მიუთითეთ `api` {PROGRESS_API}
+	Keep settings of its own	საკუთარი პარამეტრების შენახვა
+	Keep a cache of its own, which you can clear	საკუთარი ქეშის შენახვა, რომლის გასუფთავებაც შეგიძლიათ
+	Clear Plug-in Cache	პლაგინის ქეშის გასუფთავება
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	ნებართვას `{permission}` სჭირდება პლაგინის API-ის დონე {PROGRESS_API}: მიუთითეთ `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	მოდულს შემოაქვს `env.{name}` ჰოსტისგან განსხვავებული ტიპით: ჰოსტის ტიპია {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	მოდულს შემოაქვს `env.{name}`, რომლის გამოყენებაც პლაგინს მხოლოდ პლაგინის API-ის დონეზე {PROGRESS_API} (`api` {PROGRESS_API}) და ნებართვით `progress` შეუძლია
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	მოდულს შემოაქვს `{from}.{name}`, რომელსაც ჰოსტი არ გვთავაზობს: პლაგინს შეუძლია შემოიტანოს მხოლოდ `env.vc_progress`, `env.vc_cancelled` და `env.vc_log` (პლაგინის API-ის დონე 2) და არა WASI, ფაილები ან ქსელი
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	მოდულს შემოაქვს `env.{name}`, რომლის გამოყენებაც პლაგინს მხოლოდ პლაგინის API-ის დონეზე {PROGRESS_API} (`api` {PROGRESS_API}) და ნებართვით `{permission}` შეუძლია
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	მოდულს შემოაქვს `{from}.{name}`, რომელსაც ჰოსტი არ გვთავაზობს: პლაგინს შეუძლია შემოიტანოს მხოლოდ docs/plugins.md-ში ჩამოთვლილი `env.vc_*` ფუნქციები (პლაგინის API-ის დონე 2) და არა WASI, ფაილები ან ქსელი
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` არის {_1}; ეს ჰოსტი პლაგინის API-ის დონეებს 1-დან {API_LEVEL}-მდე უჭერს მხარს
 @msg	`grant` must be a list of permission names	`grant` ნებართვების სახელების სია უნდა იყოს
 @msg	`grant` names an unknown permission `{shown}`	`grant` უცნობ ნებართვას ასახელებს: `{shown}`
diff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsv
index 6246149a2..30a409b72 100644
--- a/crates/ui-egui/src/i18n/ko.tsv
+++ b/crates/ui-egui/src/i18n/ko.tsv
@@ -3811,6 +3811,15 @@ file-filter	Templates	템플릿
 	Tate-chu-yoko	다테추요코
 	Tate-chu-yoko Settings…	다테추요코 설정…
 	Tate-chu-yoko Settings	다테추요코 설정
+	Composite Fonts…	합성 글꼴…
+	Composite Fonts	합성 글꼴
+	Export Composite Fonts	합성 글꼴 내보내기
+	Import Composite Fonts	합성 글꼴 가져오기
+	Delete Font	글꼴 삭제
+	Kanji	한자
+	Kana	가나
+	Numerals	숫자
+	Scale at Center	중심에서 크기 조정
 	Up/Down:	위/아래:
 	Left/Right:	왼쪽/오른쪽:
 	Temperature	색온도
@@ -4389,6 +4398,7 @@ theme	Appearance	외관
 @msg	an image VectorCraft can't read was left out	VectorCraft가 읽을 수 없는 이미지는 제외했습니다
 @msg	graphs come in as plain art, without their data or settings	그래프는 데이터와 설정 없이 일반 아트로 가져왔습니다
 @msg	an image whose data is cut short was left out	데이터가 잘린 이미지는 제외했습니다
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	레이어를 유지하기 위해 {_1} × {_2} 픽셀의 포함된 이미지를 {_3} × {_4} 픽셀로 줄였습니다
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	연결된 그림은 해당 파일을 찾을 때까지 파일에 저장된 저해상도 미리 보기로 표시됩니다: 링크 패널에서 다시 연결하세요
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft 한도를 넘는 연결된 문자 영역은 제외되었습니다
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	문자 개체 안에서 쓰기 방향이 바뀌는 문자는 첫 글자의 방향으로 열립니다
@@ -4807,6 +4817,7 @@ theme	Appearance	외관
 @msg	object ids are non-negative integers, not {v}	개체 id는 음이 아닌 정수여야 하며 {v}은(는) 안 됩니다
 @msg	{key} must be an array of non-negative integer object ids	{key}은(는) 음이 아닌 정수인 개체 id의 배열이어야 합니다
 @msg	invalid object id {value}: expected a non-negative integer	개체 id {value}이(가) 올바르지 않습니다: 음이 아닌 정수여야 합니다
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}`의 항목 {index}은(는) {value}이며, 음이 아닌 정수인 개체 id가 아닙니다
 @msg	no such object id {value}	id가 {value}인 개체가 없습니다
 @msg	id {value} is a layer, not an object	id {value}은(는) 개체가 아닌 레이어입니다
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value}은(는) 개체가 아닌 레이어입니다. 레이어는 layer.move로 이동하세요
@@ -5438,6 +5449,9 @@ axis	Y Axis	Y축
 	Install “{name}”, which asks for these permissions?	이 권한을 요청하는 “{name}”을(를) 설치하시겠습니까?
 	ID: {id}	ID: {id}
 	Version: {version}	버전: {version}
+	Install “{name}” in place of the plug-in with the same ID?	같은 ID의 플러그인 대신 “{name}”을(를) 설치하시겠습니까?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	이 파일은 이전에 이 ID로 설치된 플러그인이 아닙니다. 이 ID에 보관된 설정과 캐시를 받습니다.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}”은(는) ID {_1}의 플러그인과 다른 모듈이며 그 플러그인에 보관된 설정과 캐시를 받게 됩니다. 사용자가 동의하면 `replace: true`로 설치하세요
 	File SHA-256: {hash}	파일 SHA-256: {hash}
 	Read the objects it is given	전달받은 개체 읽기
 	Change, add and delete objects in the document	문서의 개체 변경, 추가 및 삭제
@@ -5445,10 +5459,13 @@ axis	Y Axis	Y축
 	Change how the objects its effect is applied to are drawn	효과가 적용된 개체가 그려지는 방식 변경
 	Write the document as a file in its own format	문서를 자체 형식의 파일로 쓰기
 	Show its progress, see Cancel and write log lines	진행률 표시, 취소 감지 및 로그 줄 쓰기
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	`progress` 권한에는 플러그인 API 수준 {PROGRESS_API}이(가) 필요합니다. `api` {PROGRESS_API}을(를) 지정하십시오
+	Keep settings of its own	자체 설정 보관
+	Keep a cache of its own, which you can clear	지울 수 있는 자체 캐시 보관
+	Clear Plug-in Cache	플러그인 캐시 지우기
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	`{permission}` 권한에는 플러그인 API 수준 {PROGRESS_API}이(가) 필요합니다. `api` {PROGRESS_API}을(를) 지정하십시오
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	모듈이 `env.{name}`을(를) 호스트와 다른 형식으로 가져옵니다. 호스트의 형식은 {signature}입니다
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	모듈이 `env.{name}`을(를) 가져오지만, 플러그인은 이를 플러그인 API 수준 {PROGRESS_API}(`api` {PROGRESS_API})에서 `progress` 권한이 있을 때만 사용할 수 있습니다
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	모듈이 호스트가 제공하지 않는 `{from}.{name}`을(를) 가져옵니다. 플러그인은 `env.vc_progress`, `env.vc_cancelled`, `env.vc_log`(플러그인 API 수준 2)만 가져올 수 있으며 WASI, 파일, 네트워크는 사용할 수 없습니다
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	모듈이 `env.{name}`을(를) 가져오지만, 플러그인은 이를 플러그인 API 수준 {PROGRESS_API}(`api` {PROGRESS_API})에서 `{permission}` 권한이 있을 때만 사용할 수 있습니다
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	모듈이 호스트가 제공하지 않는 `{from}.{name}`을(를) 가져옵니다. 플러그인은 docs/plugins.md에 나열된 `env.vc_*` 함수(플러그인 API 수준 2)만 가져올 수 있으며 WASI, 파일, 네트워크는 사용할 수 없습니다
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api`가 {_1}입니다. 이 호스트는 플러그인 API 수준 1부터 {API_LEVEL}까지 지원합니다
 @msg	`grant` must be a list of permission names	`grant`는 권한 이름 목록이어야 합니다
 @msg	`grant` names an unknown permission `{shown}`	`grant`에 알 수 없는 권한 `{shown}`이(가) 있습니다
diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsv
index d3e8ee5a8..c771d8b17 100644
--- a/crates/ui-egui/src/i18n/nl.tsv
+++ b/crates/ui-egui/src/i18n/nl.tsv
@@ -1449,6 +1449,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko-instellingen…
 	Tate-chu-yoko Settings	Tate-chu-yoko-instellingen
+	Composite Fonts…	Samengestelde lettertypen…
+	Composite Fonts	Samengestelde lettertypen
+	Export Composite Fonts	Samengestelde lettertypen exporteren
+	Import Composite Fonts	Samengestelde lettertypen importeren
+	Delete Font	Lettertype verwijderen
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Cijfers
+	Scale at Center	Schalen vanuit het midden
 	Up/Down:	Omhoog/omlaag:
 	Left/Right:	Links/rechts:
 	Underline	Onderstrepen
@@ -4680,6 +4689,7 @@ imageTrace	Outline	Contour
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	verloop „{name}” is niet gedefinieerd in het bestand: er is een effen kleur voor gebruikt
 @msg	an image VectorCraft can't read was left out	een afbeelding die VectorCraft niet kan lezen, is weggelaten
 @msg	an image whose data is cut short was left out	een afbeelding waarvan de gegevens zijn afgekapt, is weggelaten
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	een ingesloten afbeelding van {_1} × {_2} pixels is verkleind tot {_3} × {_4} pixels om de lagen te behouden
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	gekoppelde afbeeldingen tonen het in het bestand opgeslagen voorbeeld met lage resolutie totdat hun bestanden zijn gevonden: koppel ze opnieuw in het paneel Koppelingen
 @msg	linked type areas past VectorCraft's limits were left out	gekoppelde tekstvlakken buiten de limieten van VectorCraft zijn weggelaten
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst die binnen een tekstobject van schrijfrichting verandert, wordt geopend in de richting van het eerste teken
@@ -4715,6 +4725,7 @@ imageTrace	Outline	Contour
 @msg	object ids are non-negative integers, not {v}	object-id's zijn niet-negatieve gehele getallen, niet {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} moet een array van object-id's zijn die niet-negatieve gehele getallen zijn
 @msg	invalid object id {value}: expected a non-negative integer	ongeldige object-id {value}: een niet-negatief geheel getal verwacht
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	item {index} van `{key}` is {value}, geen object-id (een niet-negatief geheel getal)
 @msg	no such object id {value}	er is geen object met id {value}
 @msg	automation filesystem access is not granted: read authority is absent: {path}	toegang tot het bestandssysteem voor automatisering is niet verleend: de leesbevoegdheid ontbreekt: {path}
 @msg	automation filesystem access is not granted: write authority is absent: {path}	toegang tot het bestandssysteem voor automatisering is niet verleend: de schrijfbevoegdheid ontbreekt: {path}
@@ -5790,6 +5801,8 @@ axis	Y Axis	Y-as
 	Install “{name}”, which asks for these permissions?	„{name}” installeren, dat om deze machtigingen vraagt?
 	ID: {id}	ID: {id}
 	Version: {version}	Versie: {version}
+	Install “{name}” in place of the plug-in with the same ID?	„{name}” installeren in plaats van de plug-in met dezelfde ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Dit bestand is niet de plug-in die eerder met deze ID was geïnstalleerd. Het krijgt de instellingen en cache die voor die ID bewaard zijn.
 	File SHA-256: {hash}	SHA-256 van het bestand: {hash}
 	Read the objects it is given	De objecten lezen die het krijgt
 	Change, add and delete objects in the document	Objecten in het document wijzigen, toevoegen en verwijderen
@@ -5797,6 +5810,9 @@ axis	Y Axis	Y-as
 	Change how the objects its effect is applied to are drawn	Wijzigen hoe de objecten waarop het effect is toegepast worden getekend
 	Write the document as a file in its own format	Het document als bestand in een eigen indeling schrijven
 	Show its progress, see Cancel and write log lines	De voortgang tonen, een annulering zien en logregels schrijven
+	Keep settings of its own	Eigen instellingen bewaren
+	Keep a cache of its own, which you can clear	Een eigen cache bewaren, die u kunt legen
+	Clear Plug-in Cache	Plug-incache legen
 # Actions panel: action sets (#3712).
 	New Set…	Nieuwe set…
 	New Set	Nieuwe set
diff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsv
index 04545e4e5..bdd887ecd 100644
--- a/crates/ui-egui/src/i18n/pl.tsv
+++ b/crates/ui-egui/src/i18n/pl.tsv
@@ -1437,6 +1437,15 @@ digits	Malayalam	Malajalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Ustawienia Tate-chu-yoko…
 	Tate-chu-yoko Settings	Ustawienia Tate-chu-yoko
+	Composite Fonts…	Fonty złożone…
+	Composite Fonts	Fonty złożone
+	Export Composite Fonts	Eksportuj fonty złożone
+	Import Composite Fonts	Importuj fonty złożone
+	Delete Font	Usuń font
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Cyfry
+	Scale at Center	Skaluj od środka
 	Up/Down:	W górę/w dół:
 	Left/Right:	W lewo/w prawo:
 	Underline	Podkreślenie
@@ -4870,6 +4879,7 @@ imageTrace	Outline	Kontur
 @msg	an image VectorCraft can't read was left out	pominięto obraz, którego VectorCraft nie potrafi odczytać
 @msg	graphs come in as plain art, without their data or settings	wykresy są wczytywane jako zwykła grafika, bez ich danych i ustawień
 @msg	an image whose data is cut short was left out	pominięto obraz z uciętymi danymi
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	osadzony obraz o wymiarach {_1} × {_2} pikseli zmniejszono do {_3} × {_4} pikseli, aby zachować warstwy
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	połączone obrazy pokazują zapisany w pliku podgląd niskiej rozdzielczości, dopóki ich pliki nie zostaną znalezione: połącz je ponownie w panelu Łącza
 @msg	linked type areas past VectorCraft's limits were left out	połączone obszary tekstu poza limitami VectorCraft zostały pominięte
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	tekst zmieniający kierunek pisania wewnątrz obiektu tekstowego otwiera się w kierunku swojego pierwszego znaku
@@ -4905,6 +4915,7 @@ imageTrace	Outline	Kontur
 @msg	object ids are non-negative integers, not {v}	identyfikatory obiektów to nieujemne liczby całkowite, nie {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} musi być tablicą identyfikatorów obiektów, które są nieujemnymi liczbami całkowitymi
 @msg	invalid object id {value}: expected a non-negative integer	nieprawidłowy identyfikator obiektu {value}: oczekiwano nieujemnej liczby całkowitej
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	element {index} w `{key}` to {value}, a nie identyfikator obiektu (nieujemna liczba całkowita)
 @msg	no such object id {value}	brak obiektu o identyfikatorze {value}
 @msg	id {value} is a layer, not an object	identyfikator {value} oznacza warstwę, a nie obiekt
 @msg	id {value} is a layer, not an object; move layers with layer.move	identyfikator {value} oznacza warstwę, a nie obiekt; warstwy przenosi się za pomocą layer.move
@@ -5714,6 +5725,9 @@ axis	Y Axis	Oś Y
 	Install “{name}”, which asks for these permissions?	Zainstalować „{name}”, wtyczkę, która prosi o te uprawnienia?
 	ID: {id}	ID: {id}
 	Version: {version}	Wersja: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Zainstalować „{name}” zamiast wtyczki o tym samym ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Ten plik nie jest wtyczką zainstalowaną wcześniej z tym ID. Otrzyma ustawienia i pamięć podręczną przechowywane dla tego ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	„{name}” to inny moduł niż wtyczka o ID {_1} i otrzymałby przechowywane dla niej ustawienia i pamięć podręczną: zainstaluj go z `replace: true`, gdy użytkownik się zgodzi
 	File SHA-256: {hash}	SHA-256 pliku: {hash}
 	Read the objects it is given	Odczytywać obiekty, które otrzymuje
 	Change, add and delete objects in the document	Zmieniać, dodawać i usuwać obiekty w dokumencie
@@ -5721,10 +5735,13 @@ axis	Y Axis	Oś Y
 	Change how the objects its effect is applied to are drawn	Zmieniać sposób rysowania obiektów, do których zastosowano jej efekt
 	Write the document as a file in its own format	Zapisywać dokument jako plik we własnym formacie
 	Show its progress, see Cancel and write log lines	Pokazywać swój postęp, wykrywać anulowanie i zapisywać wiersze dziennika
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	uprawnienie `progress` wymaga poziomu API wtyczek {PROGRESS_API}: podaj `api` {PROGRESS_API}
+	Keep settings of its own	Przechowywać własne ustawienia
+	Keep a cache of its own, which you can clear	Przechowywać własną pamięć podręczną, którą możesz wyczyścić
+	Clear Plug-in Cache	Wyczyść pamięć podręczną wtyczki
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	uprawnienie `{permission}` wymaga poziomu API wtyczek {PROGRESS_API}: podaj `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	moduł importuje `env.{name}` z innym typem niż typ hosta: typ hosta to {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	moduł importuje `env.{name}`, którego wtyczka może używać tylko na poziomie API wtyczek {PROGRESS_API} (`api` {PROGRESS_API}) i z uprawnieniem `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	moduł importuje `{from}.{name}`, którego host nie udostępnia: wtyczka może importować tylko `env.vc_progress`, `env.vc_cancelled` i `env.vc_log` (poziom API wtyczek 2), bez WASI, plików i sieci
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	moduł importuje `env.{name}`, którego wtyczka może używać tylko na poziomie API wtyczek {PROGRESS_API} (`api` {PROGRESS_API}) i z uprawnieniem `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	moduł importuje `{from}.{name}`, którego host nie udostępnia: wtyczka może importować tylko funkcje `env.vc_*` wymienione w docs/plugins.md (poziom API wtyczek 2), bez WASI, plików i sieci
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` ma wartość {_1}; ten host obsługuje poziomy API wtyczek od 1 do {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` musi być listą nazw uprawnień
 @msg	`grant` names an unknown permission `{shown}`	`grant` wymienia nieznane uprawnienie `{shown}`
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index 382fc086c..822a0d59e 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -4315,6 +4315,7 @@ axis	Both	Ambos
 @msg	an image VectorCraft can't read was left out	uma imagem que o VectorCraft não consegue ler foi omitida
 @msg	graphs come in as plain art, without their data or settings	os gráficos são importados como arte comum, sem seus dados nem configurações
 @msg	an image whose data is cut short was left out	uma imagem com dados incompletos foi omitida
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	uma imagem incorporada de {_1} × {_2} pixels foi reduzida para {_3} × {_4} pixels para manter as camadas
 @msg	its editing data doesn't say where its art is	seus dados de edição não indicam onde está a arte
 @msg	this file was saved without PDF compatibility, and its editing data can't be read ({why})	este arquivo foi salvo sem compatibilidade com PDF e seus dados de edição não podem ser lidos ({why})
 @msg	the PDF part couldn't be read ({_1}): the file opened from its editing data	não foi possível ler a parte PDF ({_1}): o arquivo foi aberto a partir dos seus dados de edição
@@ -4343,6 +4344,7 @@ axis	Both	Ambos
 @msg	object ids are non-negative integers, not {v}	os ids de objeto são inteiros não negativos, não {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} deve ser uma matriz de ids de objeto que sejam inteiros não negativos
 @msg	invalid object id {value}: expected a non-negative integer	id de objeto inválido {value}: era esperado um inteiro não negativo
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	a entrada {index} de `{key}` é {value}, não um id de objeto (inteiro não negativo)
 @msg	no such object id {value}	não existe objeto com o id {value}
 @msg	id {value} is a layer, not an object	o id {value} é uma camada, não um objeto
 @msg	id {value} is a layer, not an object; move layers with layer.move	o id {value} é uma camada, não um objeto; mova camadas com layer.move
@@ -4912,6 +4914,15 @@ axis	Both	Ambos
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Configurações de Tate-chu-yoko…
 	Tate-chu-yoko Settings	Configurações de Tate-chu-yoko
+	Composite Fonts…	Fontes compostas…
+	Composite Fonts	Fontes compostas
+	Export Composite Fonts	Exportar fontes compostas
+	Import Composite Fonts	Importar fontes compostas
+	Delete Font	Excluir fonte
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Números
+	Scale at Center	Dimensionar a partir do centro
 	Up/Down:	Para Cima/Para Baixo:
 	Left/Right:	Esquerda/Direita:
 	Temperature	Temperatura
@@ -5776,6 +5787,9 @@ axis	Y Axis	Eixo Y
 	Install “{name}”, which asks for these permissions?	Instalar “{name}”, que pede estas permissões?
 	ID: {id}	ID: {id}
 	Version: {version}	Versão: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Instalar “{name}” no lugar do plug-in com o mesmo ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Este arquivo não é o plug-in instalado antes com este ID. Ele recebe as configurações e o cache guardados para esse ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}” é um módulo diferente do plug-in com ID {_1} e receberia as configurações e o cache guardados para ele: instale-o com `replace: true` depois que o usuário concordar
 	File SHA-256: {hash}	SHA-256 do arquivo: {hash}
 	Read the objects it is given	Ler os objetos que recebe
 	Change, add and delete objects in the document	Alterar, adicionar e excluir objetos no documento
@@ -5783,10 +5797,13 @@ axis	Y Axis	Eixo Y
 	Change how the objects its effect is applied to are drawn	Alterar como são desenhados os objetos aos quais seu efeito é aplicado
 	Write the document as a file in its own format	Gravar o documento como um arquivo em formato próprio
 	Show its progress, see Cancel and write log lines	Mostrar seu progresso, detectar o cancelamento e gravar linhas de log
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	a permissão `progress` exige o nível de API de plug-in {PROGRESS_API}: informe `api` {PROGRESS_API}
+	Keep settings of its own	Guardar configurações próprias
+	Keep a cache of its own, which you can clear	Guardar um cache próprio, que você pode limpar
+	Clear Plug-in Cache	Limpar cache do plug-in
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	a permissão `{permission}` exige o nível de API de plug-in {PROGRESS_API}: informe `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	o módulo importa `env.{name}` com um tipo diferente do tipo do host: o do host é {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	o módulo importa `env.{name}`, que um plug-in só pode usar no nível de API de plug-in {PROGRESS_API} (`api` {PROGRESS_API}) e com a permissão `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	o módulo importa `{from}.{name}`, que o host não oferece: um plug-in só pode importar `env.vc_progress`, `env.vc_cancelled` e `env.vc_log` (nível de API de plug-in 2), e nenhum WASI, arquivo ou rede
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	o módulo importa `env.{name}`, que um plug-in só pode usar no nível de API de plug-in {PROGRESS_API} (`api` {PROGRESS_API}) e com a permissão `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	o módulo importa `{from}.{name}`, que o host não oferece: um plug-in só pode importar as funções `env.vc_*` listadas em docs/plugins.md (nível de API de plug-in 2), e nenhum WASI, arquivo ou rede
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` é {_1}; este host aceita os níveis de API de plug-in de 1 a {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` deve ser uma lista de nomes de permissões
 @msg	`grant` names an unknown permission `{shown}`	`grant` cita uma permissão desconhecida `{shown}`
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index f5980891e..54158fab4 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -3494,6 +3494,15 @@ digits	Malayalam	Малаялам
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Параметры Tate-chu-yoko…
 	Tate-chu-yoko Settings	Параметры Tate-chu-yoko
+	Composite Fonts…	Составные шрифты…
+	Composite Fonts	Составные шрифты
+	Export Composite Fonts	Экспорт составных шрифтов
+	Import Composite Fonts	Импорт составных шрифтов
+	Delete Font	Удалить шрифт
+	Kanji	Кандзи
+	Kana	Кана
+	Numerals	Цифры
+	Scale at Center	Масштабировать от центра
 	Up/Down:	Вверх/вниз:
 	Left/Right:	Влево/вправо:
 	Temperature	Температура
@@ -4773,6 +4782,7 @@ axis	Both	Оба
 @msg	an image VectorCraft can't read was left out	изображение, которое VectorCraft не может прочитать, пропущено
 @msg	graphs come in as plain art, without their data or settings	диаграммы импортируются как обычная графика, без их данных и настроек
 @msg	an image whose data is cut short was left out	изображение с обрезанными данными пропущено
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	встроенное изображение {_1} × {_2} пикселей уменьшено до {_3} × {_4} пикселей, чтобы сохранить слои
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	связанные изображения показываются как сохранённый в файле просмотр низкого разрешения, пока их файлы не найдены: восстановите связи на панели «Связи»
 @msg	linked type areas past VectorCraft's limits were left out	связанные текстовые области за пределами ограничений VectorCraft пропущены
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, меняющий направление письма внутри текстового объекта, открывается в направлении своего первого символа
@@ -4836,6 +4846,7 @@ axis	Both	Оба
 @msg	object ids are non-negative integers, not {v}	идентификаторы объектов — неотрицательные целые числа, а не {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} должно быть массивом идентификаторов объектов, которые являются неотрицательными целыми числами
 @msg	invalid object id {value}: expected a non-negative integer	недопустимый идентификатор объекта {value}: ожидается неотрицательное целое число
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	элемент {index} в `{key}` равен {value}, а не идентификатору объекта (неотрицательному целому числу)
 @msg	no such object id {value}	объект с идентификатором {value} не существует
 @msg	id {value} is a layer, not an object	идентификатор {value} относится к слою, а не к объекту
 @msg	id {value} is a layer, not an object; move layers with layer.move	идентификатор {value} относится к слою, а не к объекту; перемещайте слои с помощью layer.move
@@ -5472,6 +5483,9 @@ axis	Y Axis	Ось Y
 	Install “{name}”, which asks for these permissions?	Установить «{name}», которому нужны эти разрешения?
 	ID: {id}	ID: {id}
 	Version: {version}	Версия: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Установить «{name}» вместо модуля с тем же ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Этот файл не является модулем, установленным ранее с этим ID. Он получит настройки и кэш, сохранённые для этого ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	«{name}» отличается от модуля с ID {_1} и получил бы сохранённые для него настройки и кэш: установите его с `replace: true`, когда пользователь согласится
 	File SHA-256: {hash}	SHA-256 файла: {hash}
 	Read the objects it is given	Читать переданные ему объекты
 	Change, add and delete objects in the document	Изменять, добавлять и удалять объекты в документе
@@ -5479,10 +5493,13 @@ axis	Y Axis	Ось Y
 	Change how the objects its effect is applied to are drawn	Изменять то, как рисуются объекты, к которым применён его эффект
 	Write the document as a file in its own format	Записывать документ в файл собственного формата
 	Show its progress, see Cancel and write log lines	Показывать свой ход выполнения, замечать отмену и записывать строки журнала
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	разрешению `progress` нужен уровень API модулей {PROGRESS_API}: укажите `api` {PROGRESS_API}
+	Keep settings of its own	Хранить собственные настройки
+	Keep a cache of its own, which you can clear	Хранить собственный кэш, который можно очистить
+	Clear Plug-in Cache	Очистить кэш модуля
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	разрешению `{permission}` нужен уровень API модулей {PROGRESS_API}: укажите `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	модуль импортирует `env.{name}` с другим типом, чем у хоста: у хоста тип {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	модуль импортирует `env.{name}`, который модуль может использовать только на уровне API модулей {PROGRESS_API} (`api` {PROGRESS_API}) и с разрешением `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	модуль импортирует `{from}.{name}`, который хост не предоставляет: модуль может импортировать только `env.vc_progress`, `env.vc_cancelled` и `env.vc_log` (уровень API модулей 2), без WASI, файлов и сети
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	модуль импортирует `env.{name}`, который модуль может использовать только на уровне API модулей {PROGRESS_API} (`api` {PROGRESS_API}) и с разрешением `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	модуль импортирует `{from}.{name}`, который хост не предоставляет: модуль может импортировать только функции `env.vc_*`, перечисленные в docs/plugins.md (уровень API модулей 2), без WASI, файлов и сети
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` равно {_1}; этот хост поддерживает уровни API модулей от 1 до {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` должен быть списком имён разрешений
 @msg	`grant` names an unknown permission `{shown}`	`grant` называет неизвестное разрешение `{shown}`
diff --git a/crates/ui-egui/src/i18n/sv.tsv b/crates/ui-egui/src/i18n/sv.tsv
index a0539f5cb..a872e969a 100644
--- a/crates/ui-egui/src/i18n/sv.tsv
+++ b/crates/ui-egui/src/i18n/sv.tsv
@@ -3385,6 +3385,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Inställningar för Tate-chu-yoko…
 	Tate-chu-yoko Settings	Inställningar för Tate-chu-yoko
+	Composite Fonts…	Sammansatta teckensnitt…
+	Composite Fonts	Sammansatta teckensnitt
+	Export Composite Fonts	Exportera sammansatta teckensnitt
+	Import Composite Fonts	Importera sammansatta teckensnitt
+	Delete Font	Ta bort teckensnitt
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Siffror
+	Scale at Center	Skala från mitten
 	Up/Down:	Upp/ned:
 	Left/Right:	Vänster/höger:
 	Temperature	Temperatur
@@ -4635,6 +4644,7 @@ axis	Both	Båda
 @msg	an image VectorCraft can't read was left out	en bild som VectorCraft inte kan läsa utelämnades
 @msg	graphs come in as plain art, without their data or settings	diagram läses in som vanlig grafik, utan sina data och inställningar
 @msg	an image whose data is cut short was left out	en bild med avkortade data utelämnades
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	en inbäddad bild på {_1} × {_2} pixlar förminskades till {_3} × {_4} pixlar för att behålla lagren
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	länkade bilder visar förhandsgranskningen med låg upplösning som sparats i filen tills deras filer hittas: länka om dem i panelen Länkar
 @msg	linked type areas past VectorCraft's limits were left out	länkade textområden utöver VectorCrafts gränser utelämnades
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	text som byter skrivriktning inuti ett textobjekt öppnas i riktningen för sitt första tecken
@@ -4714,6 +4724,7 @@ axis	Both	Båda
 @msg	object ids are non-negative integers, not {v}	objekt-id:n är icke-negativa heltal, inte {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} måste vara en array med objekt-id:n som är icke-negativa heltal
 @msg	invalid object id {value}: expected a non-negative integer	ogiltigt objekt-id {value}: ett icke-negativt heltal förväntades
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	post {index} i `{key}` är {value}, inte ett objekt-id (ett icke-negativt heltal)
 @msg	no such object id {value}	det finns inget objekt med id {value}
 @msg	id {value} is a layer, not an object	id {value} är ett lager, inte ett objekt
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} är ett lager, inte ett objekt; flytta lager med layer.move
@@ -5884,6 +5895,9 @@ axis	Y Axis	Y-axel
 	Install “{name}”, which asks for these permissions?	Installera ”{name}”, som begär dessa behörigheter?
 	ID: {id}	ID: {id}
 	Version: {version}	Version: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Installera ”{name}” i stället för det plugin som har samma id?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Den här filen är inte det plugin som tidigare installerades med detta id. Den får de inställningar och den cache som sparats för detta id.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	”{name}” är en annan modul än pluginet med id {_1} och skulle få de inställningar och den cache som sparats för det: installera det med `replace: true` när användaren har godkänt
 	File SHA-256: {hash}	Filens SHA-256: {hash}
 	Read the objects it is given	Läsa objekten den får
 	Change, add and delete objects in the document	Ändra, lägga till och ta bort objekt i dokumentet
@@ -5891,10 +5905,13 @@ axis	Y Axis	Y-axel
 	Change how the objects its effect is applied to are drawn	Ändra hur objekten som dess effekt används på ritas
 	Write the document as a file in its own format	Skriva dokumentet som en fil i sitt eget format
 	Show its progress, see Cancel and write log lines	Visa sitt förlopp, se när det avbryts och skriva loggrader
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	behörigheten `progress` kräver plugin-API-nivå {PROGRESS_API}: ange `api` {PROGRESS_API}
+	Keep settings of its own	Spara egna inställningar
+	Keep a cache of its own, which you can clear	Spara en egen cache, som du kan tömma
+	Clear Plug-in Cache	Töm pluginets cache
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	behörigheten `{permission}` kräver plugin-API-nivå {PROGRESS_API}: ange `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	modulen importerar `env.{name}` med en annan typ än värdens: värdens typ är {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	modulen importerar `env.{name}`, som ett plugin bara får använda på plugin-API-nivå {PROGRESS_API} (`api` {PROGRESS_API}) och med behörigheten `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	modulen importerar `{from}.{name}`, som värden inte erbjuder: ett plugin får bara importera `env.vc_progress`, `env.vc_cancelled` och `env.vc_log` (plugin-API-nivå 2), och ingen WASI, inga filer eller nätverk
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	modulen importerar `env.{name}`, som ett plugin bara får använda på plugin-API-nivå {PROGRESS_API} (`api` {PROGRESS_API}) och med behörigheten `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	modulen importerar `{from}.{name}`, som värden inte erbjuder: ett plugin får bara importera de `env.vc_*`-funktioner som docs/plugins.md listar (plugin-API-nivå 2), och ingen WASI, inga filer eller nätverk
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` är {_1}; den här värden stöder plugin-API-nivå 1 till {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` måste vara en lista med behörighetsnamn
 @msg	`grant` names an unknown permission `{shown}`	`grant` anger en okänd behörighet `{shown}`
diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs
index 40dab2ea0..d8a34883a 100644
--- a/crates/ui-egui/src/i18n/tests.rs
+++ b/crates/ui-egui/src/i18n/tests.rs
@@ -2062,9 +2062,9 @@ fn dataset_import_cell_errors_are_translated() {
 
 /// The errors of the parameter checks that many commands share (a number given as text, a missing
 /// number or index, a fraction for a whole number, `ids` that aren't a list of object ids, an
-/// object id that is negative or names no object, a date that isn't Unix seconds) fill their
-/// templates, and each language shows the value in the message, such as a quoted `"60 mm"`, as
-/// given: in its row's translation, or in English where it has none.
+/// `ids` entry or an `id` that is negative, an object id that names no object, a date that isn't
+/// Unix seconds) fill their templates, and each language shows the value in the message, such as a
+/// quoted `"60 mm"`, as given: in its row's translation, or in English where it has none.
 #[test]
 fn shared_param_check_errors_show_their_values_as_given() {
     use serde_json::json;
@@ -2075,7 +2075,7 @@ fn shared_param_check_errors_show_their_values_as_given() {
     s.execute("select.all", &json!({})).unwrap();
     // A command, its params, the English template of its error and the template's values.
     type Case = (&'static str, serde_json::Value, &'static str, &'static [(&'static str, &'static str)]);
-    let cases: [Case; 10] = [
+    let cases: [Case; 11] = [
         ("object.move", json!({"dx": "60 mm"}), "`{key}` must be a number, not {v}", &[("key", "dx"), ("v", r#""60 mm""#)]),
         ("object.rotate", json!({"angle": true}), "`{key}` must be a number, not {v}", &[("key", "angle"), ("v", "true")]),
         ("object.setBounds", json!({"width": [1, 2]}), "`{key}` must be a number, not {v}", &[("key", "width"), ("v", "[1,2]")]),
@@ -2083,7 +2083,13 @@ fn shared_param_check_errors_show_their_values_as_given() {
         ("appearance.setItem", json!({}), "missing integer `{key}`", &[("key", "index")]),
         ("object.transformEach", json!({"reference": 2.5}), "`{key}` must be a whole number", &[("key", "reference")]),
         ("edit.clear", json!({"ids": "all"}), "{key} must be an array of non-negative integer object ids", &[("key", "ids")]),
-        ("edit.clear", json!({"ids": [-1]}), "invalid object id {value}: expected a non-negative integer", &[("value", "-1")]),
+        (
+            "edit.clear",
+            json!({"ids": [-1]}),
+            "`{key}` entry {index} is {value}, not a non-negative integer object id",
+            &[("key", "ids"), ("index", "0"), ("value", "-1")],
+        ),
+        ("paint.invert", json!({"id": -1}), "invalid object id {value}: expected a non-negative integer", &[("value", "-1")]),
         ("edit.clear", json!({"ids": [99999]}), "no such object id {value}", &[("value", "99999")]),
         ("file.new", json!({"created": "yesterday"}), "{key} must be Unix seconds (an integer) or null", &[("key", "created")]),
     ];
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
index 4b605bb06..300167a97 100644
--- a/crates/ui-egui/src/i18n/tr.tsv
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -3276,6 +3276,15 @@ digits	Malayalam	Malayalam
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Tate-chu-yoko Ayarları…
 	Tate-chu-yoko Settings	Tate-chu-yoko Ayarları
+	Composite Fonts…	Bileşik Fontlar…
+	Composite Fonts	Bileşik Fontlar
+	Export Composite Fonts	Bileşik Fontları Dışa Aktar
+	Import Composite Fonts	Bileşik Fontları İçe Aktar
+	Delete Font	Fontu Sil
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Rakamlar
+	Scale at Center	Merkezden Ölçekle
 	Up/Down:	Yukarı/Aşağı:
 	Left/Right:	Sol/Sağ:
 	Temperature	Sıcaklık
@@ -4473,6 +4482,7 @@ axis	Both	Her İkisi
 @msg	an image VectorCraft can't read was left out	VectorCraft'ın okuyamadığı bir resim dışarıda bırakıldı
 @msg	graphs come in as plain art, without their data or settings	grafikler, verileri ve ayarları olmadan düz çizim olarak içe aktarılır
 @msg	an image whose data is cut short was left out	verileri kısa kesilen bir resim dışarıda bırakıldı
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	katmanları korumak için {_1} × {_2} piksellik gömülü bir resim {_3} × {_4} piksele küçültüldü
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	bağlantılı resimler, dosyaları bulunana kadar dosyaya kaydedilen düşük çözünürlüklü önizlemeyi gösterir: bunları Bağlantılar panelinde yeniden bağlayın
 @msg	linked type areas past VectorCraft's limits were left out	VectorCraft sınırlarını aşan bağlantılı metin alanları dışarıda bırakıldı
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	bir metin nesnesi içinde yazı yönünü değiştiren metin, ilk karakterinin yönünde açılır
@@ -5531,6 +5541,7 @@ theme	Appearance	Görünüm
 @msg	missing integer `{key}`	`{key}` tam sayısı eksik
 @msg	{key} must be an array of non-negative integer object ids	{key}, negatif olmayan tam sayı nesne kimlikleri dizisi olmalıdır
 @msg	invalid object id {value}: expected a non-negative integer	geçersiz nesne kimliği {value}: negatif olmayan bir tam sayı bekleniyordu
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` içindeki {index} dizinli öğe {value}, negatif olmayan tam sayı bir nesne kimliği değil
 @msg	no such object id {value}	böyle bir nesne kimliği yok: {value}
 @msg	id {value} is a layer, not an object	{value} kimliği bir katmana ait, bir nesneye değil
 @msg	id {value} is a layer, not an object; move layers with layer.move	{value} kimliği bir katmana ait, bir nesneye değil; katmanları layer.move ile taşıyın
@@ -5818,6 +5829,9 @@ axis	Y Axis	Y ekseni
 	Install “{name}”, which asks for these permissions?	Bu izinleri isteyen “{name}” yüklensin mi?
 	ID: {id}	Kimlik: {id}
 	Version: {version}	Sürüm: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Aynı kimliğe sahip eklentinin yerine “{name}” yüklensin mi?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Bu dosya, daha önce bu kimlikle yüklenen eklenti değil. O kimlik için saklanan ayarları ve önbelleği alır.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}”, {_1} kimlikli eklentiden farklı bir modül ve onun için saklanan ayarları ve önbelleği alacak: kullanıcı onayladıktan sonra `replace: true` ile yükleyin
 	File SHA-256: {hash}	Dosya SHA-256: {hash}
 	Read the objects it is given	Kendisine verilen nesneleri okuma
 	Change, add and delete objects in the document	Belgedeki nesneleri değiştirme, ekleme ve silme
@@ -5825,10 +5839,13 @@ axis	Y Axis	Y ekseni
 	Change how the objects its effect is applied to are drawn	Efektinin uygulandığı nesnelerin nasıl çizildiğini değiştirme
 	Write the document as a file in its own format	Belgeyi kendi biçiminde bir dosya olarak yazma
 	Show its progress, see Cancel and write log lines	İlerlemesini gösterme, iptali algılama ve günlük satırları yazma
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	`progress` izni için eklenti API düzeyi {PROGRESS_API} gerekir: `api` {PROGRESS_API} verin
+	Keep settings of its own	Kendi ayarlarını saklama
+	Keep a cache of its own, which you can clear	Temizleyebileceğiniz kendi önbelleğini saklama
+	Clear Plug-in Cache	Eklenti Önbelleğini Temizle
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	`{permission}` izni için eklenti API düzeyi {PROGRESS_API} gerekir: `api` {PROGRESS_API} verin
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	modül `env.{name}` öğesini ana bilgisayarınkinden farklı bir türle içe aktarıyor: ana bilgisayarın türü {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	modül `env.{name}` öğesini içe aktarıyor; bir eklenti bunu yalnızca eklenti API düzeyi {PROGRESS_API} (`api` {PROGRESS_API}) ile ve `progress` izniyle kullanabilir
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	modül, ana bilgisayarın sunmadığı `{from}.{name}` öğesini içe aktarıyor: bir eklenti yalnızca `env.vc_progress`, `env.vc_cancelled` ve `env.vc_log` öğelerini (eklenti API düzeyi 2) içe aktarabilir; WASI, dosya veya ağ kullanamaz
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	modül `env.{name}` öğesini içe aktarıyor; bir eklenti bunu yalnızca eklenti API düzeyi {PROGRESS_API} (`api` {PROGRESS_API}) ile ve `{permission}` izniyle kullanabilir
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	modül, ana bilgisayarın sunmadığı `{from}.{name}` öğesini içe aktarıyor: bir eklenti yalnızca docs/plugins.md dosyasında listelenen `env.vc_*` işlevlerini (eklenti API düzeyi 2) içe aktarabilir; WASI, dosya veya ağ kullanamaz
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` değeri {_1}; bu ana bilgisayar 1 ile {API_LEVEL} arasındaki eklenti API düzeylerini destekler
 @msg	`grant` must be a list of permission names	`grant` izin adlarından oluşan bir liste olmalıdır
 @msg	`grant` names an unknown permission `{shown}`	`grant` bilinmeyen bir izin adlandırıyor: `{shown}`
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index 78db714e4..4ad4f5b4d 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -3492,6 +3492,15 @@ effect	Points	Точки
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Параметри Tate-chu-yoko…
 	Tate-chu-yoko Settings	Параметри Tate-chu-yoko
+	Composite Fonts…	Складені шрифти…
+	Composite Fonts	Складені шрифти
+	Export Composite Fonts	Експорт складених шрифтів
+	Import Composite Fonts	Імпорт складених шрифтів
+	Delete Font	Видалити шрифт
+	Kanji	Кандзі
+	Kana	Кана
+	Numerals	Цифри
+	Scale at Center	Масштабувати від центру
 	Up/Down:	Вгору/вниз:
 	Left/Right:	Ліворуч/праворуч:
 	Temperature	Температура
@@ -4762,6 +4771,7 @@ axis	Both	Обидві
 @msg	an image VectorCraft can't read was left out	зображення, яке VectorCraft не може прочитати, пропущено
 @msg	graphs come in as plain art, without their data or settings	діаграми імпортуються як звичайна графіка, без їхніх даних і налаштувань
 @msg	an image whose data is cut short was left out	зображення з обрізаними даними пропущено
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	вбудоване зображення {_1} × {_2} пікселів зменшено до {_3} × {_4} пікселів, щоб зберегти шари
 @msg	linked pictures show the low-resolution preview saved in the file until their files are found: relink them in the Links panel	пов’язані зображення показуються як збережений у файлі перегляд низької роздільності, доки їхні файли не знайдено: відновіть зв’язки на панелі «Зв’язки»
 @msg	linked type areas past VectorCraft's limits were left out	пов’язані текстові області понад обмеження VectorCraft пропущено
 @msg	type that changes writing direction inside a text object opens in the direction of its first character	текст, що змінює напрямок письма всередині текстового об’єкта, відкривається в напрямку свого першого символу
@@ -4823,6 +4833,7 @@ axis	Both	Обидві
 @msg	object ids are non-negative integers, not {v}	ідентифікатори об’єктів — невід’ємні цілі числа, а не {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} має бути масивом ідентифікаторів об’єктів, які є невід’ємними цілими числами
 @msg	invalid object id {value}: expected a non-negative integer	неприпустимий ідентифікатор об’єкта {value}: очікується невід’ємне ціле число
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	елемент {index} у `{key}` дорівнює {value}, а не ідентифікатору об’єкта (невід’ємному цілому числу)
 @msg	no such object id {value}	об’єкт з ідентифікатором {value} не існує
 @msg	id {value} is a layer, not an object	ідентифікатор {value} належить шару, а не об’єкту
 @msg	id {value} is a layer, not an object; move layers with layer.move	ідентифікатор {value} належить шару, а не об’єкту; переміщуйте шари за допомогою layer.move
@@ -5457,6 +5468,9 @@ axis	Y Axis	Вісь Y
 	Install “{name}”, which asks for these permissions?	Встановити «{name}», якому потрібні ці дозволи?
 	ID: {id}	ID: {id}
 	Version: {version}	Версія: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Встановити «{name}» замість модуля з тим самим ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Цей файл не є модулем, установленим раніше з цим ID. Він отримає налаштування й кеш, збережені для цього ID.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	«{name}» відрізняється від модуля з ID {_1} і отримав би збережені для нього налаштування й кеш: встановіть його з `replace: true`, коли користувач погодиться
 	File SHA-256: {hash}	SHA-256 файлу: {hash}
 	Read the objects it is given	Читати передані йому об’єкти
 	Change, add and delete objects in the document	Змінювати, додавати й видаляти об’єкти в документі
@@ -5464,10 +5478,13 @@ axis	Y Axis	Вісь Y
 	Change how the objects its effect is applied to are drawn	Змінювати те, як малюються об’єкти, до яких застосовано його ефект
 	Write the document as a file in its own format	Записувати документ у файл власного формату
 	Show its progress, see Cancel and write log lines	Показувати свій поступ, помічати скасування і записувати рядки журналу
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	дозволу `progress` потрібен рівень API модулів {PROGRESS_API}: укажіть `api` {PROGRESS_API}
+	Keep settings of its own	Зберігати власні налаштування
+	Keep a cache of its own, which you can clear	Зберігати власний кеш, який можна очистити
+	Clear Plug-in Cache	Очистити кеш модуля
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	дозволу `{permission}` потрібен рівень API модулів {PROGRESS_API}: укажіть `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	модуль імпортує `env.{name}` з іншим типом, ніж у хоста: у хоста тип {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	модуль імпортує `env.{name}`, який модуль може використовувати лише на рівні API модулів {PROGRESS_API} (`api` {PROGRESS_API}) і з дозволом `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	модуль імпортує `{from}.{name}`, який хост не надає: модуль може імпортувати лише `env.vc_progress`, `env.vc_cancelled` і `env.vc_log` (рівень API модулів 2), без WASI, файлів і мережі
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	модуль імпортує `env.{name}`, який модуль може використовувати лише на рівні API модулів {PROGRESS_API} (`api` {PROGRESS_API}) і з дозволом `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	модуль імпортує `{from}.{name}`, який хост не надає: модуль може імпортувати лише функції `env.vc_*`, перелічені в docs/plugins.md (рівень API модулів 2), без WASI, файлів і мережі
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` дорівнює {_1}; цей хост підтримує рівні API модулів від 1 до {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` має бути списком назв дозволів
 @msg	`grant` names an unknown permission `{shown}`	`grant` називає невідомий дозвіл `{shown}`
diff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsv
index f309c0acc..b493f9c64 100644
--- a/crates/ui-egui/src/i18n/vi.tsv
+++ b/crates/ui-egui/src/i18n/vi.tsv
@@ -3826,6 +3826,15 @@ mark-style	Japanese	Kiểu Nhật
 	Tate-chu-yoko	Tate-chu-yoko
 	Tate-chu-yoko Settings…	Cài đặt Tate-chu-yoko…
 	Tate-chu-yoko Settings	Cài đặt Tate-chu-yoko
+	Composite Fonts…	Phông chữ tổ hợp…
+	Composite Fonts	Phông chữ tổ hợp
+	Export Composite Fonts	Xuất phông chữ tổ hợp
+	Import Composite Fonts	Nhập phông chữ tổ hợp
+	Delete Font	Xóa phông chữ
+	Kanji	Kanji
+	Kana	Kana
+	Numerals	Chữ số
+	Scale at Center	Co giãn từ tâm
 	Up/Down:	Lên/Xuống:
 	Left/Right:	Trái/Phải:
 	Temperature	Nhiệt độ màu
@@ -4400,6 +4409,7 @@ theme	Appearance	Giao diện
 @msg	an image VectorCraft can't read was left out	một ảnh VectorCraft không đọc được đã bị bỏ qua
 @msg	graphs come in as plain art, without their data or settings	biểu đồ được nhập dưới dạng hình vẽ thường, không kèm dữ liệu và thiết lập của chúng
 @msg	an image whose data is cut short was left out	một ảnh bị cắt ngắn dữ liệu đã bị bỏ qua
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	một ảnh nhúng {_1} × {_2} điểm ảnh đã được thu nhỏ còn {_3} × {_4} điểm ảnh để giữ các lớp
 @msg	an object can't be read	không thể đọc một đối tượng
 @msg	an object in perspective would leave the edited grid	đối tượng trong phối cảnh sẽ rời khỏi lưới đang chỉnh sửa
 @msg	An object takes one 3D effect. Edit the existing effect's options, or remove it first.	Một đối tượng chỉ nhận một hiệu ứng 3D. Hãy chỉnh sửa tùy chọn của hiệu ứng hiện có hoặc xóa nó trước.
@@ -4772,6 +4782,7 @@ theme	Appearance	Giao diện
 @msg	object ids are non-negative integers, not {v}	id đối tượng là số nguyên không âm, không phải {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} phải là một mảng id đối tượng là số nguyên không âm
 @msg	invalid object id {value}: expected a non-negative integer	id đối tượng {value} không hợp lệ: cần một số nguyên không âm
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	mục {index} của `{key}` là {value}, không phải id đối tượng (số nguyên không âm)
 @msg	no such object id {value}	không có đối tượng nào có id {value}
 @msg	id {value} is a layer, not an object	id {value} là một lớp, không phải đối tượng
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} là một lớp, không phải đối tượng; hãy di chuyển lớp bằng layer.move
@@ -5458,6 +5469,9 @@ axis	Y Axis	Trục Y
 	Install “{name}”, which asks for these permissions?	Cài đặt “{name}”, plug-in yêu cầu các quyền này?
 	ID: {id}	ID: {id}
 	Version: {version}	Phiên bản: {version}
+	Install “{name}” in place of the plug-in with the same ID?	Cài đặt “{name}” thay cho plug-in có cùng ID?
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	Tệp này không phải là plug-in đã cài đặt trước đây với ID này. Tệp sẽ nhận cài đặt và bộ nhớ đệm được lưu cho ID đó.
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}” là mô-đun khác với plug-in có ID {_1} và sẽ nhận cài đặt và bộ nhớ đệm được lưu cho plug-in đó: hãy cài đặt với `replace: true` khi người dùng đồng ý
 	File SHA-256: {hash}	SHA-256 của tệp: {hash}
 	Read the objects it is given	Đọc các đối tượng được trao cho nó
 	Change, add and delete objects in the document	Thay đổi, thêm và xóa đối tượng trong tài liệu
@@ -5465,10 +5479,13 @@ axis	Y Axis	Trục Y
 	Change how the objects its effect is applied to are drawn	Thay đổi cách vẽ các đối tượng được áp dụng hiệu ứng của nó
 	Write the document as a file in its own format	Ghi tài liệu thành tệp theo định dạng riêng
 	Show its progress, see Cancel and write log lines	Hiển thị tiến độ, nhận biết yêu cầu hủy và ghi các dòng nhật ký
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	quyền `progress` cần API plug-in cấp {PROGRESS_API}: hãy đặt `api` {PROGRESS_API}
+	Keep settings of its own	Lưu cài đặt riêng
+	Keep a cache of its own, which you can clear	Lưu bộ nhớ đệm riêng mà bạn có thể xóa
+	Clear Plug-in Cache	Xóa bộ nhớ đệm của plug-in
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	quyền `{permission}` cần API plug-in cấp {PROGRESS_API}: hãy đặt `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	mô-đun nhập `env.{name}` với kiểu khác với kiểu của máy chủ: kiểu của máy chủ là {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	mô-đun nhập `env.{name}`, thứ mà plug-in chỉ được dùng ở API plug-in cấp {PROGRESS_API} (`api` {PROGRESS_API}) và với quyền `progress`
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	mô-đun nhập `{from}.{name}`, thứ mà máy chủ không cung cấp: plug-in chỉ được nhập `env.vc_progress`, `env.vc_cancelled` và `env.vc_log` (API plug-in cấp 2), không có WASI, tệp hay mạng
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	mô-đun nhập `env.{name}`, thứ mà plug-in chỉ được dùng ở API plug-in cấp {PROGRESS_API} (`api` {PROGRESS_API}) và với quyền `{permission}`
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	mô-đun nhập `{from}.{name}`, thứ mà máy chủ không cung cấp: plug-in chỉ được nhập các hàm `env.vc_*` mà docs/plugins.md liệt kê (API plug-in cấp 2), không có WASI, tệp hay mạng
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` là {_1}; máy chủ này hỗ trợ các mức API plug-in từ 1 đến {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` phải là danh sách tên quyền
 @msg	`grant` names an unknown permission `{shown}`	`grant` nêu một quyền không xác định `{shown}`
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index 30603ef86..99e5223df 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -3331,6 +3331,15 @@ digits	Malayalam	马拉雅拉姆数字
 	Tate-chu-yoko	纵中横
 	Tate-chu-yoko Settings…	纵中横设置…
 	Tate-chu-yoko Settings	纵中横设置
+	Composite Fonts…	复合字体…
+	Composite Fonts	复合字体
+	Export Composite Fonts	导出复合字体
+	Import Composite Fonts	导入复合字体
+	Delete Font	删除字体
+	Kanji	汉字
+	Kana	假名
+	Numerals	数字
+	Scale at Center	从中心缩放
 	Up/Down:	上/下：
 	Left/Right:	左/右：
 	Temperature	色温
@@ -4186,6 +4195,7 @@ imageTrace	Outline	轮廓
 @msg	an image VectorCraft can't read was left out	已略去 VectorCraft 无法读取的图像
 @msg	graphs come in as plain art, without their data or settings	图表作为普通图稿导入，不保留其数据和设置
 @msg	an image whose data is cut short was left out	已略去数据不完整的图像
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	为保留图层，{_1} × {_2} 像素的嵌入图像已缩小为 {_3} × {_4} 像素
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	文件中未定义渐变“{name}”：已改用纯色代替
 @msg	brushes VectorCraft can't read yet were left out of the Brushes panel ({_1})	VectorCraft 尚无法读取的画笔未加入“画笔”面板 ({_1})
 @msg	objects with several fills or strokes, effects or brushes came in as their drawn look ({_1}): their appearance isn't editable yet	带有多个填色或描边、效果或画笔的对象已按其绘制外观导入 ({_1})：其外观尚不可编辑
@@ -4589,6 +4599,7 @@ imageTrace	Outline	轮廓
 @msg	object ids are non-negative integers, not {v}	对象 id 是非负整数，而不是 {v}
 @msg	{key} must be an array of non-negative integer object ids	{key} 必须是由非负整数对象 id 组成的数组
 @msg	invalid object id {value}: expected a non-negative integer	无效的对象 id {value}：应为非负整数
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` 中索引 {index} 处的项为 {value}，不是非负整数对象 id
 @msg	no such object id {value}	没有 id 为 {value} 的对象
 @msg	id {value} is a layer, not an object	id {value} 是图层，不是对象
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} 是图层，不是对象；请使用 layer.move 移动图层
@@ -5699,6 +5710,9 @@ axis	Y Axis	Y 轴
 	Install “{name}”, which asks for these permissions?	要安装需要这些权限的“{name}”吗？
 	ID: {id}	ID：{id}
 	Version: {version}	版本：{version}
+	Install “{name}” in place of the plug-in with the same ID?	要安装“{name}”来替换具有相同 ID 的插件吗？
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	此文件不是之前以此 ID 安装的插件。它将获得为该 ID 保存的设置和缓存。
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	“{name}”与 ID 为 {_1} 的插件是不同的模块，并会获得为其保存的设置和缓存：请在用户同意后使用 `replace: true` 安装
 	File SHA-256: {hash}	文件 SHA-256：{hash}
 	Read the objects it is given	读取交给它的对象
 	Change, add and delete objects in the document	更改、添加和删除文档中的对象
@@ -5706,10 +5720,13 @@ axis	Y Axis	Y 轴
 	Change how the objects its effect is applied to are drawn	更改应用了其效果的对象的绘制方式
 	Write the document as a file in its own format	将文档写为其自有格式的文件
 	Show its progress, see Cancel and write log lines	显示进度、检测取消请求并写入日志行
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	权限 `progress` 需要增效工具 API 级别 {PROGRESS_API}：请设置 `api` {PROGRESS_API}
+	Keep settings of its own	保存自己的设置
+	Keep a cache of its own, which you can clear	保存自己的缓存，您可以清除它
+	Clear Plug-in Cache	清除增效工具缓存
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	权限 `{permission}` 需要增效工具 API 级别 {PROGRESS_API}：请设置 `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	模块以与宿主不同的类型导入 `env.{name}`：宿主的类型为 {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	模块导入了 `env.{name}`，增效工具只有在增效工具 API 级别 {PROGRESS_API}（`api` {PROGRESS_API}）且具有权限 `progress` 时才能使用它
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	模块导入了宿主不提供的 `{from}.{name}`：增效工具只能导入 `env.vc_progress`、`env.vc_cancelled` 和 `env.vc_log`（增效工具 API 级别 2），不能使用 WASI、文件或网络
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	模块导入了 `env.{name}`，增效工具只有在增效工具 API 级别 {PROGRESS_API}（`api` {PROGRESS_API}）且具有权限 `{permission}` 时才能使用它
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	模块导入了宿主不提供的 `{from}.{name}`：增效工具只能导入 docs/plugins.md 列出的 `env.vc_*` 函数（增效工具 API 级别 2），不能使用 WASI、文件或网络
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` 为 {_1}；此主机支持的增效工具 API 级别为 1 到 {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` 必须是权限名称的列表
 @msg	`grant` names an unknown permission `{shown}`	`grant` 包含未知权限 `{shown}`
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index 3971235fa..eb0cf06b1 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -2037,6 +2037,7 @@ file-filter	Templates	範本
 @msg	an image VectorCraft can't read was left out	已略過 VectorCraft 無法讀取的影像
 @msg	graphs come in as plain art, without their data or settings	圖表以一般圖稿匯入，不保留其資料與設定
 @msg	an image whose data is cut short was left out	已略過資料不完整的影像
+@msg	an embedded image of {_1} × {_2} pixels was reduced to {_3} × {_4} pixels to keep the layers	為保留圖層，{_1} × {_2} 像素的內嵌影像已縮小為 {_3} × {_4} 像素
 @msg	gradient “{name}” isn't defined in the file: a plain colour stands in for it	檔案中未定義漸層「{name}」：已改用單色替代
 @msg	brushes VectorCraft can't read yet were left out of the Brushes panel ({_1})	VectorCraft 尚無法讀取的筆刷未加入「筆刷」面板 ({_1})
 @msg	objects with several fills or strokes, effects or brushes came in as their drawn look ({_1}): their appearance isn't editable yet	具有多個填色或筆畫、效果或筆刷的物件已依其繪製外觀匯入 ({_1})：其外觀目前尚無法編輯
@@ -4370,6 +4371,15 @@ digits	Malayalam	馬來亞拉姆數字
 	Tate-chu-yoko	縱中橫
 	Tate-chu-yoko Settings…	縱中橫設定…
 	Tate-chu-yoko Settings	縱中橫設定
+	Composite Fonts…	複合字體…
+	Composite Fonts	複合字體
+	Export Composite Fonts	匯出複合字體
+	Import Composite Fonts	匯入複合字體
+	Delete Font	刪除字體
+	Kanji	漢字
+	Kana	假名
+	Numerals	數字
+	Scale at Center	從中心縮放
 	Up/Down:	上/下：
 	Left/Right:	左/右：
 	Temperature	色溫
@@ -5410,6 +5420,7 @@ lighting	Light	光源
 @msg	{key} must be Unix seconds (an integer) or null	{key} 必須是以秒為單位的 Unix 時間 (整數) 或 null
 @msg	{key} must be an array of non-negative integer object ids	{key} 必須是由非負整數物件 id 組成的陣列
 @msg	invalid object id {value}: expected a non-negative integer	無效的物件 id {value}：應為非負整數
+@msg	`{key}` entry {index} is {value}, not a non-negative integer object id	`{key}` 中索引 {index} 處的項目為 {value}，不是非負整數物件 id
 @msg	no such object id {value}	沒有 id 為 {value} 的物件
 @msg	id {value} is a layer, not an object	id {value} 是圖層，不是物件
 @msg	id {value} is a layer, not an object; move layers with layer.move	id {value} 是圖層，不是物件；請使用 layer.move 移動圖層
@@ -5495,6 +5506,9 @@ axis	Y Axis	Y 軸
 	Install “{name}”, which asks for these permissions?	要安裝需要這些權限的「{name}」嗎？
 	ID: {id}	ID：{id}
 	Version: {version}	版本：{version}
+	Install “{name}” in place of the plug-in with the same ID?	要安裝「{name}」來取代具有相同 ID 的增效模組嗎？
+	This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.	此檔案不是先前以此 ID 安裝的增效模組。它會取得為該 ID 保存的設定和快取。
+@msg	“{name}” is another module than the plug-in with id {_1} and would get the settings and cache kept for it: install it with `replace: true` once the user agrees	「{name}」與 ID 為 {_1} 的增效模組是不同的模組，並會取得為其保存的設定和快取：請在使用者同意後以 `replace: true` 安裝
 	File SHA-256: {hash}	檔案 SHA-256：{hash}
 	Read the objects it is given	讀取交給它的物件
 	Change, add and delete objects in the document	變更、新增和刪除文件中的物件
@@ -5502,10 +5516,13 @@ axis	Y Axis	Y 軸
 	Change how the objects its effect is applied to are drawn	變更套用其效果的物件的繪製方式
 	Write the document as a file in its own format	將文件寫成其自有格式的檔案
 	Show its progress, see Cancel and write log lines	顯示進度、偵測取消要求並寫入記錄行
-@msg	permission `progress` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	權限 `progress` 需要增效模組 API 層級 {PROGRESS_API}：請設定 `api` {PROGRESS_API}
+	Keep settings of its own	保存自己的設定
+	Keep a cache of its own, which you can clear	保存自己的快取，您可以清除它
+	Clear Plug-in Cache	清除增效模組快取
+@msg	permission `{permission}` needs plug-in API level {PROGRESS_API}: give `api` {PROGRESS_API}	權限 `{permission}` 需要增效模組 API 層級 {PROGRESS_API}：請設定 `api` {PROGRESS_API}
 @msg	the module imports `env.{name}` with another type than the host's: it is {signature}	模組以與主機不同的類型匯入 `env.{name}`：主機的類型為 {signature}
-@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `progress`	模組匯入了 `env.{name}`，增效模組只有在增效模組 API 層級 {PROGRESS_API}（`api` {PROGRESS_API}）且具有權限 `progress` 時才能使用它
-@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only `env.vc_progress`, `env.vc_cancelled` and `env.vc_log` (plug-in API level 2), and no WASI, files or network	模組匯入了主機未提供的 `{from}.{name}`：增效模組只能匯入 `env.vc_progress`、`env.vc_cancelled` 和 `env.vc_log`（增效模組 API 層級 2），不能使用 WASI、檔案或網路
+@msg	the module imports `env.{name}`, which a plug-in may use only at plug-in API level {PROGRESS_API} (`api` {PROGRESS_API}) and with the permission `{permission}`	模組匯入了 `env.{name}`，增效模組只有在增效模組 API 層級 {PROGRESS_API}（`api` {PROGRESS_API}）且具有權限 `{permission}` 時才能使用它
+@msg	the module imports `{from}.{name}`, which the host doesn't offer: a plug-in may import only the `env.vc_*` functions that docs/plugins.md lists (plug-in API level 2), and no WASI, files or network	模組匯入了主機未提供的 `{from}.{name}`：增效模組只能匯入 docs/plugins.md 列出的 `env.vc_*` 函式（增效模組 API 層級 2），不能使用 WASI、檔案或網路
 @msg	`api` is {_1}; this host implements plug-in API levels 1 to {API_LEVEL}	`api` 為 {_1}；此主機支援的增效模組 API 層級為 1 到 {API_LEVEL}
 @msg	`grant` must be a list of permission names	`grant` 必須是權限名稱的清單
 @msg	`grant` names an unknown permission `{shown}`	`grant` 包含未知權限 `{shown}`
diff --git a/crates/ui-egui/src/io/open.rs b/crates/ui-egui/src/io/open.rs
index 4f507fe30..a03118aa2 100644
--- a/crates/ui-egui/src/io/open.rs
+++ b/crates/ui-egui/src/io/open.rs
@@ -101,6 +101,7 @@ pub fn opens_as(name: &str) -> Option<OpensAs> {
         (vectorcraft_engine::cmd::printpresets::PRESET_EXTS, "print.presets.import", "print presets"),
         (vectorcraft_engine::cmd::perspgrid::PRESET_EXTS, "perspective.presets.import", "perspective grid presets"),
         (fileio::SCREEN_EXPORT_PRESET_EXTS, "document.exportPresets.import", EXPORT_PRESETS),
+        (vectorcraft_engine::cmd::compositefonts::EXTS, "type.compositeFonts.import", "composite fonts"),
     ];
     if vectorcraft_engine::cmd::plugin::EXTS.contains(&ext.as_str()) {
         Some(OpensAs::Plugin)
@@ -175,6 +176,8 @@ fn permission_words(name: &str) -> String {
         Some(permissions::Permission::EffectRender) => tl!("Change how the objects its effect is applied to are drawn"),
         Some(permissions::Permission::ExportWrite) => tl!("Write the document as a file in its own format"),
         Some(permissions::Permission::Progress) => tl!("Show its progress, see Cancel and write log lines"),
+        Some(permissions::Permission::Settings) => tl!("Keep settings of its own"),
+        Some(permissions::Permission::Cache) => tl!("Keep a cache of its own, which you can clear"),
         None => return permissions::display_text(name, permissions::MAX_SHOWN_FIELD),
     };
     words.to_string()
@@ -183,15 +186,18 @@ fn permission_words(name: &str) -> String {
 /// Installs the plug-in module that `module` names (`plugin.install`'s `path`, or `dataBase64`
 /// with `name`) → `plugin.install`'s result. A plug-in that lists permissions the user hasn't
 /// granted it yet (`grant`) asks them first, showing its name, id, version, file hash and what each
-/// permission lets it do, and so does a filter that asks for a heavy budget the user hasn't allowed
-/// yet (`allowHeavy`); OK installs it if the module still has the hash the prompt showed, Cancel
-/// installs nothing → `{pending}` while it asks. Every
+/// permission lets it do, so does a filter that asks for a heavy budget the user hasn't allowed
+/// yet (`allowHeavy`), and so does a module that would take the place of another one with its id
+/// and get its settings and cache (`replace`); OK installs it if the module still has the hash the
+/// prompt showed, Cancel installs nothing → `{pending}` while it asks. Every
 /// text from the manifest is shown with its hidden characters escaped and its length capped
 /// ([`permissions::display_text`]).
 pub fn install_module(app: &mut VectorcraftApp, module: Value) -> Result<Value, String> {
     let heavy_allowed = module.get("allowHeavy").and_then(Value::as_bool) == Some(true);
     let granted = module.get("grant").is_some_and(|g| !g.is_null());
-    if !heavy_allowed || !granted {
+    // `replace: false` asks for no replacing, so only a module without `replace` asks.
+    let replace_given = module.get("replace").is_some_and(|r| !r.is_null());
+    if !heavy_allowed || !granted || !replace_given {
         let given = |k: &str| module.get(k).map(|v| (k.to_string(), v.clone()));
         let source = Value::Object(["path", "dataBase64", "name"].into_iter().filter_map(given).collect());
         // What OK installs: the same module, with what the user has agreed to so far, pinned to
@@ -234,6 +240,19 @@ pub fn install_module(app: &mut VectorcraftApp, module: Value) -> Result<Value,
             dialogs::confirm::ask(app, &message, &detail, "ui.installPlugin", allowed);
             return Ok(json!({ "pending": dialogs::confirm::KIND }));
         }
+        if !replace_given && info["needsReplace"] == true {
+            let message = crate::i18n::fmt(tl!("Install “{name}” in place of the plug-in with the same ID?"), &[("name", &name)]);
+            let lines = [
+                crate::i18n::fmt(tl!("ID: {id}"), &[("id", &shown("id", permissions::MAX_SHOWN_FIELD))]),
+                crate::i18n::fmt(tl!("File SHA-256: {hash}"), &[("hash", &shown("hash", 64))]),
+                String::new(),
+                tl!("This file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID.").to_string(),
+            ];
+            let mut replaced = answered;
+            replaced["replace"] = json!(true);
+            dialogs::confirm::ask(app, &message, &lines.join("\n"), "ui.installPlugin", replaced);
+            return Ok(json!({ "pending": dialogs::confirm::KIND }));
+        }
     }
     let r = app.run("plugin.install", module)?;
     app.status(format!("Installed plug-in {}", permissions::display_text(r["name"].as_str().unwrap_or_default(), permissions::MAX_SHOWN_NAME)));
diff --git a/crates/ui-egui/src/io/save.rs b/crates/ui-egui/src/io/save.rs
index 98e52a2c3..e9860e99a 100644
--- a/crates/ui-egui/src/io/save.rs
+++ b/crates/ui-egui/src/io/save.rs
@@ -129,6 +129,7 @@ const FILE_TYPES: &[(&str, &[&str])] = &[
     ("Print presets", vectorcraft_engine::cmd::printpresets::PRESET_EXTS),
     ("Action sets", &[crate::panels::actions::ACTIONS_EXT]),
     ("Export presets", fileio::SCREEN_EXPORT_PRESET_EXTS),
+    ("Composite fonts", vectorcraft_engine::cmd::compositefonts::EXTS),
     ("CSS", &["css"]),
     ("PostScript", &["ps"]),
 ];
diff --git a/crates/ui-egui/src/keymap.rs b/crates/ui-egui/src/keymap.rs
index d481ba389..d32ae53d5 100644
--- a/crates/ui-egui/src/keymap.rs
+++ b/crates/ui-egui/src/keymap.rs
@@ -3,16 +3,18 @@
 //! user's overrides.
 //!
 //! Entry keys are VectorCraft's everywhere outside this module: a command id, `tool:<id>`, or
-//! `panel:<id>` for the Window menu item showing a panel (`window.panel {panel}`). Chord texts
-//! outside it are VectorCraft's too (`Cmd+Shift+]`, `Comma`, `Period`, `~` for the backtick key,
-//! `=` for Plus with modifiers). Inside an [`Overrides`] keys and texts are the crate's.
+//! `panel:<id>` for the Window menu item showing a panel (`window.panel {panel}`), `effect:<id>`
+//! for an Effect menu item, or `plugin:<id>` for a filter plug-in's Object › Plug-ins item
+//! (`plugin.dialog {id}`). Chord texts outside it are VectorCraft's too (`Cmd+Shift+]`, `Comma`,
+//! `Period`, `~` for the backtick key, `=` for Plus with modifiers). Inside an [`Overrides`] keys
+//! and texts are the crate's.
 
-use std::sync::{OnceLock, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 
 use craft_keymap::{Bindable, Binding, Chord, CommandRef, Key, Keymap, Kind, Lookup, Mods, Overrides, Platform, Scope, Scopes};
 use serde_json::{Value, json};
 
-use crate::shortcut_editor::{self, Entry};
+use crate::shortcut_editor::{self, EffectItem, Entry, Snapshot};
 
 /// Menu commands whose label flips between Show and Hide (see `menus::dynamic_label`).
 pub const TOGGLES: &[&str] = &[
@@ -38,37 +40,95 @@ pub const TOGGLES: &[&str] = &[
 
 /// The command an entry key runs.
 pub fn command_of(key: &str) -> CommandRef {
+    if key.starts_with("effect:") {
+        return command_in(key, &shortcut_editor::effect_items());
+    }
+    command_in(key, &[])
+}
+
+/// The command an entry key runs while the Effect menu holds `effects`.
+fn command_in(key: &str, effects: &[EffectItem]) -> CommandRef {
     if let Some(panel) = key.strip_prefix("panel:") {
         return CommandRef::with_params("window.panel", json!({ "panel": panel }));
     }
-    // An Effect menu item (#3296): what its item runs, its dialog unless it has no options.
+    // An Effect menu item (#3296): what its item runs, its dialog unless it has no options. An
+    // effect the menu does not hold (a plug-in removed for now) is named by its dialog.
     if let Some(effect) = key.strip_prefix("effect:") {
-        let command = shortcut_editor::effect_items().iter().find(|e| e.effect == effect).map_or("effect.dialog", |e| e.command);
+        let command = effects.iter().find(|e| e.effect == effect).map_or("effect.dialog", |e| e.command);
         return CommandRef::with_params(command, json!({ "effect": effect }));
     }
+    // A filter plug-in's Object › Plug-ins item, installed or not: what its item runs.
+    if let Some(id) = key.strip_prefix("plugin:") {
+        return CommandRef::with_params("plugin.dialog", json!({ "id": id }));
+    }
     CommandRef::new(key)
 }
 
-/// The entry key of a command: `panel:<id>` for `window.panel {panel}`.
+/// `overrides` with each Effect menu item's shortcut under the command its item runs while the
+/// menu holds `effects`: a shortcut saved while a plug-in effect was missing, or while it had
+/// options it no longer has, stays that effect's.
+pub(crate) fn effect_keys_in(overrides: &Overrides, effects: &[EffectItem]) -> Overrides {
+    let mut out = overrides.clone();
+    for (k, texts) in overrides.iter() {
+        let entry = entry_of_stored(k);
+        if !entry.starts_with("effect:") {
+            continue;
+        }
+        let now = command_in(&entry, effects).key();
+        if now != k && out.get(&now).is_none() {
+            out.remove(k);
+            let _ = out.insert(now, texts.to_vec());
+        }
+    }
+    out
+}
+
+/// The entry key of a command: `panel:<id>` for `window.panel {panel}`, `effect:<id>` for an
+/// Effect menu item and `plugin:<id>` for `plugin.dialog {id}`.
 pub fn entry_key(command: &CommandRef) -> String {
     match (command.id.as_str(), command.params.get("panel").and_then(Value::as_str)) {
         ("window.panel", Some(panel)) => format!("panel:{panel}"),
         ("effect.dialog" | "effect.apply", _) if command.params.get("effect").and_then(Value::as_str).is_some() => {
             format!("effect:{}", command.params.get("effect").and_then(Value::as_str).unwrap_or_default())
         }
+        ("plugin.dialog", _) if command.params.get("id").and_then(Value::as_str).is_some() => {
+            format!("plugin:{}", command.params.get("id").and_then(Value::as_str).unwrap_or_default())
+        }
         _ => command.key(),
     }
 }
 
 /// The [`Overrides`] key of an entry key.
 pub fn stored_key(key: &str) -> String {
-    if key.starts_with("panel:") || key.starts_with("effect:") { command_of(key).key() } else { key.to_string() }
+    if key.starts_with("panel:") || key.starts_with("effect:") || key.starts_with("plugin:") { command_of(key).key() } else { key.to_string() }
+}
+
+/// An Effect menu item's [`Overrides`] key under the command its item does not run now
+/// (`effect.apply` for one that opens its dialog, and the other way round).
+fn other_stored_key(key: &str) -> Option<String> {
+    let effect = key.strip_prefix("effect:")?;
+    let other = if command_of(key).id == "effect.apply" { "effect.dialog" } else { "effect.apply" };
+    Some(CommandRef::with_params(other, json!({ "effect": effect })).key())
+}
+
+/// The texts of an entry's override, saved under its [`stored_key`] or, for an Effect menu item,
+/// under its [`other_stored_key`].
+pub(crate) fn stored_texts<'a>(overrides: &'a Overrides, key: &str) -> Option<&'a [String]> {
+    overrides.get(&stored_key(key)).or_else(|| other_stored_key(key).and_then(|k| overrides.get(&k)))
+}
+
+/// Removes an entry's override, under either key an Effect menu item's can have.
+pub(crate) fn remove_override(overrides: &mut Overrides, key: &str) {
+    overrides.remove(&stored_key(key));
+    if let Some(k) = other_stored_key(key) {
+        overrides.remove(&k);
+    }
 }
 
 /// The entry key of an [`Overrides`] key.
 pub fn entry_of_stored(key: &str) -> String {
     CommandRef::parse_key(key)
-        .filter(|c| matches!(c.id.as_str(), "window.panel" | "effect.dialog" | "effect.apply"))
+        .filter(|c| matches!(c.id.as_str(), "window.panel" | "effect.dialog" | "effect.apply" | "plugin.dialog"))
         .map_or_else(|| key.to_string(), |c| entry_key(&c))
 }
 
@@ -132,7 +192,7 @@ fn vc_binding(text: &str) -> Option<Binding> {
 
 /// Every listed entry as the crate sees it, in dispatch priority: commands (engine, then UI),
 /// panels, tools. Each tool is its own group: tools never cycle.
-fn catalogue(p: Platform) -> Vec<Bindable> {
+fn catalogue(snapshot: &Snapshot, p: Platform) -> Vec<Bindable> {
     let rank = |e: &Entry| {
         if e.is_tool {
             2
@@ -142,14 +202,14 @@ fn catalogue(p: Platform) -> Vec<Bindable> {
             0
         }
     };
-    let mut entries: Vec<&Entry> = shortcut_editor::entries().iter().collect();
+    let mut entries: Vec<&Entry> = snapshot.entries.iter().collect();
     entries.sort_by_key(|e| rank(e));
     entries
         .into_iter()
         .map(|e| {
             let mut path: Vec<String> = e.group.split(" › ").filter(|s| !s.is_empty()).map(str::to_string).collect();
             path.push(e.label.clone());
-            let mut b = Bindable::new(command_of(&e.key), e.label.clone(), Scope::app()).with_path(path);
+            let mut b = Bindable::new(command_in(&e.key, &snapshot.effects), e.label.clone(), Scope::app()).with_path(path);
             if let Some(tool) = e.key.strip_prefix("tool:") {
                 b = b.with_kind(Kind::Tool { group: Some(tool.to_string()) });
             }
@@ -208,34 +268,54 @@ pub fn note_os(ctx: &egui::Context) {
     }
 }
 
-/// The value for `p` in `cells`, made on first use. Each platform has its own cell, because the
-/// web build learns the browser's platform only after the first frame.
-pub(crate) fn per_platform<T>(cells: &'static [OnceLock<T>; 3], p: Platform, make: impl FnOnce() -> T) -> &'static T {
-    let [mac, windows, other] = cells;
-    let cell = match p {
-        Platform::Mac => mac,
-        Platform::Windows => windows,
-        _ => other,
-    };
-    cell.get_or_init(make)
+/// The keymap with the default shortcuts for [`platform`] and the plug-ins installed now.
+pub fn template() -> Arc<Keymap> {
+    template_for(&shortcut_editor::snapshot())
 }
 
-/// The keymap with the default shortcuts for [`platform`], built once per platform.
-pub fn template() -> &'static Keymap {
-    static TEMPLATES: [OnceLock<Keymap>; 3] = [OnceLock::new(), OnceLock::new(), OnceLock::new()];
+/// The keymap with the default shortcuts for [`platform`] and the entries of `snapshot`, built
+/// once per platform and plug-in revision. Each platform has its own cell, because the web build
+/// learns the browser's platform only after the first frame.
+pub(crate) fn template_for(snapshot: &Snapshot) -> Arc<Keymap> {
+    /// A template and the plug-in revision it was built for.
+    type Built = Option<(u64, Arc<Keymap>)>;
+    static TEMPLATES: Mutex<[Built; 3]> = Mutex::new([None, None, None]);
     let p = platform();
-    per_platform(&TEMPLATES, p, || keymap_for(p))
+    let at = match p {
+        Platform::Mac => 0,
+        Platform::Windows => 1,
+        _ => 2,
+    };
+    let cached = TEMPLATES.lock().unwrap_or_else(|e| e.into_inner())[at].clone();
+    if let Some((_, km)) = cached.filter(|(revision, _)| *revision == snapshot.revision) {
+        return km;
+    }
+    let km = Arc::new(keymap_for(p, snapshot));
+    let mut cells = TEMPLATES.lock().unwrap_or_else(|e| e.into_inner());
+    if cells[at].as_ref().is_none_or(|(revision, _)| *revision <= snapshot.revision) {
+        cells[at] = Some((snapshot.revision, km.clone()));
+    }
+    km
 }
 
-/// The default keymap of `p`. The chords the operating system takes can't be assigned.
-pub(crate) fn keymap_for(p: Platform) -> Keymap {
-    Keymap::new(catalogue(p), Scopes::new(), p).with_reserved(craft_keymap::reserved::system(p))
+/// The default keymap of `p` with the entries of `snapshot`. The chords the operating system
+/// takes can't be assigned.
+pub(crate) fn keymap_for(p: Platform, snapshot: &Snapshot) -> Keymap {
+    Keymap::new(catalogue(snapshot, p), Scopes::new(), p).with_reserved(craft_keymap::reserved::system(p))
 }
 
 /// The keymap with `overrides` applied.
 pub fn keymap_with(overrides: &Overrides) -> Keymap {
-    let defaults = template();
-    defaults.clone().with_overrides(edit_alias_overrides(overrides, defaults.platform()))
+    keymap_in(&shortcut_editor::snapshot(), overrides)
+}
+
+/// The keymap of `snapshot`'s entries with `overrides` applied, each Effect menu item's shortcut
+/// under the command its item runs now.
+pub(crate) fn keymap_in(snapshot: &Snapshot, overrides: &Overrides) -> Keymap {
+    let defaults = template_for(snapshot);
+    let moved = effect_keys_in(overrides, &snapshot.effects);
+    let resolved = edit_alias_overrides(&moved, defaults.platform());
+    defaults.as_ref().clone().with_overrides(resolved)
 }
 
 /// When a saved override assigns F2, F3 or F4 elsewhere without changing its edit command,
@@ -277,7 +357,7 @@ pub fn lookup(km: &Keymap, chord: &Chord) -> Option<CommandRef> {
 pub fn effective_with(km: &Keymap, key: &str) -> Option<String> {
     let command = command_of(key);
     if km.bindable(&command).is_none() {
-        return match km.overrides().get(&stored_key(key)) {
+        return match stored_texts(km.overrides(), key) {
             Some(texts) => texts.first().filter(|t| !t.trim().is_empty()).map(|t| crate_to_vc(t)),
             None => shortcut_editor::default_of(key).map(str::to_string),
         };
@@ -297,6 +377,9 @@ pub fn effective_with(km: &Keymap, key: &str) -> Option<String> {
 /// Sets an entry's shortcut in VectorCraft's terms: `""` for none.
 pub fn set_override(overrides: &mut Overrides, key: &str, text: &str) {
     let texts = if text.trim().is_empty() { vec![] } else { vec![vc_to_crate(text)] };
+    if let Some(k) = other_stored_key(key) {
+        overrides.remove(&k);
+    }
     // Only an over-long key or text is refused; such an entry could not be stored anyway.
     let _ = overrides.insert(stored_key(key), texts);
 }
@@ -312,11 +395,11 @@ pub fn overrides_from(pairs: &[(&str, &str)]) -> Overrides {
 
 /// An entry's stored shortcut in VectorCraft's terms (`""` for none), when it has an override.
 pub fn override_text(overrides: &Overrides, key: &str) -> Option<String> {
-    overrides.get(&stored_key(key)).map(|t| t.first().map(|t| crate_to_vc(t)).unwrap_or_default())
+    stored_texts(overrides, key).map(|t| t.first().map(|t| crate_to_vc(t)).unwrap_or_default())
 }
 
 pub fn has_override(overrides: &Overrides, key: &str) -> bool {
-    overrides.get(&stored_key(key)).is_some()
+    stored_texts(overrides, key).is_some()
 }
 
 /// Serde for [`Overrides`] in VectorCraft's own form, which every earlier version reads: a map
@@ -428,7 +511,7 @@ mod tests {
 
     #[test]
     fn curvature_keeps_shift_tilde_and_plus_is_one_key() {
-        let km = template();
+        let km = &*template();
         let curvature = vc_chord("Shift+~").unwrap();
         assert_eq!(curvature, Chord::parse("Shift+`").unwrap());
         assert_eq!(lookup(km, &curvature), Some(CommandRef::new("tool:curvature")));
@@ -448,17 +531,21 @@ mod tests {
 
     #[test]
     fn the_default_shortcuts_do_not_conflict() {
-        assert_eq!(template().conflicts(), vec![]);
-        assert_eq!(template().problems(), vec![]);
-        assert_eq!(template().catalog().len(), shortcut_editor::entries().len(), "every entry is bindable");
+        // One snapshot: tests running beside this one install and remove plug-ins.
+        let snapshot = shortcut_editor::snapshot();
+        let template = template_for(&snapshot);
+        assert_eq!(template.conflicts(), vec![]);
+        assert_eq!(template.problems(), vec![]);
+        assert_eq!(template.catalog().len(), snapshot.entries.len(), "every entry is bindable");
         // A default the bridge can't read would show in the menus but never run.
-        let unbound: Vec<(&str, &str)> = shortcut_editor::entries()
+        let unbound: Vec<(&str, &str)> = snapshot
+            .entries
             .iter()
             .filter_map(|e| shortcut_editor::default_of(&e.key).map(|d| (e.key.as_str(), d)))
             .filter(|(key, d)| {
                 let mut expected: Vec<Binding> = vc_binding(d).into_iter().collect();
                 expected.extend(default_aliases(key, platform()).iter().filter_map(|alias| vc_binding(alias)));
-                expected != template().default_bindings(&command_of(key))
+                expected != template.default_bindings(&command_in(key, &snapshot.effects))
             })
             .collect();
         assert_eq!(unbound, vec![], "every default text becomes the entry's binding");
@@ -471,10 +558,10 @@ mod tests {
             let defaults = template().default_bindings(&command);
             assert_eq!(defaults, vec![vc_binding(plain).unwrap(), vc_binding(shifted).unwrap()], "{key}");
             assert_eq!(
-                shortcut_editor::entry(key).map(|e| e.label.as_str()),
+                shortcut_editor::entry(key).as_ref().map(|e| e.label.as_str()),
                 Some(if key == "paint.lastColor" { "Apply Last Color" } else { "Apply Last Gradient" })
             );
-            assert_eq!(effective_with(template(), key).as_deref(), Some(plain));
+            assert_eq!(effective_with(&template(), key).as_deref(), Some(plain));
             let mut overrides = Overrides::new();
             set_override(&mut overrides, key, "Shift+;");
             assert_eq!(keymap_with(&overrides).bindings(&command), vec![vc_binding("Shift+;").unwrap()]);
@@ -487,7 +574,7 @@ mod tests {
     #[test]
     fn edit_function_keys_follow_platform_and_reset_restores_both_bindings() {
         for p in [Platform::Windows, Platform::Linux, Platform::Mac] {
-            let km = keymap_for(p);
+            let km = keymap_for(p, &shortcut_editor::snapshot());
             for (key, primary, alternate) in [("edit.cut", "Cmd+X", "F2"), ("edit.copy", "Cmd+C", "F3"), ("edit.paste", "Cmd+V", "F4")] {
                 let command = command_of(key);
                 let mut expected = vec![vc_binding(primary).unwrap()];
@@ -514,16 +601,16 @@ mod tests {
             for (alias, edit, primary) in [("F2", "edit.cut", "Cmd+X"), ("F3", "edit.copy", "Cmd+C"), ("F4", "edit.paste", "Cmd+V")] {
                 let mut saved = Overrides::new();
                 set_override(&mut saved, "tool:pen", alias);
-                let assigned = keymap_for(p).with_overrides(edit_alias_overrides(&saved, p));
+                let assigned = keymap_for(p, &shortcut_editor::snapshot()).with_overrides(edit_alias_overrides(&saved, p));
                 assert_eq!(lookup(&assigned, &vc_chord(alias).unwrap()), Some(command_of("tool:pen")), "{p:?} saved {alias} assignment");
                 assert_eq!(lookup(&assigned, &vc_chord(primary).unwrap()), Some(command_of(edit)), "{p:?} primary {edit} binding");
                 shortcut_editor::reset_one(&mut saved, "tool:pen");
-                let reset = keymap_for(p).with_overrides(edit_alias_overrides(&saved, p));
+                let reset = keymap_for(p, &shortcut_editor::snapshot()).with_overrides(edit_alias_overrides(&saved, p));
                 assert_eq!(lookup(&reset, &vc_chord(alias).unwrap()), (!p.is_mac()).then_some(command_of(edit)), "{p:?} reset saved {alias}");
             }
             let mut unknown = Overrides::new();
             set_override(&mut unknown, "missing.command", "F2");
-            let km = keymap_for(p).with_overrides(edit_alias_overrides(&unknown, p));
+            let km = keymap_for(p, &shortcut_editor::snapshot()).with_overrides(edit_alias_overrides(&unknown, p));
             assert_eq!(lookup(&km, &vc_chord("F2").unwrap()), (!p.is_mac()).then_some(command_of("edit.cut")), "{p:?} unknown saved entry");
         }
     }
@@ -531,10 +618,12 @@ mod tests {
     /// The chords the operating system takes are refused, and no default uses one.
     #[test]
     fn system_shortcuts_are_refused() {
+        let snapshot = shortcut_editor::snapshot();
         for (p, os_chord) in [(Platform::Mac, "Cmd+Tab"), (Platform::Windows, "Alt+F4"), (Platform::Linux, "Ctrl+Alt+F2")] {
-            let mut km = keymap_for(p);
+            let mut km = keymap_for(p, &snapshot);
             assert_eq!((km.conflicts(), km.problems()), (vec![], vec![]), "{p:?}");
-            let reserved: Vec<String> = shortcut_editor::entries()
+            let reserved: Vec<String> = snapshot
+                .entries
                 .iter()
                 .filter(|e| km.bindings(&command_of(&e.key)).iter().any(|b| km.is_reserved(&b.trigger.chord)))
                 .map(|e| e.key.clone())
@@ -545,7 +634,7 @@ mod tests {
             // A saved override on a reserved chord keeps the default.
             let mut ov = Overrides::new();
             let _ = ov.insert(stored_key("edit.undo"), vec![os_chord.to_string()]);
-            let km = keymap_for(p).with_overrides(ov);
+            let km = keymap_for(p, &snapshot).with_overrides(ov);
             assert_eq!(km.bindings(&command_of("edit.undo")), km.default_bindings(&command_of("edit.undo")), "{p:?}");
         }
     }
@@ -557,7 +646,8 @@ mod tests {
         assert_eq!(entry_key(&c), "panel:layers");
         assert_eq!(entry_of_stored(&stored_key("panel:layers")), "panel:layers");
         assert_eq!(stored_key("tool:pen"), "tool:pen");
-        let paths = &template().bindable(&c).unwrap().paths;
+        let template = template();
+        let paths = &template.bindable(&c).unwrap().paths;
         assert_eq!(paths, &vec![vec!["Window".to_string(), "Layers".to_string()]], "import matches panels by name");
     }
 
@@ -569,7 +659,8 @@ mod tests {
         for id in TOGGLES {
             let label = crate::menus::dynamic_label(&app, id, "");
             assert!(label.starts_with("Show ") || label.starts_with("Hide "), "{id}: {label}");
-            let listed = template().bindable(&CommandRef::new(*id));
+            let template = template();
+            let listed = template.bindable(&CommandRef::new(*id));
             assert!(listed.is_none_or(|b| b.is_toggle), "{id}");
         }
     }
diff --git a/crates/ui-egui/src/menus/invoke.rs b/crates/ui-egui/src/menus/invoke.rs
index a29714b1a..2594b6842 100644
--- a/crates/ui-egui/src/menus/invoke.rs
+++ b/crates/ui-egui/src/menus/invoke.rs
@@ -1,4 +1,4 @@
-use super::state::{SUBJECT_COMMANDS, has_subject, waits_for_ime};
+use super::state::{SUBJECT_COMMANDS, enabled, has_subject, waits_for_ime};
 use super::{Value, VectorcraftApp, json};
 
 /// What a menu click runs: items whose label ends with "…" and that carry default params open a
@@ -138,6 +138,10 @@ pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
     if waits_for_ime(app, id) {
         return;
     }
+    // A shortcut or a palette pick on a filter plug-in does nothing while its menu item is dimmed.
+    if id == "plugin.dialog" && !enabled(app, id) {
+        return;
+    }
     if SUBJECT_COMMANDS.contains(&id)
         && p.get("ids").is_none_or(|ids| ids.as_array().is_some_and(Vec::is_empty))
         && p.get("id").is_none()
@@ -267,6 +271,13 @@ fn open_view_dialog(app: &mut VectorcraftApp, id: &str, p: &Value) -> bool {
         let _ = app.run("ui.paramDialog", json!({"command": id, "label": "New View", "params": {"name": name}}));
         return true;
     }
+    // Composite Fonts…: the document's composite fonts, to edit before OK sets them.
+    if id == crate::dialogs::composite_fonts::COMMAND && p.as_object().is_none_or(|o| o.is_empty()) {
+        if let Err(e) = crate::dialogs::composite_fonts::open(app) {
+            app.status(e);
+        }
+        return true;
+    }
     // Edit Views…: the saved views in a list, to rename or delete.
     if id == "view.saved.edit" && p.as_object().is_none_or(|o| o.is_empty()) {
         if let Err(e) = crate::dialogs::edit_views::open(app) {
diff --git a/crates/ui-egui/src/menus/labels.rs b/crates/ui-egui/src/menus/labels.rs
index 3c3b06425..8cc4a5c36 100644
--- a/crates/ui-egui/src/menus/labels.rs
+++ b/crates/ui-egui/src/menus/labels.rs
@@ -212,11 +212,13 @@ pub(super) fn unlock_item_label(app: &VectorcraftApp, id: &str, p: &Value, lang:
 }
 
 /// The shortcut a menu item shows: its command's (items without params), a panel's for the
-/// Window menu's `window.panel {panel}` items, or an effect's for the Effect menu's items.
+/// Window menu's `window.panel {panel}` items, an effect's for the Effect menu's items, or a filter
+/// plug-in's for Object › Plug-ins' `plugin.dialog {id}` items.
 pub fn item_shortcut(id: &str, p: &Value) -> Option<&'static str> {
     match (id, p.get("panel").and_then(Value::as_str)) {
         ("window.panel", Some(panel)) => crate::shortcut_editor::panel_shortcut(panel),
         ("effect.dialog" | "effect.apply", _) => p.get("effect").and_then(Value::as_str).and_then(crate::shortcut_editor::effect_shortcut),
+        ("plugin.dialog", _) => p.get("id").and_then(Value::as_str).and_then(crate::shortcut_editor::filter_shortcut),
         // The Artboard tool's canvas menu passes the point its Paste goes to.
         ("edit.paste", _) => shortcut_of(id),
         // That menu's Cut and Copy: with the tool chosen, the keys run `edit.cut` and `edit.copy`, which do the same.
diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rs
index ff5ccda13..1c09d3899 100644
--- a/crates/ui-egui/src/menus/state.rs
+++ b/crates/ui-egui/src/menus/state.rs
@@ -135,12 +135,19 @@ fn swapped_out(app: &VectorcraftApp, id: &str) -> bool {
     enabled(app, "object.envelope.release") != reset
 }
 
+/// Menu items shown only with Preferences › Type › Show East Asian Options on: Type › Composite
+/// Fonts….
+fn east_asian_hidden(app: &VectorcraftApp, id: &str) -> bool {
+    id == crate::dialogs::composite_fonts::COMMAND && !app.session.prefs.show_east_asian_options
+}
+
 /// How the menus show item `id` (params `p`) now: (enabled, checked: `Some` for an item that is on
-/// or off), or `None` while they leave it out: an empty slot ([`hidden_when_disabled`]) or an item
-/// another stands in for ([`swapped_out`]).
+/// or off), or `None` while they leave it out: an empty slot ([`hidden_when_disabled`]), an item
+/// another stands in for ([`swapped_out`]) or an East Asian item with those options hidden
+/// ([`east_asian_hidden`]).
 pub fn shown_state(app: &VectorcraftApp, id: &str, p: &Value) -> Option<(bool, Option<bool>)> {
     let en = enabled(app, id) && (id != crate::addons::select::link_status::COMMAND || crate::addons::select::link_status::enabled(app, p));
-    if (!en && hidden_when_disabled(id)) || swapped_out(app, id) {
+    if (!en && hidden_when_disabled(id)) || swapped_out(app, id) || east_asian_hidden(app, id) {
         return None;
     }
     Some((en, checked(app, id, p)))
diff --git a/crates/ui-egui/src/menus/tree.rs b/crates/ui-egui/src/menus/tree.rs
index 0df18da50..83f6d6db4 100644
--- a/crates/ui-egui/src/menus/tree.rs
+++ b/crates/ui-egui/src/menus/tree.rs
@@ -406,6 +406,7 @@ pub fn menu_tree_named(english_names: bool) -> Vec<(&'static str, Vec<Item>)> {
                 c("Fit Headline", "text.fitHeadline"),
                 Sep,
                 c("Find Font…", "type.findFont"),
+                c("Composite Fonts…", crate::dialogs::composite_fonts::COMMAND),
                 sub(
                     "Change Case",
                     vec![
diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs
index f0ceda22a..5e985bae2 100644
--- a/crates/ui-egui/src/menus/ui_commands.rs
+++ b/crates/ui-egui/src/menus/ui_commands.rs
@@ -1475,7 +1475,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "ui.installPlugin",
         "Install Plug-in…",
         "",
-        "{path?: a .wasm file | dataBase64?: the module, name?: the file name shown as its source (with dataBase64), allowHeavy?: bool (the user agreed to its heavy budget), grant?: [permission] (the permissions the user granted it), replace?: bool, hash?: the module's SHA-256 (as plugin.install)} install a WebAssembly plug-in (plugin.install); without a path pick one (the web opens the browser's file picker; File › Open of a .wasm installs it too). A plug-in that lists permissions the user hasn't granted it asks the user first, showing its name, id, version, file SHA-256 and what each permission lets it do, and so does a filter that asks for a heavy budget: OK installs it if the file still has the SHA-256 shown, Cancel installs nothing → plugin.install's result | {pending: \"confirm\"} while it asks",
+        "{path?: a .wasm file | dataBase64?: the module, name?: the file name shown as its source (with dataBase64), allowHeavy?: bool (the user agreed to its heavy budget), grant?: [permission] (the permissions the user granted it), replace?: bool (true: the user agreed it takes the place of the plug-in with its id, as plugin.install), hash?: the module's SHA-256 (as plugin.install)} install a WebAssembly plug-in (plugin.install); without a path pick one (the web opens the browser's file picker; File › Open of a .wasm installs it too). A plug-in that lists permissions the user hasn't granted it asks the user first, showing its name, id, version, file SHA-256 and what each permission lets it do, so does a filter that asks for a heavy budget, and so does one without replace that would take the place of another module with its id and get its settings and cache (needsReplace in plugin.inspect), showing its id and file SHA-256: OK installs it if the file still has the SHA-256 shown, Cancel installs nothing → plugin.install's result | {pending: \"confirm\"} while it asks",
     ),
     (
         "plugin.cancelRuns",
diff --git a/crates/ui-egui/src/palette.rs b/crates/ui-egui/src/palette.rs
index 4f893e686..14f0b8a9d 100644
--- a/crates/ui-egui/src/palette.rs
+++ b/crates/ui-egui/src/palette.rs
@@ -16,7 +16,8 @@ pub fn items() -> Vec<(String, String, String)> {
         let label = if path.is_empty() { c.label.to_string() } else { format!("{path} › {}", c.label) };
         items.push((label, c.id.to_string(), menus::shortcut_of(c.id).unwrap_or("").to_string()));
     }
-    for c in menus::UI_COMMANDS {
+    // `plugin.dialog` runs nothing without an id: [`build`] lists each filter instead.
+    for c in menus::UI_COMMANDS.iter().filter(|c| c.0 != "plugin.dialog") {
         items.push((c.1.to_string(), c.0.to_string(), menus::shortcut_of(c.0).unwrap_or("").to_string()));
     }
     for tool in vectorcraft_tools::catalog::all_tools() {
@@ -32,7 +33,7 @@ fn shown_label(lang: crate::i18n::Lang, label: &str) -> String {
 }
 
 /// One palette entry, with what it shows and what a query matches worked out once.
-struct Entry {
+pub(crate) struct Entry {
     id: String,
     shortcut: String,
     /// The label in the UI language.
@@ -59,20 +60,47 @@ fn entries(ctx: &egui::Context, lang: crate::i18n::Lang) -> Arc<Vec<Entry>> {
     {
         return v;
     }
-    let built: Arc<Vec<Entry>> = Arc::new(
-        items()
-            .into_iter()
-            .map(|(label, id, shortcut)| {
-                let shown = shown_label(lang, &label);
-                let haystack = format!("{}\n{}\n{}", label.to_lowercase(), shown.to_lowercase(), id.to_lowercase());
-                Entry { id, shortcut, shown, haystack }
-            })
-            .collect(),
-    );
+    let built: Arc<Vec<Entry>> = Arc::new(build(lang));
     ctx.data_mut(|d| d.insert_temp::<Cached>(id, (key, built.clone())));
     built
 }
 
+/// The palette's entries in `lang`: [`items`], then one per filter plug-in's Object › Plug-ins
+/// item (`plugin:<id>`), whose name is not translated.
+fn build(lang: crate::i18n::Lang) -> Vec<Entry> {
+    let entry = |label: String, shown: String, id: String, shortcut: String| {
+        let haystack = format!("{}\n{}\n{}", label.to_lowercase(), shown.to_lowercase(), id.to_lowercase());
+        Entry { id, shortcut, shown, haystack }
+    };
+    let mut out: Vec<Entry> = items()
+        .into_iter()
+        .map(|(label, id, shortcut)| {
+            let shown = shown_label(lang, &label);
+            entry(label, shown, id, shortcut)
+        })
+        .collect();
+    out.extend(crate::shortcut_editor::filter_items().iter().map(|f| {
+        let shortcut = crate::shortcut_editor::filter_shortcut(&f.id).unwrap_or("").to_string();
+        let label = format!("{} › {}", f.group, f.label);
+        let shown = format!("{} › {}", shown_label(lang, &f.group), f.label);
+        entry(label, shown, format!("plugin:{}", f.id), shortcut)
+    }));
+    out
+}
+
+/// Runs the palette result `id`: selects a tool, or invokes a command with the params its entry
+/// stands for.
+pub(crate) fn run_pick(app: &mut VectorcraftApp, id: &str) {
+    if let Some(tool) = id.strip_prefix("tool:") {
+        app.select_tool(tool);
+    } else if id.starts_with("plugin:") {
+        let command = crate::keymap::command_of(id);
+        menus::invoke(app, &command.id, command.params);
+    } else {
+        menus::invoke(app, id, json!({}));
+    }
+}
+
 pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     if !app.ui.palette_open {
         return;
@@ -137,11 +165,7 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
     ctx.data_mut(|d| d.insert_temp(sel_id, (sel, q)));
     if let Some(id) = run {
         app.ui.palette_open = false;
-        if let Some(tool) = id.strip_prefix("tool:") {
-            app.select_tool(tool);
-        } else {
-            menus::invoke(app, &id, json!({}));
-        }
+        run_pick(app, &id);
     }
 }
 
@@ -264,4 +288,39 @@ mod tests {
         app.ui.palette_query = "zoom in".into();
         assert_eq!(frame(&mut app, vec![]), 0);
     }
+
+    /// Each filter plug-in has one result, also when two share a name: its menu path translates,
+    /// the plug-in's name does not, and a pick runs that filter (a dialog for one with parameters,
+    /// nothing with no document open).
+    #[test]
+    fn each_filter_plugin_is_a_result_of_its_own() {
+        use vectorcraft_plugins::wat as tpl;
+        let (one, two) = ("test.UI.palette_filter-one", "test.UI.palette_filter-two");
+        let (key_one, key_two) = (format!("plugin:{one}"), format!("plugin:{two}"));
+        let install = |id: &str, params: &str| {
+            let manifest = format!(r#"{{"id":"{id}","name":"Group","version":"1","kind":"filter","params":{params}}}"#);
+            vectorcraft_plugins::registry::install_bytes(&wat::parse_str(tpl::returning(&manifest, r#"{"objects":[]}"#)).unwrap()).unwrap();
+        };
+        install(one, "{}");
+        install(two, r#"{"wiggle":{"type":"bool"}}"#);
+        let zh = Lang::from_code("zh-hant").unwrap();
+        let built = build(zh);
+        let of = |key: &str| built.iter().filter(|e| e.id == key).collect::<Vec<_>>();
+        assert_eq!((of(&key_one).len(), of(&key_two).len()), (1, 1));
+        assert!(built.iter().all(|e| e.id != "plugin.dialog"), "no result without a filter's id");
+        let path = format!("{} › {}", crate::i18n::tr(zh, "Object"), crate::i18n::tr(zh, "Plug-ins"));
+        assert_eq!(of(&key_two)[0].shown, format!("{path} › Group…"));
+        assert_eq!(of(&key_one)[0].shown, format!("{path} › Group"));
+        assert!(of(&key_two)[0].haystack.contains("object › plug-ins › group…"));
+
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), crate::Services::default());
+        run_pick(&mut app, &key_two);
+        assert!(app.ui.dialog.is_none(), "no document: the dimmed item's pick does nothing");
+        app.run("file.new", json!({"width": 200, "height": 200})).unwrap();
+        run_pick(&mut app, &key_two);
+        let d = app.ui.dialog.take().expect("the filter's dialog opens");
+        assert_eq!((d.kind.as_str(), d.str("__plugin")), ("plugin", two.to_string()));
+        vectorcraft_plugins::registry::remove(one);
+        vectorcraft_plugins::registry::remove(two);
+    }
 }
diff --git a/crates/ui-egui/src/shortcut_editor.rs b/crates/ui-egui/src/shortcut_editor.rs
index 2bee024da..5dcf390fd 100644
--- a/crates/ui-egui/src/shortcut_editor.rs
+++ b/crates/ui-egui/src/shortcut_editor.rs
@@ -65,13 +65,17 @@ pub(crate) use ui_mirror;
 /// The keymap with the user's overrides, and the effective text of every entry they change.
 pub(crate) struct Mirror {
     pub keymap: Keymap,
-    source_overrides: Overrides,
     text: HashMap<String, Option<&'static str>>,
+    /// The overrides this was built from, as the UI state holds them.
+    source: Overrides,
+    /// The plug-in revision of the entries the keymap holds ([`Snapshot::revision`]).
+    revision: u64,
 }
 
 impl Mirror {
     fn new(overrides: Overrides) -> Mirror {
-        let keymap = crate::keymap::keymap_with(&overrides);
+        let snapshot = snapshot();
+        let keymap = crate::keymap::keymap_in(&snapshot, &overrides);
         let text = overrides
             .iter()
             .map(|(k, _)| {
@@ -80,20 +84,41 @@ impl Mirror {
                 (key, t)
             })
             .collect();
-        Mirror { keymap, source_overrides: overrides, text }
+        Mirror { keymap, text, source: overrides, revision: snapshot.revision }
+    }
+
+    /// Was this built from `overrides` for the platform and the plug-ins in effect now?
+    fn is_for(&self, overrides: &Overrides) -> bool {
+        self.source == *overrides && self.revision == menus::plugin_revision() && self.keymap.platform() == crate::keymap::platform()
     }
 }
 
 ui_mirror!(fn store() -> Option<Arc<Mirror>>);
 
-/// The mirror: the keymap in effect.
+/// The mirror: the keymap in effect. One the plug-ins installed or removed since it was built
+/// left behind is built again, with the overrides it was built from.
 pub(crate) fn current() -> Arc<Mirror> {
-    static DEFAULTS: [OnceLock<Arc<Mirror>>; 3] = [OnceLock::new(), OnceLock::new(), OnceLock::new()];
-    store()
-        .read()
-        .ok()
-        .and_then(|m| m.clone())
-        .unwrap_or_else(|| crate::keymap::per_platform(&DEFAULTS, crate::keymap::platform(), || Arc::new(Mirror::new(Overrides::new()))).clone())
+    static DEFAULT: Mutex<Option<Arc<Mirror>>> = Mutex::new(None);
+    if let Some(m) = store().read().ok().and_then(|m| m.clone()) {
+        if m.is_for(&m.source) {
+            return m;
+        }
+        let fresh = Arc::new(Mirror::new(m.source.clone()));
+        if let Ok(mut s) = store().write()
+            && s.as_ref().is_some_and(|s| Arc::ptr_eq(s, &m))
+        {
+            *s = Some(fresh.clone());
+        }
+        return fresh;
+    }
+    let none = Overrides::new();
+    let cached = DEFAULT.lock().unwrap_or_else(|e| e.into_inner()).clone();
+    if let Some(m) = cached.filter(|m| m.is_for(&none)) {
+        return m;
+    }
+    let fresh = Arc::new(Mirror::new(none));
+    *DEFAULT.lock().unwrap_or_else(|e| e.into_inner()) = Some(fresh.clone());
+    fresh
 }
 
 /// Leak-once interning for override strings (bounded by the chords a user ever assigns).
@@ -113,7 +138,7 @@ pub fn sync(ui: &UiState) {
     let same = store()
         .read()
         .map(|m| match &*m {
-            Some(m) => m.source_overrides == ui.shortcut_overrides && m.keymap.platform() == crate::keymap::platform(),
+            Some(m) => m.is_for(&ui.shortcut_overrides),
             None => ui.shortcut_overrides.is_empty(),
         })
         .unwrap_or(false);
@@ -334,9 +359,54 @@ pub struct Entry {
     pub is_tool: bool,
 }
 
+/// The editor's entries, the Effect menu's effect items and Object › Plug-ins' filter items while
+/// the installed plug-ins are those of one [`menus::plugin_revision`].
+pub(crate) struct Snapshot {
+    /// The plug-in revision read before the menus were walked.
+    pub revision: u64,
+    pub effects: Arc<[EffectItem]>,
+    pub filters: Arc<[FilterItem]>,
+    pub entries: Arc<[Entry]>,
+}
+
+/// The entries for the plug-ins installed now: rebuilt when a plug-in is installed or removed, so
+/// a live-effect or filter plug-in installed later has its row, and one removed has none.
+pub(crate) fn snapshot() -> Arc<Snapshot> {
+    static LAST: Mutex<Option<Arc<Snapshot>>> = Mutex::new(None);
+    let revision = menus::plugin_revision();
+    let last = LAST.lock().unwrap_or_else(|e| e.into_inner()).clone();
+    if let Some(s) = last.filter(|s| s.revision == revision) {
+        return s;
+    }
+    // Built without the lock held: the Effect menu is walked anew.
+    let effects: Arc<[EffectItem]> = build_effect_items().into();
+    let filters: Arc<[FilterItem]> = build_filter_items().into();
+    let (head, tail) = fixed_entries();
+    let entries: Arc<[Entry]> = head
+        .iter()
+        .cloned()
+        .chain(effects.iter().map(|e| Entry { key: format!("effect:{}", e.effect), label: e.label.clone(), group: e.group.clone(), is_tool: false }))
+        .chain(filters.iter().map(|f| Entry { key: format!("plugin:{}", f.id), label: f.label.clone(), group: f.group.clone(), is_tool: false }))
+        .chain(tail.iter().cloned())
+        .collect();
+    let s = Arc::new(Snapshot { revision, effects, filters, entries });
+    let mut last = LAST.lock().unwrap_or_else(|e| e.into_inner());
+    // A newer snapshot another thread stored meanwhile stays.
+    if last.as_ref().is_none_or(|l| l.revision <= revision) {
+        *last = Some(s.clone());
+    }
+    s
+}
+
 /// Every tool, command and panel the editor can give a shortcut; [`listed`] says which it lists.
-pub fn entries() -> &'static [Entry] {
-    static E: OnceLock<Vec<Entry>> = OnceLock::new();
+pub fn entries() -> Arc<[Entry]> {
+    snapshot().entries.clone()
+}
+
+/// The entries no plug-in changes: (tools, commands and panels; UI commands). The Effect menu's
+/// items and Object › Plug-ins' filters go between them.
+fn fixed_entries() -> &'static (Vec<Entry>, Vec<Entry>) {
+    static E: OnceLock<(Vec<Entry>, Vec<Entry>)> = OnceLock::new();
     E.get_or_init(|| {
         let mut v: Vec<Entry> = vectorcraft_tools::catalog::all_tools()
             .map(|t| Entry { key: format!("tool:{}", t.id), label: t.label.to_string(), group: "Tools".into(), is_tool: true })
@@ -362,22 +432,17 @@ pub fn entries() -> &'static [Entry] {
             group: "Window".into(),
             is_tool: false,
         }));
-        // Each effect of the Effect menu, by its own key: they all run `effect.dialog` (#3296).
-        v.extend(effect_items().iter().map(|e| Entry {
-            key: format!("effect:{}", e.effect),
-            label: e.label.clone(),
-            group: e.group.clone(),
-            is_tool: false,
-        }));
+        // Each effect of the Effect menu comes next, by its own key (#3296): see [`snapshot`].
+        let mut tail = vec![];
         for (id, label, sc, params) in menus::UI_COMMANDS {
             // Rename has no default key, and a key press names the selection: it needs no `id`.
             let key_runs_it = !sc.is_empty() || params.starts_with("{}") || params.starts_with("{path") || *id == "ui.rename";
             if !seen.insert(id) || !key_runs_it {
                 continue;
             }
-            v.push(Entry { key: id.to_string(), label: label.to_string(), group: id_group(id), is_tool: false });
+            tail.push(Entry { key: id.to_string(), label: label.to_string(), group: id_group(id), is_tool: false });
         }
-        v
+        (v, tail)
     })
 }
 
@@ -391,38 +456,41 @@ pub struct EffectItem {
     pub group: String,
 }
 
-/// The Effect menu's effect items, in menu order, each once.
-pub fn effect_items() -> &'static [EffectItem] {
-    static E: OnceLock<Vec<EffectItem>> = OnceLock::new();
-    E.get_or_init(|| {
-        fn walk(items: &[menus::Item], path: &mut Vec<String>, seen: &mut HashSet<String>, out: &mut Vec<EffectItem>) {
-            for it in items {
-                match it {
-                    menus::Item::Cmd(label, id @ ("effect.dialog" | "effect.apply"), p) => {
-                        if let Some(effect) = p.get("effect").and_then(serde_json::Value::as_str)
-                            && seen.insert(effect.to_string())
-                        {
-                            out.push(EffectItem { effect: effect.to_string(), command: id, label: label.to_string(), group: path.join(" › ") });
-                        }
+/// The Effect menu's effect items, in menu order, each once, with the live-effect plug-ins
+/// installed now.
+pub fn effect_items() -> Arc<[EffectItem]> {
+    snapshot().effects.clone()
+}
+
+/// Walks the Effect menu for [`effect_items`].
+fn build_effect_items() -> Vec<EffectItem> {
+    fn walk(items: &[menus::Item], path: &mut Vec<String>, seen: &mut HashSet<String>, out: &mut Vec<EffectItem>) {
+        for it in items {
+            match it {
+                menus::Item::Cmd(label, id @ ("effect.dialog" | "effect.apply"), p) => {
+                    if let Some(effect) = p.get("effect").and_then(serde_json::Value::as_str)
+                        && seen.insert(effect.to_string())
+                    {
+                        out.push(EffectItem { effect: effect.to_string(), command: id, label: label.to_string(), group: path.join(" › ") });
                     }
-                    menus::Item::Sub(name, children) => {
-                        path.push(name.to_string());
-                        walk(children, path, seen, out);
-                        path.pop();
-                    }
-                    _ => {}
                 }
+                menus::Item::Sub(name, children) => {
+                    path.push(name.to_string());
+                    walk(children, path, seen, out);
+                    path.pop();
+                }
+                _ => {}
             }
         }
-        let mut out = vec![];
-        let mut seen = HashSet::new();
-        for (name, items) in menus::menu_tree() {
-            if name == "Effect" {
-                walk(&items, &mut vec![name.to_string()], &mut seen, &mut out);
-            }
+    }
+    let mut out = vec![];
+    let mut seen = HashSet::new();
+    for (name, items) in menus::menu_tree() {
+        if name == "Effect" {
+            walk(&items, &mut vec![name.to_string()], &mut seen, &mut out);
         }
-        out
-    })
+    }
+    out
 }
 
 /// Effective shortcut of the Effect menu item of `effect` (`effect:<id>`).
@@ -430,6 +498,74 @@ pub fn effect_shortcut(effect: &str) -> Option<&'static str> {
     effective(&format!("effect:{effect}"))
 }
 
+/// One filter plug-in's Object › Plug-ins item (`plugin.dialog {id}`) a shortcut can be given: the
+/// plug-in's id, its label (the plug-in's name, with an ellipsis when it opens a dialog) and its
+/// menu path.
+#[derive(Clone, Debug)]
+pub struct FilterItem {
+    pub id: String,
+    pub label: String,
+    pub group: String,
+}
+
+/// Object › Plug-ins' filter items, in menu order, each once, with the filter plug-ins installed
+/// now.
+pub fn filter_items() -> Arc<[FilterItem]> {
+    snapshot().filters.clone()
+}
+
+/// Walks the Object menu for [`filter_items`].
+fn build_filter_items() -> Vec<FilterItem> {
+    fn walk(items: &[menus::Item], path: &mut Vec<String>, seen: &mut HashSet<String>, out: &mut Vec<FilterItem>) {
+        for it in items {
+            match it {
+                menus::Item::Cmd(label, "plugin.dialog", p) => {
+                    if let Some(id) = p.get("id").and_then(serde_json::Value::as_str)
+                        && seen.insert(id.to_string())
+                    {
+                        out.push(FilterItem { id: id.to_string(), label: label.to_string(), group: path.join(" › ") });
+                    }
+                }
+                menus::Item::Sub(name, children) => {
+                    path.push(name.to_string());
+                    walk(children, path, seen, out);
+                    path.pop();
+                }
+                _ => {}
+            }
+        }
+    }
+    let mut out = vec![];
+    let mut seen = HashSet::new();
+    for (name, items) in menus::menu_tree() {
+        if name == "Object" {
+            walk(&items, &mut vec![name.to_string()], &mut seen, &mut out);
+        }
+    }
+    out
+}
+
+/// Effective shortcut of filter plug-in `id`'s Object › Plug-ins item (`plugin:<id>`).
+pub fn filter_shortcut(id: &str) -> Option<&'static str> {
+    effective(&format!("plugin:{id}"))
+}
+
+/// Entry `e`'s label in the UI language. A plug-in's own name is not translated.
+pub(crate) fn shown_label(e: &Entry) -> &str {
+    let plugin = e.key.starts_with("plugin:") || e.key.strip_prefix("effect:").and_then(vectorcraft_plugins::effect::plugin_id).is_some();
+    if plugin { &e.label } else { tl!(&e.label) }
+}
+
+/// A menu path in the UI language, one segment at a time.
+pub(crate) fn shown_group(group: &str) -> String {
+    group.split(" › ").map(|s| tl!(s)).collect::<Vec<_>>().join(" › ")
+}
+
+/// How Keyboard Shortcuts names entry `e`: a tool by its label, the others after their menu.
+pub(crate) fn shown_name(e: &Entry) -> String {
+    if e.is_tool || e.group.is_empty() { shown_label(e).to_string() } else { format!("{} › {}", shown_group(&e.group), shown_label(e)) }
+}
+
 /// The group of a command no menu holds: the first part of its id, capitalised (`edit.x` → "Edit").
 fn id_group(id: &str) -> String {
     let mut c = id.split('.').next().unwrap_or_default().chars();
@@ -447,7 +583,7 @@ fn runs_without_params(params: &str) -> bool {
 /// Does the editor list `e` under `overrides`? An entry that [`needs_a_value`] is listed only while
 /// the user has given it a shortcut.
 fn listed(overrides: &Overrides, e: &Entry) -> bool {
-    !needs_a_value(&e.key) || overrides.get(&crate::keymap::stored_key(&e.key)).is_some_and(|t| !t.is_empty())
+    !needs_a_value(&e.key) || crate::keymap::stored_texts(overrides, &e.key).is_some_and(|t| !t.is_empty())
 }
 
 /// Commands whose params are all optional that do nothing, or fail, when a key press runs them
@@ -583,17 +719,19 @@ fn names_a_required_field(params: &str) -> bool {
     false
 }
 
-pub fn entry(key: &str) -> Option<&'static Entry> {
-    entries().iter().find(|e| e.key == key)
+pub fn entry(key: &str) -> Option<Entry> {
+    entries().iter().find(|e| e.key == key).cloned()
 }
 
 /// Entries (other than `except`) whose effective shortcut equals `chord`.
 pub fn conflicts_with(overrides: &Overrides, chord: &str, except: &str) -> Vec<String> {
     let Some(c) = vc_chord(chord) else { return vec![] };
-    let km = keymap_with(overrides);
+    let snapshot = snapshot();
+    let km = crate::keymap::keymap_in(&snapshot, overrides);
     let p = km.platform();
     let want = Trigger::single(c).effective(p);
-    entries()
+    snapshot
+        .entries
         .iter()
         .filter(|e| e.key != except)
         .filter(|e| km.bindings(&command_of(&e.key)).iter().any(|b| b.trigger.effective(p) == want))
@@ -699,7 +837,7 @@ pub fn assign_in(km: &mut Keymap, key: &str, chord: Option<&str>, force: bool) -
 }
 
 pub fn reset_one(overrides: &mut Overrides, key: &str) {
-    overrides.remove(&crate::keymap::stored_key(key));
+    crate::keymap::remove_override(overrides, key);
 }
 
 /// Text shown for all active chords in a dialog row, with the backtick key shown as `typed`
@@ -742,14 +880,15 @@ pub fn import_json(v: &Value) -> Result<(String, Overrides), String> {
 /// row per line with the name and the shortcuts as the dialog shows them, separated by a tab. A
 /// row with no shortcut ends after the tab.
 pub fn export_text(set: &str, overrides: &Overrides) -> String {
-    let km = keymap_with(overrides);
+    let snapshot = snapshot();
+    let km = crate::keymap::keymap_in(&snapshot, overrides);
     let backtick = backtick_text();
     let shown_set = if PRESETS.contains(&set) || set == CUSTOM { tl!(set) } else { set };
     let mut out = format!("{}\n{} {shown_set}\n", tl!("Keyboard Shortcuts"), tl!("Set:"));
     for (tools, heading) in [(true, "Tools"), (false, "Menu Commands")] {
         out += &format!("\n{}\n", tl!(heading));
-        for e in entries().iter().filter(|e| e.is_tool == tools && listed(km.overrides(), e)) {
-            let name = if e.is_tool || e.group.is_empty() { tl!(&e.label).to_string() } else { format!("{} › {}", tl!(&e.group), tl!(&e.label)) };
+        for e in snapshot.entries.iter().filter(|e| e.is_tool == tools && listed(km.overrides(), e)) {
+            let name = shown_name(e);
             let sc = dialog_shortcuts_with(&km, &e.key, backtick.as_deref()).unwrap_or_default();
             out += &format!("{name}\t{sc}\n");
         }
@@ -823,10 +962,12 @@ pub fn run_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Resu
                 Ok(q) => q.unwrap_or_default().to_lowercase(),
                 Err(e) => return Some(Err(e)),
             };
-            let km = keymap_with(&app.ui.shortcut_overrides);
-            let ov = &app.ui.shortcut_overrides;
+            let snapshot = snapshot();
+            let km = crate::keymap::keymap_in(&snapshot, &app.ui.shortcut_overrides);
+            let ov = &crate::keymap::effect_keys_in(&app.ui.shortcut_overrides, &snapshot.effects);
             Ok(Value::Array(
-                entries()
+                snapshot
+                    .entries
                     .iter()
                     .filter(|e| listed(ov, e))
                     .filter(|e| q.is_empty() || e.label.to_lowercase().contains(&q) || e.key.to_lowercase().contains(&q))
@@ -960,13 +1101,17 @@ pub fn is_recording(app: &VectorcraftApp) -> bool {
 
 // ---------- dialog ----------
 
-/// The dialog's working set as a keymap, with each entry's shortcut text (in [`entries`] order)
-/// and the number of conflicts, kept between frames while the set is unchanged.
+/// The dialog's working set as a keymap, with the entries it lists, each entry's shortcut text (in
+/// their order) and the number of conflicts, kept between frames while the set and the installed
+/// plug-ins are unchanged.
 struct DialogView {
     /// The dialog's `overrides` field this was built from.
     source: Value,
     /// The [`backtick_text`] the texts show.
     backtick: Option<String>,
+    /// The plug-in revision of `entries`.
+    revision: u64,
+    entries: Arc<[Entry]>,
     keymap: Keymap,
     texts: Vec<Option<String>>,
     conflicts: usize,
@@ -974,20 +1119,32 @@ struct DialogView {
 
 impl DialogView {
     fn new(overrides: Overrides) -> DialogView {
-        let keymap = keymap_with(&overrides);
+        let snapshot = snapshot();
+        let keymap = crate::keymap::keymap_in(&snapshot, &overrides);
         let backtick = backtick_text();
-        let texts = entries().iter().map(|e| dialog_shortcuts_with(&keymap, &e.key, backtick.as_deref())).collect();
+        let texts = snapshot.entries.iter().map(|e| dialog_shortcuts_with(&keymap, &e.key, backtick.as_deref())).collect();
         let conflicts = conflicts_in(&keymap).len();
-        DialogView { source: stored::to_value(&overrides), backtick, keymap, texts, conflicts }
+        DialogView {
+            source: stored::to_value(&crate::keymap::effect_keys_in(&overrides, &snapshot.effects)),
+            backtick,
+            revision: snapshot.revision,
+            entries: snapshot.entries.clone(),
+            keymap,
+            texts,
+            conflicts,
+        }
     }
 
-    /// The view of `d`'s working set, from the cache unless the set or the backtick key's
-    /// character changed. The dialog's `overrides` field is left in its stored form.
+    /// The view of `d`'s working set, from the cache unless the set, the backtick key's character
+    /// or the installed plug-ins changed. The dialog's `overrides` field is left in its stored form.
     fn of(ctx: &egui::Context, d: &mut Dialog) -> Arc<DialogView> {
         let id = egui::Id::unique("dialog-shortcuts-view");
         let source = d.fields.get("overrides").unwrap_or(&Value::Null);
         let backtick = backtick_text();
-        if let Some(v) = ctx.data(|m| m.get_temp::<Arc<DialogView>>(id)).filter(|v| v.source == *source && v.backtick == backtick) {
+        let revision = menus::plugin_revision();
+        if let Some(v) =
+            ctx.data(|m| m.get_temp::<Arc<DialogView>>(id)).filter(|v| v.source == *source && v.backtick == backtick && v.revision == revision)
+        {
             return v;
         }
         let v = Arc::new(DialogView::new(dialog_overrides(d)));
@@ -1096,25 +1253,21 @@ pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
                 ui.label(egui::RichText::new(tl!("Shortcut")).color(t.text_dim).size(11.0));
             });
             egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, false]).show(ui, |ui| {
-                for (i, e) in entries().iter().enumerate().filter(|(_, e)| e.is_tool == tools && listed(km.overrides(), e)) {
+                for (i, e) in view.entries.iter().enumerate().filter(|(_, e)| e.is_tool == tools && listed(km.overrides(), e)) {
                     let sc = match &km {
                         Cow::Borrowed(_) => view.texts.get(i).cloned().flatten(),
                         Cow::Owned(km) => dialog_shortcuts_with(km, &e.key, view.backtick.as_deref()),
                     };
                     let matches = e.label.to_lowercase().contains(&q)
-                        || tl!(&e.label).to_lowercase().contains(&q)
+                        || shown_label(e).to_lowercase().contains(&q)
                         || e.group.to_lowercase().contains(&q)
-                        || tl!(&e.group).to_lowercase().contains(&q)
+                        || shown_group(&e.group).to_lowercase().contains(&q)
                         || sc.as_deref().is_some_and(|s| s.to_lowercase().contains(&q));
                     if !q.is_empty() && !matches {
                         continue;
                     }
                     let row = ui.horizontal(|ui| {
-                        let name = if e.is_tool || e.group.is_empty() {
-                            tl!(&e.label).to_string()
-                        } else {
-                            format!("{} › {}", tl!(&e.group), tl!(&e.label))
-                        };
+                        let name = shown_name(e);
                         let r = ui
                             .allocate_ui_with_layout(egui::vec2(360.0, 20.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
                                 ui.set_min_width(360.0);
@@ -1282,7 +1435,7 @@ fn export_dialog_set(app: &mut VectorcraftApp, command: &str) {
 fn drop_hidden(d: &mut Dialog, overrides: &Overrides) {
     for field in ["__recording", "__selected", "__conflict"] {
         let key = d.str(field);
-        if !key.is_empty() && entry(&key).is_none_or(|e| !listed(overrides, e)) {
+        if !key.is_empty() && entry(&key).is_none_or(|e| !listed(overrides, &e)) {
             d.fields.insert(field.into(), json!(""));
         }
     }
@@ -1322,9 +1475,23 @@ fn record(d: &mut Dialog, km: &mut Keymap, key: &str, chord: &str) {
 mod tests {
     use super::*;
 
+    /// Runs `f` again until no plug-in was installed or removed while it ran, and returns what it
+    /// returned. Other tests install and remove plug-ins at any time, and each changes the Effect
+    /// menu's rows.
+    fn with_steady_plugins<T>(mut f: impl FnMut() -> T) -> T {
+        for _ in 0..100 {
+            let revision = menus::plugin_revision();
+            let r = f();
+            if menus::plugin_revision() == revision {
+                return r;
+            }
+        }
+        panic!("the installed plug-ins kept changing");
+    }
+
     #[test]
     fn format_parse_round_trip_for_every_default() {
-        for e in entries() {
+        for e in entries().iter() {
             if let Some(s) = default_of(&e.key)
                 && let Some(sc) = crate::shortcuts::parse(s)
             {
@@ -1428,7 +1595,6 @@ mod tests {
         open(&mut app);
         let ctx = egui::Context::default();
         theme::install_fonts(&ctx);
-        let at = entries().iter().position(|e| e.key == "edit.clear").unwrap();
         let press = |key| egui::Event::Key { key, physical_key: Some(key), pressed: true, repeat: false, modifiers: Modifiers::NONE };
         let text = |t: &str| egui::Event::Text(t.into());
         let mut record_with = |events: Vec<egui::Event>| {
@@ -1436,7 +1602,9 @@ mod tests {
             let mut out = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| show(&mut app, ui.ctx()));
             out.textures_delta.clear();
             let d = app.ui.dialog.clone().unwrap();
-            let shown = DialogView::new(dialog_overrides(&d)).texts[at].clone();
+            let view = DialogView::new(dialog_overrides(&d));
+            let at = view.entries.iter().position(|e| e.key == "edit.clear").unwrap();
+            let shown = view.texts[at].clone();
             (crate::keymap::override_text(&dialog_overrides(&d), "edit.clear"), shown)
         };
         assert_eq!(record_with(vec![press(Key::Backtick), text("\"")]), (Some("~".to_string()), Some("\"".to_string())));
@@ -1590,18 +1758,26 @@ mod tests {
     fn export_text_lists_the_dialogs_rows_with_their_shortcuts() {
         let mut ov = Overrides::new();
         crate::keymap::set_override(&mut ov, "edit.preferences", "Ctrl+Alt+Shift+9");
-        let text = export_text("VectorCraft Defaults", &ov);
+        let (text, km, tool_rows, menu_rows) = with_steady_plugins(|| {
+            let text = export_text("VectorCraft Defaults", &ov);
+            let km = keymap_with(&ov);
+            let names = |tools: bool| -> Vec<String> {
+                entries()
+                    .iter()
+                    .filter(|e| e.is_tool == tools && listed(km.overrides(), e))
+                    .map(|e| if e.is_tool || e.group.is_empty() { format!("{}\t", e.label) } else { format!("{} › {}\t", e.group, e.label) })
+                    .collect()
+            };
+            let rows = (names(true), names(false));
+            (text, km, rows.0, rows.1)
+        });
         let lines: Vec<&str> = text.lines().collect();
         assert_eq!(lines[..4], ["Keyboard Shortcuts", "Set: VectorCraft Defaults", "", "Tools"]);
         let menu_at = lines.iter().position(|l| *l == "Menu Commands").expect("a Menu Commands section");
         assert_eq!(lines[menu_at - 1], "", "a blank line before Menu Commands");
-        let km = keymap_with(&ov);
-        let names = |tools: bool| -> Vec<String> {
-            entries().iter().filter(|e| e.is_tool == tools && listed(km.overrides(), e)).map(|e| text_row(&e.key, "")).collect()
-        };
         let names_of = |rows: &[&str]| -> Vec<String> { rows.iter().map(|l| format!("{}\t", l.split('\t').next().unwrap_or_default())).collect() };
-        assert_eq!(names_of(&lines[4..menu_at - 1]), names(true), "the Tools rows, in the dialog's order");
-        assert_eq!(names_of(&lines[menu_at + 1..]), names(false), "the Menu Commands rows, in the dialog's order");
+        assert_eq!(names_of(&lines[4..menu_at - 1]), tool_rows, "the Tools rows, in the dialog's order");
+        assert_eq!(names_of(&lines[menu_at + 1..]), menu_rows, "the Menu Commands rows, in the dialog's order");
         let pen = menus::pretty_shortcut(default_of("tool:pen").expect("the Pen tool has a default key"));
         assert!(lines[4..menu_at].contains(&text_row("tool:pen", &pen).as_str()), "{text}");
         let prefs = menus::pretty_shortcut(&effective_with(&km, "edit.preferences").expect("the shortcut set"));
@@ -1641,7 +1817,11 @@ mod tests {
             Ok(())
         }));
         app.run("shortcuts.import", json!({"data": export_json("Studio", &Overrides::new())})).unwrap();
-        assert_eq!(app.run("shortcuts.exportText", json!({"path": "/sets/Studio.txt"})), Ok(json!({"path": "/sets/Studio.txt"})));
+        let expected = with_steady_plugins(|| {
+            written.borrow_mut().clear();
+            assert_eq!(app.run("shortcuts.exportText", json!({"path": "/sets/Studio.txt"})), Ok(json!({"path": "/sets/Studio.txt"})));
+            export_text("Studio", &Overrides::new())
+        });
         assert_eq!(
             app.run("shortcuts.exportText", json!({"path": "/missing/dir/Studio.txt"})),
             Err("can't write /missing/dir/Studio.txt".to_string())
@@ -1651,7 +1831,7 @@ mod tests {
         let [(path, text)] = files.as_slice() else { panic!("{files:?}") };
         assert_eq!(path, "/sets/Studio.txt");
         assert!(text.starts_with("Keyboard Shortcuts\nSet: Studio\n\nTools\n"), "{text}");
-        assert_eq!(*text, export_text("Studio", &Overrides::new()));
+        assert_eq!(*text, expected);
     }
 
     /// The dialog's Import… leaves an action its function key when the imported set gives the key
@@ -1695,7 +1875,7 @@ mod tests {
     fn paint_dialog_rows_show_both_default_keys() {
         let view = DialogView::new(Overrides::new());
         for (key, plain, shifted) in [("paint.lastColor", ",", "Shift+Comma"), ("paint.lastGradient", ".", "Shift+Period")] {
-            let at = entries().iter().position(|e| e.key == key).unwrap();
+            let at = view.entries.iter().position(|e| e.key == key).unwrap();
             let shown = view.texts[at].as_deref().unwrap();
             let shifted = menus::pretty_shortcut(shifted);
             assert!(shown.contains(plain) && shown.contains(&shifted), "{key}: {shown}");
@@ -1706,7 +1886,7 @@ mod tests {
     #[test]
     fn edit_dialog_rows_show_primary_and_function_keys() {
         for p in [craft_keymap::Platform::Windows, craft_keymap::Platform::Linux, craft_keymap::Platform::Mac] {
-            let km = crate::keymap::keymap_for(p);
+            let km = crate::keymap::keymap_for(p, &snapshot());
             for (key, primary, alternate) in [("edit.cut", "Cmd+X", "F2"), ("edit.copy", "Cmd+C", "F3"), ("edit.paste", "Cmd+V", "F4")] {
                 let shown = dialog_shortcuts_with(&km, key, None).unwrap();
                 let primary = menus::pretty_shortcut(primary);
@@ -1835,7 +2015,7 @@ mod tests {
     #[test]
     fn duplicate_can_be_given_a_shortcut() {
         // Duplicate has no default chord (#1539): it must still be listed so one can be set.
-        assert_eq!(entry("edit.duplicate").map(|e| e.group.as_str()), Some("Edit"));
+        assert_eq!(entry("edit.duplicate").as_ref().map(|e| e.group.as_str()), Some("Edit"));
         let mut ov = Overrides::new();
         assign(&mut ov, "edit.duplicate", Some("Cmd+Alt+Shift+F8"), false).unwrap();
         assert_eq!(effective_in(&ov, "edit.duplicate").as_deref(), Some("Cmd+Alt+Shift+F8"));
@@ -1883,6 +2063,53 @@ mod tests {
             .collect()
     }
 
+    /// An open dialog lists a live-effect plug-in installed while it is open, with the shortcut its
+    /// working set gives it, and drops the row while the plug-in is removed, keeping that shortcut
+    /// in the working set.
+    #[test]
+    fn an_open_dialog_follows_live_effect_plugins() {
+        use vectorcraft_plugins::wat as tpl;
+        let (plugin, key) = ("test.ui.openfx", "effect:plugin.test.ui.openfx");
+        let wasm = wat::parse_str(tpl::module(&tpl::manifest(plugin, "effect", r#"{"wiggle":{"type":"bool"}}"#), tpl::ECHO, "", 1)).unwrap();
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+        open(&mut app);
+        let d = app.ui.dialog.as_mut().unwrap();
+        d.fields.insert("tab".into(), json!("menu"));
+        d.fields.insert("query".into(), json!("test.ui.openfx"));
+        let mut working = Overrides::new();
+        crate::keymap::set_override(&mut working, key, "Cmd+Alt+Shift+F5");
+        d.fields.insert("overrides".into(), stored::to_value(&working));
+        let ctx = egui::Context::default();
+        theme::install_fonts(&ctx);
+        let texts = |app: &mut VectorcraftApp| {
+            let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui.ctx()));
+            out.textures_delta.clear();
+            out.shapes
+                .iter()
+                .filter_map(|c| match &c.shape {
+                    egui::Shape::Text(t) => Some(t.galley.text().to_string()),
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+        };
+        let row = "Effect › Plug-ins › Test test.ui.openfx…";
+        let shortcut = menus::pretty_shortcut("Cmd+Alt+Shift+F5");
+        // The modal draws nothing in its first frame, which only sizes it.
+        texts(&mut app);
+        assert!(!texts(&mut app).iter().any(|t| t == row));
+        vectorcraft_plugins::registry::install_bytes(&wasm).unwrap();
+        let shown = texts(&mut app);
+        assert!(shown.iter().any(|t| t == row) && shown.contains(&shortcut), "{shown:?}");
+        vectorcraft_plugins::registry::remove(plugin);
+        assert!(!texts(&mut app).iter().any(|t| t == row));
+        let d = app.ui.dialog.as_ref().unwrap();
+        assert_eq!(crate::keymap::override_text(&dialog_overrides(d), key).as_deref(), Some("Cmd+Alt+Shift+F5"));
+        vectorcraft_plugins::registry::install_bytes(&wasm).unwrap();
+        let shown = texts(&mut app);
+        assert!(shown.iter().any(|t| t == row) && shown.contains(&shortcut), "{shown:?}");
+        vectorcraft_plugins::registry::remove(plugin);
+    }
+
     /// A menu command whose params need a value (Units needs `{units}`) is not listed while it has
     /// no shortcut. A shortcut the user gave it keeps it listed, where it can be changed or cleared.
     #[test]
@@ -1908,10 +2135,11 @@ mod tests {
         // whose params are all optional, one the menu bar runs without params (Rotate… opens its
         // dialog) and one that opens a dialog for its values (New Variable).
         let none = Overrides::new();
-        let dropped: Vec<&str> = entries().iter().filter(|e| default_of(&e.key).is_some() && !listed(&none, e)).map(|e| e.key.as_str()).collect();
+        let all = entries();
+        let dropped: Vec<&str> = all.iter().filter(|e| default_of(&e.key).is_some() && !listed(&none, e)).map(|e| e.key.as_str()).collect();
         assert!(dropped.is_empty(), "{dropped:?}");
         for id in ["edit.duplicate", "object.pathfinder.unite", "object.rotate", "variable.define", "object.distributeSpacing"] {
-            assert!(entry(id).is_some_and(|e| listed(&none, e)), "{id}");
+            assert!(entry(id).is_some_and(|e| listed(&none, &e)), "{id}");
         }
         for (doc, required) in [
             ("{}", false),
@@ -1940,12 +2168,12 @@ mod tests {
         let others = ["swatch.unused", "graphicStyle.unused", "document.info", "view.proofSetup", "magicWand.set", "edit.findNext"];
         for id in NEEDS_A_PARAM.iter().chain(&others) {
             let e = entry(id).unwrap_or_else(|| panic!("{id} has an entry"));
-            assert!(!listed(&none, e), "{id}");
+            assert!(!listed(&none, &e), "{id}");
             assert_eq!(default_of(id), None, "{id}");
         }
         let mut ov = Overrides::new();
         crate::keymap::set_override(&mut ov, "transparency.set", "Cmd+Alt+Shift+F10");
-        assert!(entry("transparency.set").is_some_and(|e| listed(&ov, e)));
+        assert!(entry("transparency.set").is_some_and(|e| listed(&ov, &e)));
         let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
         for id in ["transparency.set", "transparency.setOpacityMask"] {
             let list = run_command(&mut app, "shortcuts.list", &json!({ "query": id })).unwrap().unwrap();
@@ -1960,7 +2188,7 @@ mod tests {
             "addon.color.printFixes",
             "edit.findReplace",
         ] {
-            assert!(entry(id).is_some_and(|e| listed(&none, e)), "{id}");
+            assert!(entry(id).is_some_and(|e| listed(&none, &e)), "{id}");
         }
         assert_eq!(menu_target("object.path.cleanUp").map(|(id, _)| id).as_deref(), Some("ui.paramDialog"));
         assert_eq!(
@@ -2029,8 +2257,9 @@ mod tests {
             assert!(app.ui.shortcut_overrides.is_empty(), "{id} {p}");
             assert_eq!(app.ui.shortcut_set, set, "{id} {p}");
         }
-        let all = app.run("shortcuts.list", json!({})).unwrap();
-        assert_eq!(app.run("shortcuts.list", json!({"query": null})), Ok(all));
+        let (all, null_query) =
+            with_steady_plugins(|| (app.run("shortcuts.list", json!({})).unwrap(), app.run("shortcuts.list", json!({"query": null}))));
+        assert_eq!(null_query, Ok(all));
         let r = app.run("shortcuts.set", json!({"id": "object.isolate", "shortcut": "Cmd+Alt+Shift+F11", "force": null})).unwrap();
         assert_eq!(r["shortcut"], "Cmd+Alt+Shift+F11");
         assert!(app.run("shortcuts.preset", json!({"name": null})).unwrap_err().starts_with("unknown preset"));
diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs
index 713cf5dd4..bf54c3124 100644
--- a/crates/ui-egui/src/shortcuts.rs
+++ b/crates/ui-egui/src/shortcuts.rs
@@ -116,11 +116,17 @@ pub(crate) fn all_shortcuts() -> Vec<(KeyboardShortcut, &'static str, serde_json
     }
     // Effect menu items with shortcuts of their own (#3296): a chord bound to one is a command's
     // too, so the tool doesn't take Cmd+Enter bound to an effect before the keymap runs it.
-    for e in crate::shortcut_editor::effect_items() {
+    for e in crate::shortcut_editor::effect_items().iter() {
         if let Some(sc) = crate::shortcut_editor::effect_shortcut(&e.effect).and_then(parse) {
             v.push((sc, e.command, json!({ "effect": e.effect })));
         }
     }
+    // Object › Plug-ins' filter items with shortcuts, for the same reason.
+    for f in crate::shortcut_editor::filter_items().iter() {
+        if let Some(sc) = crate::shortcut_editor::filter_shortcut(&f.id).and_then(parse) {
+            v.push((sc, "plugin.dialog", json!({ "id": f.id })));
+        }
+    }
     // Most specific (most modifiers) first: `paste_command` takes the first V chord the held keys
     // match logically, so Cmd+Shift+V isn't taken by Cmd+V.
     v.sort_by_key(|(sc, ..)| {
diff --git a/crates/ui-egui/src/shortcuts/tests.rs b/crates/ui-egui/src/shortcuts/tests.rs
index 3d40a5427..cdbdeeeba 100644
--- a/crates/ui-egui/src/shortcuts/tests.rs
+++ b/crates/ui-egui/src/shortcuts/tests.rs
@@ -557,7 +557,7 @@ fn cmd_alt_k_and_cmd_alt_shift_f_highlight_the_character_fields() {
     assert!(app.ui.dialog.is_none(), "not Preferences");
     // Keyboard Shortcuts lists all three under Type; Highlight Tracking has no default key.
     for id in ["type.highlightFontName", "type.highlightKerning", "type.highlightTracking"] {
-        assert_eq!(crate::shortcut_editor::entry(id).map(|e| e.group.as_str()), Some("Type"), "{id}");
+        assert_eq!(crate::shortcut_editor::entry(id).as_ref().map(|e| e.group.as_str()), Some("Type"), "{id}");
     }
     assert_eq!(crate::menus::shortcut_of("type.highlightTracking"), None);
 }
@@ -2419,7 +2419,7 @@ fn all_registered_shortcuts_parse() {
 /// dialog for the selection.
 #[test]
 fn an_effect_menu_item_takes_a_shortcut_of_its_own() {
-    let entry = crate::shortcut_editor::entries().iter().find(|e| e.key == "effect:distort.transform").expect("Transform is listed");
+    let entry = crate::shortcut_editor::entry("effect:distort.transform").expect("Transform is listed");
     assert_eq!(entry.group, "Effect › Distort & Transform");
     assert_eq!(crate::keymap::command_of("effect:distort.transform").id, "effect.dialog");
     let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
@@ -2460,6 +2460,233 @@ fn cmd_enter_bound_to_an_effect_runs_the_effect_not_the_tool() {
     crate::shortcut_editor::sync(&crate::state::UiState::default());
 }
 
+/// A live-effect plug-in installed after Keyboard Shortcuts built its list has a row of its own:
+/// it takes a shortcut, `shortcuts.list` and its Effect › Plug-ins item show it, and the key
+/// applies the effect. While the plug-in is removed it has no row and no key is bound to it; the
+/// saved shortcut is the effect's again when the plug-in comes back, now opening the dialog of the
+/// options it has.
+#[test]
+fn a_live_effect_plugin_installed_later_takes_a_shortcut_of_its_own() {
+    use vectorcraft_plugins::wat as tpl;
+    let (plugin, effect, key) = ("test.ui.keyedfx", "plugin.test.ui.keyedfx", "effect:plugin.test.ui.keyedfx");
+    let install = |params: &str| {
+        let src = tpl::module(&tpl::manifest(plugin, "effect", params), tpl::ECHO, "", 1);
+        vectorcraft_plugins::registry::install_bytes(&wat::parse_str(src).unwrap()).unwrap();
+    };
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    let id = app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
+    app.session.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let node = vectorcraft_doc::NodeId(id.as_u64().unwrap());
+    let effects =
+        |app: &VectorcraftApp| app.session.doc().unwrap().doc.node(node).unwrap().appearance.effects.iter().filter(|e| e.id == effect).count();
+    let shown = |app: &mut VectorcraftApp| {
+        let list = crate::shortcut_editor::run_command(app, "shortcuts.list", &json!({ "query": effect })).unwrap().unwrap();
+        list.as_array().unwrap().iter().map(|e| (e["id"].as_str().unwrap_or_default().to_string(), e["shortcut"].clone())).collect::<Vec<_>>()
+    };
+    let chord = "Cmd+Alt+Shift+F6";
+    let f6 = || press(Key::F6, cmd() | Modifiers::ALT | Modifiers::SHIFT);
+    // The lists and the keymap in effect are built before the plug-in is installed.
+    assert!(crate::shortcut_editor::entry(key).is_none());
+    crate::shortcut_editor::sync(&app.ui);
+    assert!(crate::shortcuts::all_shortcuts().iter().all(|(_, _, p)| p["effect"] != effect));
+    install("{}");
+    let e = crate::shortcut_editor::entry(key).expect("listed once installed");
+    assert_eq!((e.label.as_str(), e.group.as_str()), ("Test test.ui.keyedfx", "Effect › Plug-ins"));
+    assert_eq!(crate::keymap::command_of(key).id, "effect.apply", "it has no options");
+    let set = crate::shortcut_editor::run_command(&mut app, "shortcuts.set", &json!({"id": key, "shortcut": chord})).unwrap().unwrap();
+    assert_eq!(set["shortcut"], chord);
+    assert_eq!(shown(&mut app), vec![(key.to_string(), json!(chord))]);
+    assert_eq!(crate::menus::item_shortcut("effect.apply", &json!({ "effect": effect })), Some(chord));
+    frame(&mut app, f6());
+    assert_eq!(effects(&app), 1, "the key applies the effect");
+    // Removed: no row, and no key is bound to the effect; the saved shortcut stays.
+    vectorcraft_plugins::registry::remove(plugin);
+    assert!(crate::shortcut_editor::entry(key).is_none());
+    assert_eq!(shown(&mut app), vec![]);
+    assert!(crate::shortcuts::all_shortcuts().iter().all(|(_, _, p)| p["effect"] != effect), "no key is bound to the removed effect");
+    assert!(crate::keymap::has_override(&app.ui.shortcut_overrides, key));
+    // Back, now with options: the saved shortcut opens its dialog.
+    install(r#"{"wiggle":{"type":"bool"}}"#);
+    assert_eq!(crate::keymap::command_of(key).id, "effect.dialog");
+    assert_eq!(shown(&mut app), vec![(key.to_string(), json!(chord))]);
+    assert_eq!(crate::menus::item_shortcut("effect.dialog", &json!({ "effect": effect })), Some(chord));
+    frame(&mut app, f6());
+    let d = app.ui.dialog.as_ref().expect("the effect's dialog opens");
+    assert_eq!(d.fields.get("__effect").and_then(serde_json::Value::as_str), Some(effect), "{:?}", d.kind);
+    vectorcraft_plugins::registry::remove(plugin);
+    crate::shortcut_editor::sync(&crate::state::UiState::default());
+}
+
+/// Each filter plug-in's Object › Plug-ins item has a row of its own (`plugin:<id>`), with no
+/// default shortcut, even when two filters share a name: a key given to one shows in its menu item
+/// and opens that filter's dialog, and the other stays unbound. While the plug-in is removed it
+/// has no row and no key is bound to it; the saved shortcut is the filter's again when it comes
+/// back, now running it at once since it has no parameters.
+#[test]
+fn each_filter_plugin_takes_a_shortcut_of_its_own() {
+    use serde_json::Value;
+    use vectorcraft_plugins::wat as tpl;
+    let (one, two) = ("test.UI.key_filter-one", "test.UI.key_filter-two");
+    let (key_one, key_two) = (format!("plugin:{one}"), format!("plugin:{two}"));
+    let install = |id: &str, name: &str, params: &str| {
+        let manifest = format!(r#"{{"id":"{id}","name":"{name}","version":"1","kind":"filter","params":{params}}}"#);
+        vectorcraft_plugins::registry::install_bytes(&wat::parse_str(tpl::returning(&manifest, r#"{"objects":[]}"#)).unwrap()).unwrap();
+    };
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    let id = app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 20, "height": 20})).unwrap()["id"].clone();
+    app.session.execute("select.set", &json!({"ids": [id]})).unwrap();
+    let shown = |app: &mut VectorcraftApp| {
+        let list = crate::shortcut_editor::run_command(app, "shortcuts.list", &json!({ "query": "test.ui.key_filter-" })).unwrap().unwrap();
+        list.as_array().unwrap().iter().map(|e| (e["id"].as_str().unwrap_or_default().to_string(), e["shortcut"].clone())).collect::<Vec<_>>()
+    };
+    let chord = "Cmd+Alt+Shift+F7";
+    let f7 = || press(Key::F7, cmd() | Modifiers::ALT | Modifiers::SHIFT);
+    crate::shortcut_editor::sync(&app.ui);
+    install(one, "Same Name", "{}");
+    install(two, "Same Name", r#"{"wiggle":{"type":"bool"}}"#);
+    let rows: Vec<_> = [&key_one, &key_two].iter().map(|k| crate::shortcut_editor::entry(k).map(|e| (e.label, e.group, e.is_tool))).collect();
+    let group = "Object › Plug-ins".to_string();
+    assert_eq!(rows, [Some(("Same Name".into(), group.clone(), false)), Some(("Same Name…".into(), group.clone(), false))]);
+    for key in [&key_one, &key_two] {
+        assert_eq!(crate::shortcut_editor::default_of(key), None, "no default shortcut");
+        let command = crate::keymap::command_of(key);
+        assert_eq!(command.id, "plugin.dialog");
+        assert_eq!(crate::keymap::entry_key(&command), *key, "the id is kept whole");
+        assert_eq!(crate::keymap::entry_of_stored(&crate::keymap::stored_key(key)), *key);
+    }
+    assert_eq!(shown(&mut app), vec![(key_one.clone(), Value::Null), (key_two.clone(), Value::Null)]);
+    let set = crate::shortcut_editor::run_command(&mut app, "shortcuts.set", &json!({"id": key_two, "shortcut": chord})).unwrap().unwrap();
+    assert_eq!(set["shortcut"], chord);
+    assert_eq!(shown(&mut app), vec![(key_one.clone(), Value::Null), (key_two.clone(), json!(chord))]);
+    assert_eq!(crate::menus::item_shortcut("plugin.dialog", &json!({ "id": two })), Some(chord));
+    assert_eq!(crate::menus::item_shortcut("plugin.dialog", &json!({ "id": one })), None);
+    let text = crate::shortcut_editor::export_text("Custom", &app.ui.shortcut_overrides);
+    let lines: Vec<&str> = text.lines().filter(|l| l.starts_with("Object › Plug-ins › Same Name")).collect();
+    assert_eq!(lines.len(), 2, "{text}");
+    assert_eq!(lines[0], "Object › Plug-ins › Same Name\t");
+    assert!(lines[1].starts_with("Object › Plug-ins › Same Name…\t") && lines[1].ends_with("+Alt+Shift+F7"), "{}", lines[1]);
+    // A chord an Effect menu item holds is a conflict.
+    crate::keymap::set_override(&mut app.ui.shortcut_overrides, "effect:distort.transform", "Cmd+Alt+Shift+F8");
+    let conflicts = crate::shortcut_editor::conflicts_with(&app.ui.shortcut_overrides, "Cmd+Alt+Shift+F8", &key_one);
+    assert_eq!(conflicts, vec!["effect:distort.transform".to_string()]);
+    crate::keymap::remove_override(&mut app.ui.shortcut_overrides, "effect:distort.transform");
+    frame(&mut app, f7());
+    let d = app.ui.dialog.take().expect("the filter's dialog opens");
+    assert_eq!((d.kind.as_str(), d.str("__plugin")), ("plugin", two.to_string()));
+    let bound = |app: &VectorcraftApp| {
+        crate::keymap::vc_chord(chord).and_then(|c| crate::keymap::lookup(&crate::keymap::keymap_with(&app.ui.shortcut_overrides), &c))
+    };
+    assert_eq!(bound(&app).map(|c| crate::keymap::entry_key(&c)), Some(key_two.clone()));
+    // Removed: no row, and no key is bound to the filter; the saved shortcut stays.
+    vectorcraft_plugins::registry::remove(two);
+    assert_eq!(bound(&app), None, "the key runs nothing");
+    assert!(crate::shortcut_editor::entry(&key_two).is_none());
+    assert_eq!(shown(&mut app), vec![(key_one.clone(), Value::Null)]);
+    assert!(crate::shortcuts::all_shortcuts().iter().all(|(_, _, p)| p["id"] != two), "no key is bound to the removed filter");
+    assert!(crate::keymap::has_override(&app.ui.shortcut_overrides, &key_two));
+    // Back under another name and without parameters: the saved shortcut runs it at once.
+    install(two, "Renamed", "{}");
+    assert_eq!(crate::shortcut_editor::entry(&key_two).map(|e| e.label), Some("Renamed".into()));
+    assert_eq!(shown(&mut app), vec![(key_one.clone(), Value::Null), (key_two.clone(), json!(chord))]);
+    let undo = app.session.doc().unwrap().history.undo.len();
+    frame(&mut app, f7());
+    assert!(app.ui.dialog.is_none(), "no dialog: {:?}", app.ui.dialog.as_ref().map(|d| &d.kind));
+    assert_eq!(app.session.doc().unwrap().history.undo.len(), undo + 1, "the filter ran as one undo step");
+    vectorcraft_plugins::registry::remove(one);
+    vectorcraft_plugins::registry::remove(two);
+    crate::shortcut_editor::sync(&crate::state::UiState::default());
+}
+
+/// A filter plug-in replaced under its id, or reinstalled from a folder by Reload Plug-ins, keeps
+/// its shortcut, which runs the plug-in as it is now. With no document open the key does nothing,
+/// as the dimmed menu item does.
+#[test]
+fn a_filter_plugin_keeps_its_shortcut_when_replaced_or_reloaded() {
+    use vectorcraft_plugins::wat as tpl;
+    let id = "test.UI.replaced_filter";
+    let key = format!("plugin:{id}");
+    let wasm = |name: &str, params: &str| {
+        let manifest = format!(r#"{{"id":"{id}","name":"{name}","version":"1","kind":"filter","params":{params}}}"#);
+        wat::parse_str(tpl::returning(&manifest, r#"{"objects":[]}"#)).unwrap()
+    };
+    let with_params = r#"{"wiggle":{"type":"bool"}}"#;
+    let chord = "Cmd+Alt+Shift+F6";
+    let f6 = || press(Key::F6, cmd() | Modifiers::ALT | Modifiers::SHIFT);
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    vectorcraft_plugins::registry::install_bytes(&wasm("Original", "{}")).unwrap();
+    crate::shortcut_editor::run_command(&mut app, "shortcuts.set", &json!({"id": key, "shortcut": chord})).unwrap().unwrap();
+
+    vectorcraft_plugins::registry::install_bytes(&wasm("Replaced", with_params)).unwrap();
+    assert_eq!(crate::shortcut_editor::entry(&key).map(|e| e.label), Some("Replaced…".into()));
+    assert_eq!(crate::menus::item_shortcut("plugin.dialog", &json!({ "id": id })), Some(chord));
+    frame(&mut app, f6());
+    assert_eq!(app.ui.dialog.take().expect("the replaced filter has parameters").str("__plugin"), id);
+
+    let folder = std::env::temp_dir().join(format!("vectorcraft-ui-filter-shortcut-{}", std::process::id()));
+    std::fs::create_dir_all(&folder).unwrap();
+    std::fs::write(folder.join("filter.wasm"), wasm("Reloaded", with_params)).unwrap();
+    app.run("plugin.reload", json!({ "path": folder.display().to_string() })).unwrap();
+    std::fs::remove_dir_all(&folder).ok();
+    assert_eq!(crate::shortcut_editor::entry(&key).map(|e| e.label), Some("Reloaded…".into()));
+    assert_eq!(crate::menus::item_shortcut("plugin.dialog", &json!({ "id": id })), Some(chord));
+
+    let mut empty = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    empty.ui.shortcut_overrides = app.ui.shortcut_overrides.clone();
+    frame(&mut empty, f6());
+    assert!(empty.ui.dialog.is_none(), "no document: no dialog");
+    vectorcraft_plugins::registry::remove(id);
+    crate::shortcut_editor::sync(&crate::state::UiState::default());
+}
+
+/// The key of a heavy filter does what a click on its item does: one without parameters starts in
+/// the background, and one with parameters opens its dialog, which has no Preview.
+#[test]
+fn a_heavy_filter_plugin_runs_from_its_shortcut_as_from_its_menu_item() {
+    use vectorcraft_plugins::wat as tpl;
+    let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+    app.session.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+    let (at_once, asks) = ("test.UI.heavy_filter-at-once", "test.UI.heavy_filter-asks");
+    for (id, params, chord) in [(at_once, "{}", "Cmd+Alt+Shift+F7"), (asks, r#"{"wiggle":{"type":"bool"}}"#, "Cmd+Alt+Shift+F8")] {
+        let manifest = format!(r#"{{"id":"{id}","name":"Heavy {id}","version":"1","kind":"filter","budget":"heavy","params":{params}}}"#);
+        let wasm = wat::parse_str(tpl::spinning(&manifest, 1 << 40, r#"{"objects":[]}"#)).unwrap();
+        app.run("plugin.install", json!({"dataBase64": vectorcraft_format::base64_encode(&wasm), "allowHeavy": true})).unwrap();
+        crate::shortcut_editor::run_command(&mut app, "shortcuts.set", &json!({"id": format!("plugin:{id}"), "shortcut": chord})).unwrap().unwrap();
+    }
+
+    frame(&mut app, press(Key::F7, cmd() | Modifiers::ALT | Modifiers::SHIFT));
+    assert_eq!(app.plugin_runs.running.len(), 1, "started in the background");
+    assert_eq!(app.ui.status, format!("Running “Heavy {at_once}”…"));
+
+    frame(&mut app, press(Key::F8, cmd() | Modifiers::ALT | Modifiers::SHIFT));
+    let d = app.ui.dialog.take().expect("the heavy filter with parameters opens its dialog");
+    assert_eq!(d.str("__plugin"), asks);
+    assert!(d.fields.get("preview").is_none(), "no Preview");
+
+    assert_eq!(app.run("plugin.cancelRuns", json!({})).unwrap()["cancelled"], 1);
+    vectorcraft_plugins::registry::remove(at_once);
+    vectorcraft_plugins::registry::remove(asks);
+    crate::shortcut_editor::sync(&crate::state::UiState::default());
+}
+
+/// Keyboard Shortcuts translates a menu path one segment at a time and the label of a built-in
+/// item. A filter plug-in's name stays as the plug-in gives it, even when it reads like a command.
+#[test]
+fn a_filter_plugin_row_translates_its_path_and_not_its_name() {
+    let zh = crate::i18n::Lang::from_code("zh-hant").unwrap();
+    crate::i18n::set_current(zh);
+    let entry =
+        |key: &str| crate::shortcut_editor::Entry { key: key.into(), label: "Group".into(), group: "Object › Plug-ins".into(), is_tool: false };
+    let path = format!("{} › {}", crate::i18n::tr(zh, "Object"), crate::i18n::tr(zh, "Plug-ins"));
+    let (filter, command) = (crate::shortcut_editor::shown_name(&entry("plugin:a.b")), crate::shortcut_editor::shown_name(&entry("object.group")));
+    crate::i18n::set_current(crate::i18n::Lang::EN);
+    assert_ne!(path, "Object › Plug-ins");
+    assert_eq!(filter, format!("{path} › Group"));
+    assert_eq!(command, format!("{path} › {}", crate::i18n::tr(zh, "Group")));
+}
+
 /// #2898 review: Up and Down change the corner kind only while a corner widget is pressed. With
 /// none pressed, a plain Up still nudges the selected rectangle and leaves its corners alone; with
 /// one pressed, Up steps the kind and the rectangle stays where it is.
diff --git a/crates/ui-egui/src/tests/picks.rs b/crates/ui-egui/src/tests/picks.rs
index fdd0798a8..c1e3f822c 100644
--- a/crates/ui-egui/src/tests/picks.rs
+++ b/crates/ui-egui/src/tests/picks.rs
@@ -417,6 +417,7 @@ fn keyboard_shortcuts_export_text_writes_the_working_set_as_text() {
         Ok(())
     }));
     let ov = crate::keymap::overrides_from(&[("view.grid", "Ctrl+Alt+G")]);
+    let revision = crate::menus::plugin_revision();
     app.run("edit.keyboardShortcuts", json!({})).unwrap();
     let d = app.ui.dialog.as_mut().expect("Keyboard Shortcuts");
     d.fields.insert("overrides".into(), crate::keymap::stored::to_value(&ov));
@@ -431,7 +432,11 @@ fn keyboard_shortcuts_export_text_writes_the_working_set_as_text() {
     let texts = texts.borrow();
     let [(path, text)] = texts.as_slice() else { panic!("{texts:?}") };
     assert_eq!(path, "/keys/list.txt");
-    assert_eq!(*text, crate::shortcut_editor::export_text("Custom", &ov));
+    // Another test installing or removing a plug-in meanwhile changes the Effect menu's rows.
+    if crate::menus::plugin_revision() == revision {
+        assert_eq!(*text, crate::shortcut_editor::export_text("Custom", &ov));
+    }
+    assert!(text.starts_with("Keyboard Shortcuts\nSet: Custom\n"), "{text}");
     assert!(text.contains(&format!("\t{}\n", crate::menus::pretty_shortcut("Ctrl+Alt+G"))), "{text}");
     assert!(app.ui.shortcut_overrides.is_empty(), "the working set is kept only on OK");
     assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some("shortcuts"), "the dialog stays open");
diff --git a/crates/ui-egui/src/tests/plugins.rs b/crates/ui-egui/src/tests/plugins.rs
index 59da85c22..16db57365 100644
--- a/crates/ui-egui/src/tests/plugins.rs
+++ b/crates/ui-egui/src/tests/plugins.rs
@@ -130,8 +130,9 @@ fn asking(id: &str, name: &str, permissions: &str) -> Vec<u8> {
 
 /// Installing a plug-in that lists permissions asks first, showing its name, id, version, file hash
 /// and each permission in plain words, with hidden characters from the manifest escaped. Cancel
-/// installs nothing, OK installs it; installing the same module again doesn't ask, and one with
-/// other bytes does, even when it lists the same permissions, as does one that asks for another.
+/// installs nothing, OK installs it; installing the same module again doesn't ask, one with other
+/// bytes asks again, even when it lists the same permissions, and then whether to take the
+/// installed one's place, as does one that asks for another permission.
 #[test]
 fn installing_a_plugin_that_lists_permissions_asks_first() {
     let mut app = app();
@@ -168,15 +169,35 @@ fn installing_a_plugin_that_lists_permissions_asks_first() {
     // The same module again: installed without asking.
     app.run("ui.installPlugin", json!({"dataBase64": data})).unwrap();
     assert!(app.ui.dialog.is_none(), "the same bytes don't ask again");
-    // Other bytes with the same permissions ask, from both ways in; Cancel keeps the one installed.
+    // Other bytes with the same permissions ask for them, from both ways in; Cancel keeps the one
+    // installed.
     let again = asking(id, "Tidy 2", r#"["doc.write","doc.read"]"#);
     let r = app.run("ui.installPlugin", json!({"dataBase64": vectorcraft_format::base64_encode(&again)})).unwrap();
     assert_eq!(r["pending"], dialogs::confirm::KIND, "other bytes ask again");
+    assert_eq!(app.ui.dialog.as_ref().unwrap().str("message"), "Install “Tidy 2”, which asks for these permissions?");
     dialogs::cancel(&mut app);
     assert_eq!(vectorcraft_plugins::registry::get(id).map(|p| p.manifest().name.clone()), Some(name.into()), "Cancel keeps the one installed");
     io::open_bytes(&mut app, "tidy2.wasm", &again, None).unwrap();
     assert_eq!(app.ui.dialog.as_ref().map(|d| d.kind.as_str()), Some(dialogs::confirm::KIND), "File › Open asks too");
     dialogs::confirm(&mut app).unwrap();
+    // OK on the permissions goes on to ask before it takes the installed one's place, showing its
+    // id and file hash; Cancel there keeps the one installed and records no grant.
+    let d = app.ui.dialog.as_ref().unwrap();
+    assert_eq!(d.str("message"), "Install “Tidy 2” in place of the plug-in with the same ID?");
+    let again_hash = vectorcraft_plugins::permissions::sha256_hex(&again);
+    assert_eq!(
+        d.str("detail"),
+        format!(
+            "ID: {id}\nFile SHA-256: {again_hash}\n\nThis file is not the plug-in installed before with this ID. It gets the settings and cache kept for that ID."
+        )
+    );
+    dialogs::cancel(&mut app);
+    assert_eq!(vectorcraft_plugins::registry::get(id).map(|p| p.manifest().name.clone()), Some(name.into()), "Cancel keeps the one installed");
+    assert_ne!(vectorcraft_plugins::registry::granted(id).map(|g| g.hash), Some(again_hash), "Cancel records no grant");
+    app.run("ui.installPlugin", json!({"dataBase64": vectorcraft_format::base64_encode(&again)})).unwrap();
+    dialogs::confirm(&mut app).unwrap();
+    dialogs::confirm(&mut app).unwrap();
+    assert!(app.ui.dialog.is_none(), "both questions are answered");
     assert_eq!(vectorcraft_plugins::registry::get(id).map(|p| p.manifest().name.clone()), Some("Tidy 2".into()));
     let new_hash = vectorcraft_plugins::permissions::sha256_hex(&again);
     assert_eq!(vectorcraft_plugins::registry::granted(id).map(|g| g.hash), Some(new_hash), "OK records the new module's hash");
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index fcd8da020..8cdb6d325 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -219,7 +219,8 @@ private editing data. VectorCraft:
 
 ### Illustrator's private editing data
 
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). In a PDF saved with some of its artboards, the type on each page after the first goes to an artboard of that page's size after the previous page's artboard, and only to one that leaves an artboard for each later page; the first page's artboard also leaves one for each later page. When several artboards fit a later page, VectorCraft takes the one whose art draws most like the page, and compares at most 16 artboards for all the later pages together. Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; a filled clipping path keeps its fill, which paints under the art it clips, except the path of a mask that covers several layers, whose fill is read as a path of its own in the layer that holds the mask's path, and a compound clipping path whose subpaths paint differently, whose filled subpaths are read as a compound path of their own under the art it clips; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
@@ -231,9 +232,9 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do; a spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do; a spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, placed PDF and `.ai` pages as placed documents of the [page and Crop to box](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-other-file-types/adobe-pdf-placement-options.html) their dictionary names (`AI11 PlacedPDFPageIndex`, `AI11 PlacedPDFCropTo`; a value VectorCraft doesn't read, or a binding to an image variable, leaves a linked image), guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing) or Pucker & Bloat at 0 comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its settings at their defaults) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
@@ -248,9 +249,9 @@ the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPri
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do. The swatches take at most 20,000 color names in all across the brush art, and each brush-art section keeps at most 20,000 names. Each name keeps its first definition, with the color operators' names before the gradient stops' names. A spot color past those limits makes no swatch, and its color still counts toward the color mode. A spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do; a spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. When the file opens from its layers, the spot colors in the art of each brush that comes in become swatches, and that art's colors count toward the document's color mode, as a pattern's do; a spot color that the page's art, a pattern or a symbol also defines keeps the value defined there. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
-the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path comes from VectorCraft's font metrics, and on Arial at 24 pt it differs from the distance the file keeps by 1.1 pt (Ascender), 0.3 pt (Center) and 2.7 pt (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip (a frame whose options set key 6 to true keeps their defaults), and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
+the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the distance from the path under Align to Path is measured for each character at its size and vertical scale (in vertical type, its horizontal scale), from the top of its font's em box (Ascender), half the height of the top of its font's H (Center) or the bottom of its font's bounding box (Descender); the fit under Gravity does not reproduce the file's layout, and its glyphs can lie up to 7.4 pt from the positions the file keeps; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; type on a path keeps its frame's Type on a Path effect, Align to Path and Flip, and the first frame's Spacing is fitted from the file's layout, not read from the dialog's value; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic one, or a Calligraphic brush with settings of its own or an angle that follows the path comes in as its drawn look (a group named after it). Objects in a symbol defined before the file's art styles section, as newer files write it, take the same styles as the layers' objects. A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372). A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack, so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
 the app's own editing copy of a file (an EPS after its `%%EOF`, a `.ai`'s `AIPrivateData` streams, a PDF's `AIPDFPrivateData` streams when it was saved with the editing data (#868), Zstandard or zlib, the EPS's in ASCII85) is not documented as a whole. VectorCraft reads its structure: layers and sublayers (names, order, visibility, lock, printing, preview, dimming, colour), groups as they were nested, compound paths (painted by their last path, or the last painted one, with the paths of groups inside them kept as their paths: #1410), clipping groups and layer clipping (several clipping paths in a clipping group, a layer or an opacity mask's art clip to their intersection, and a compound path of clipping paths stays one clip; clipping paths that would nest the art past the document's 32 levels stop the editing data from being read: #5789), object names, hidden and locked objects, fills and strokes (grey, CMYK, RGB, named and spot colours, spot colours defined in Lab with their Lab values (#1032), global process colours as global swatches at their tint; a stroke of width 0, `0 w`, on a path, a gradient-filled path, legacy type or in an art style comes in as a 0.25 pt hairline, as from PDF: #1671), linear and radial gradients, pattern fills with their patterns as pattern swatches (#1025), gradient and pattern names in the file up to their first newline (a name that another swatch, or a gradient or pattern defined earlier, already has is numbered "Sky 2"; a name without a newline is kept, and when another swatch has it, the pattern's swatch, or a named color sharing a gradient or pattern swatch's name, is numbered the same way), opacity, blend modes, isolation and knockout, embedded images where their matrix puts them, rotated ones too (#2269), with their alpha channel (CMYK images keep their ink amounts, as they do when a `.ai` opens from its PDF part, and an alpha channel that hides part of a CMYK image becomes a grayscale opacity mask), placed (linked) files as linked images in their place, each showing the low-resolution preview the file keeps of it until its file is found or relinked in the Links panel (#1264), with the folder the file keeps relative to the document's, where the link is looked for when its path is gone, guides, and every artboard where it is, with its center mark, cross hairs, video safe areas and video ruler pixel aspect ratio. VectorCraft reads `CropAreaActive`, an `/Int` in the dictionary that holds the artboard array, as the index of the active artboard in that array, and the file opens with that artboard active; without it, or when it names no artboard that opens, the first artboard is active. It also reads the Document Raster Effects Settings (resolution, color model, background, anti-alias, clipping mask, Add Around Object and Preserve Spot Colors), the author from the header's `%%For` (an EPS's own header when the editing data's has none), swatches for the header's `%%CMYKCustomColor` and `%%RGBCustomColor` colors that the document has none of, and `%%TemplateBox` in older files; a setting with a value of another type or out of range keeps its default. Objects on Path groups open live, with their path, their objects in order along it, Pivot and Rotate; one with a dragged spacing or other options opens as a plain group. A gradient with stops in the middle runs its whole ramp across its shape, and a gradient object does not pass its fill to the next path (#1390). An object whose art style is one fill and one stroke at most (solid colours, its own gradient, a variable-width profile) with Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Offset Path, Outline Object, Outline Stroke, Convert to Shape, Tweak (only when it moves nothing), Pucker & Bloat at 0 or Bas Relief (read from its settings block: [raster effects reference](https://helpx.adobe.com/illustrator/desktop/special-effects-styles/apply-filter-effects/raster-effects-reference.html), [Photoshop File Formats Specification](https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/), [scripting the filter gallery](https://community.adobe.com/questions-712/scripting-support-for-the-filter-gallery-1064646)) comes in as itself with them and their saved settings. A path, compound path or group (not a clipping group) whose only effect is Transform (not with copies or Random) or a Free Distort whose corners make a parallelogram comes in as itself with it too, when neither it nor anything in it paints with a gradient or pattern and everything in it is a path, compound path or group with no opacity mask and no effects of its own; Transform that scales, rotates or reflects needs nothing in it to be stroked. Twist as the only effect is read the same way on an unstroked path or compound path whose segments are all straight. One with more, other effects (Zig Zag, a Pucker & Bloat of another amount, a Free Distort with other corners), an effect setting that is not read (an unknown key, a missing or out-of-range value, a Scribble with a color of its own), dashes aligned to corners, a brush other than a Calligraphic or Art one, a Calligraphic brush with settings of its own or an angle that follows the path, or an Art brush other than the ones described next comes in as its drawn look (a group named after it). A path with a Calligraphic brush otherwise comes in as the path, the brush on its stroke at the stroke's weight, which scales the brush (#372), and so does a path with an Art brush, whose weight scales the art across the path, when all of these hold: the brush stretches its art along the path, unflipped, at 100% in Tints; the path's settings are the brush's own, with no entry that isn't read, no variable width and no effects; its stroke isn't a swatch; and the art is paths, compound paths and groups in solid fills, with no strokes, masks or effects, and has some length along the path. A stroke takes the brush the Brushes panel keeps under its name, and one whose name the panel doesn't keep comes in as its drawn look. Type with an Art brush keeps its drawn look under the type. A Calligraphic brush's Pressure, Tilt, Bearing and Rotation come in as those channels (a 6D Art Pen's brushes vary with the pressure, the bearing and the barrel's rotation); its Stylus Wheel varies at random. The file's Calligraphic, Scatter, Art and Bristle brushes replace the default ones in the Brushes panel, in the file's order, also when the file comes in as its PDF part (a brush library has no layers); pattern brushes and brushes it can't read are left out with a note. Type keeps its art style as a live appearance whatever its stack (an Art brush aside), so it can be retyped: each fill and stroke of the style's stack (solid colours, gradients and pattern fills, placed as the drawn look places them) with its own opacity, blend mode and effects, the effects on the whole object, and where the characters paint among them; the effects read are Warp, Offset Path, Outline Object, Outline Stroke, Transform (with copies, Transform Objects, Transform Patterns and Scale Strokes & Effects; not with Random), Free Distort, Pucker & Bloat, Twist, Zig Zag, Tweak (only when it moves nothing, the file holding none of its random outline), Drop Shadow, Inner Glow, Outer Glow, Feather, Round Corners, Scribble, Gaussian Blur, Bas Relief (its detail, smoothness and light direction from its settings block, or the effect's defaults when the style holds no settings block; a settings block that isn't read keeps the drawn look) and Convert to Shape, and a style with others, or with an effect setting that isn't read, keeps the type's drawn look. Convert to Shape keeps its Rectangle, Rounded Rectangle or Ellipse, its Absolute or Relative size (a relative size in the file is added to each side) and its corner radius; a relative Ellipse, or a setting that isn't read, keeps the drawn look. The page's drawing of such a style isn't held to look like VectorCraft's where its drawn look lay. Gradients take their matrix (`Xm`, radials and skewed ones too), focal point and the order of stops sharing a ramp point; gradient meshes, a clipping path's own fill and its stroke, and the artboards' names are read too. `editingData: "always"` (`convert --editing-data`) opens a `.ai` or an Illustrator EPS from its editing data even where it draws differently from its page, which can be older, with a note. Type is made from the file's text document, whole and editable, shown or not: point type (its frame's matrix, which newer files leave out when it is neither turned nor scaled, read as none), area type (a story in several frames as threaded type) and type on a path, with its characters, fonts, size, leading, tracking, scaling, baseline shift, fill and stroke (grey, RGB or CMYK), alignment, indents and paragraph spacing (a character attribute a run doesn't set comes from its character style, then the style that one is based on, then the document's defaults); area type keeps its frame's Area Type Options rows and columns, the gutter between rows and the gutter between columns, and its first baseline (Fixed, Cap Height, Leading or x Height) with its minimum; the page's drawing of it (often in pieces) is left out. Vertical type keeps its orientation, its columns from right to left, and a run set to Tate-chu-yoko keeps that setting. When it makes the type of every text object that shows, the page's type is only compared with it, each text object keeps its own group, frame and layer, and a line break inside a paragraph stays one. Where it can't make a text object's type (a frame of another kind), that text object takes the page's type where the text document puts its lines, or else what is left of the page's type in painting order (no group around it); the page's type where made type draws stays that type's, and hidden type is left out with a note. Text wrap is read too: an object whose dictionary has the wrap options (offset and Invert Wrap), or any graphic of a legacy wraparound group (`*w` … `*W`, before or after its type, with no offset), is a wrap object, and area type below it in its layer flows around it when the file opens, threaded type included (#2763). Kerning, underline and the other character and paragraph options aren't read yet. A `.ai` saved without PDF compatibility (a placeholder page) opens from its editing data alone, its point type, area type and type on a path made from the text document. A `.ai` whose PDF part shows only text isn't taken for that placeholder when its page states an art, trim or bleed box: it opens from its editing data alone where that reads, else from its PDF part (#1387). A `.ai` whose PDF part draws nothing at all (an empty page, with or without those boxes) opens from its editing data alone where that reads too: there is no page art to check its layers against, and the empty page would lose all of it. Text objects with an appearance keep their own text and frame, type of hidden layers stays hidden, and type on later artboards lands on its text objects (#1391); area type whose frame is too short for a line of the fallback font shows its first line (the frame is made taller, with a warning in the open result) (#1392). Symbols are read into the Symbols panel, in the file's symbol list order, with their art, their registration point and the instances in their art, and their instances come in live with their matrix, name, hide, lock, opacity, blending mode, isolation, knockout and opacity mask; a symbol whose art isn't read whole (type, placed files, an image it leaves out or anything else it doesn't read) isn't kept. Symbols are read only with the layers: a file that comes in as its page or PDF part (editing data with no layers, layers that can't be read, or any of the cases below) opens with an empty Symbols panel. Instances of symbols it can't read, instances with appearance changes of their own (a dynamic symbol's), pattern fills whose pattern it can't read, placed files the data keeps no preview of and anything else it doesn't read make the file come in as its page (on a layer that doesn't show, they are left out of that layer), with a warning saying what. An unread object on a shown layer whose box can be found instead comes in as a group of the page's objects inside that box, named after it, with the rest of the layers and groups kept and a warning listing what came in as the page's art; the file still comes in as its page when live art or another unread object shares that page art, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry its transparency (#4806). The layers' art is also compared with the page (by lightness, so colours written as their CMYK equivalents compare alike, and by whether a pixel is inked at all); the page is used when they differ by more than 5% (away from type, when all the type is made from the text document), where one draws an object the other doesn't (away from type, whose lines may be laid out afresh), and when an EPS whose page is its art's box has art printed outside it (#735). A `.ai` is not compared with its page, and its PDF part is not imported, when its text document makes the type of every text object (at least one shows, and none is drawn by the appearance of the layer or group it is in), no object is unread, no placed file has a second placement, no live envelope keeps its drawn art, it declares no large canvas, and its artboards are its pages' trim boxes one for one, in points or in the first page's `UserUnit`: it opens from its layers, with the bleed of its pages' bleed boxes. When they differ because some objects draw differently (an object in another color, or one that only one of them draws), each top-level object of the layers that holds such a difference comes in as a group of the page's objects inside its box and the layers stay, with a warning that names the layer or sublayer of each such object as the Layers panel shows it (`<Layer>` for one without a name) and how many came in from it; an export or Save As to the file's own path then needs `acknowledgeLoss: true`, and a wrap object replaced this way keeps its wrap options. The file still comes in as its page when only edges or type differ, when a difference lies outside every top-level object, when more than half of the top-level objects or more than 64 hold one, when such an object is or holds type or holds a wrap object inside a group, when the page's type of a text object that stays lies inside such an object's box, when the page's art can't replace such an object for one of the reasons above for an unread object, when matching the differences to the objects would take too much work, or when the result still differs from the page. `editingData: "always"` keeps the objects as read, and placed files at the other point their data gives are tried as well. An EPS whose page is its art's box keeps that page when it comes in through its layers, not the editing data's artboard, and a text object counts as drawn by the page by its colours, not only its lightness, so a red stroke stacked over a dark red one stays (#1102). `textAs: "outlines"` opens a `.ai` whose type shows from its PDF part, which has the outlines; `editingData: false` opens any of them as its page or PDF part only, for print pipelines (#735). A file whose import left something out (hidden text, art or layers) is never written over by an export or Save As to its own path unless `acknowledgeLoss: true` (`convert --replace-lossy`), so the original keeps what the document lacks. Where a `.ai` can't be read that way (or its layers are turned off in the import options), we read its PDF-compatible part, so Illustrator-only live objects arrive as appearance, and plain groups arrive ungrouped: that part draws each object on its own and marks only layers, clipping groups and groups with opacity, blending or a mask (those come back). Art outside the artboards isn't in that part at all (Illustrator's PDF part leaves it out), so it doesn't open; the import says so in a note (#472). Its pages still go where the editing data puts the artboards (a grid stays a grid), with the art on each, when it has as many artboards as pages, of the same sizes (#1068); the page of the artboard `CropAreaActive` names is then the active artboard. A `.ai` whose editing data has artboards but no layers also opens on that page under the same check, and its pages stay where they are. A `.ai` whose PDF part's pages are cropped to its art (each page the box of all the art, which is the editing data's bounding box) instead of its artboards opens from its layers, with its own artboards, where they draw as that page does. Its pages are laid out so that art one of them draws past its artboard (notes beside a design, which the part doesn't clip) doesn't lie over the page before it in the row, where it was taken for that page's art: the check against the editing data then found art its layers don't have there and opened the file as its PDF part, without the art outside the artboards. That part also has no paragraphs: area type is written line by line, and comes back as area type only where its font is installed and lays the lines out with the same breaks, else as a point type object per line (#508). Art off the page that a PDF does draw opens on the pasteboard.
diff --git a/docs/gaps.md b/docs/gaps.md
index 40626920f..210f14b80 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -187,7 +187,7 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall
 
 ## G9 Illustrator `.ai` and EPS files from real users
 
-- **Done (2026-10-30):** from an audit of a user's `.ai`/EPS files: All Caps and Small Caps; placed files at their box's corner; pages cropped to the art; gradient mesh corners with handle weights of 0 and the transparency written after a mesh, a masked mesh and a blend; a layer's state block with the stroke style; type on a path spaced as the file lays it out (the distance from the path under Align to Path comes from VectorCraft's font metrics, and the fit under Gravity does not reproduce the file's layout); EPS10 legacy-format type; a PDF of some artboards compared on the artboard its page shows. Comparison limits remain unchanged. This narrows G9; scores and estimates unchanged.
+- **Done (2026-10-30):** from an audit of a user's `.ai`/EPS files: All Caps and Small Caps; placed files at their box's corner; pages cropped to the art; gradient mesh corners with handle weights of 0 and the transparency written after a mesh, a masked mesh and a blend; a layer's state block with the stroke style; type on a path spaced as the file lays it out (the distance from the path under Align to Path is measured from the top of each character's em box, half the height of the top of its H or the bottom of its font's bounding box, and the fit under Gravity does not reproduce the file's layout); EPS10 legacy-format type; a PDF of some artboards compared on the artboard its page shows. Comparison limits remain unchanged. This narrows G9; scores and estimates unchanged.
 
 - **Save-back update (2026-10-26):** ordinary EPS Save retains page margins and the whole editable document; source-loss confirmation remains. Import fidelity gaps and estimates below are unchanged.
 
diff --git a/docs/mcp.md b/docs/mcp.md
index eb803de3e..cbd8306c8 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -403,7 +403,10 @@ counterparts, `image.info`, `links.info`, `links.goTo`, `links.unembed`, `shaper
 `transparency.editOpacityMask`, `transparency.viewOpacityMask`, `symbol.edit`, the `object.blend.spine.*` commands
 and `path.curvature`) refuse an `id` that is not a non-negative integer (`"abc"`, `"5"`, `true`) with an error and
 change nothing; an omitted or null `id` keeps the default. A command that leaves out an object selected inside a
-selected group also leaves it out when `ids` list it together with a group that holds it.
+selected group also leaves it out when `ids` list it together with a group that holds it. Every command that takes
+`ids` (or `slices`, for the slice commands) refuses a list with an entry that is not a non-negative integer, or a value
+that is not a list, and changes nothing; it does not act on the other entries. The error for an entry names the key,
+the entry's index (from 0) and its value: "`ids` entry 1 is true, not a non-negative integer object id".
 
 Paint values (`fill`, `stroke`) accept `"#rrggbb"`, `"none"`, `[r,g,b]` (0..1), `{"c","m","y","k"}`, `{"gray"}`,
 or a full `paint.setFill` params object (`{"gradient": …}`, `{"swatch": "name"}`).
@@ -693,8 +696,8 @@ effect colors that new art takes; Undo restores their original values and Redo r
 colors of 3D effects stay RGB.
 Gray colors stay Gray and print
 on the black plate only. RGB grays are colors like any
-other: to CMYK they separate through the profile into four-colour greys and a rich black, as Illustrator converts
-them. `grays: "black"` puts RGB greys with R = G = B on the black plate instead, K = their grey value (the inks Edit Colors ›
+other: to CMYK they separate through the profile into light grays in cyan, magenta and yellow only, darker
+four-color grays and a rich black. `grays: "black"` puts RGB greys with R = G = B on the black plate instead, K = their grey value (the inks Edit Colors ›
 Convert to Grayscale before the switch would give); other colors convert as usual. The reply's `changed` counts the
 colors that changed in the art, symbols, graph designs and pattern tiles; it does not count the colors of graphic
 styles and brushes.
@@ -3653,6 +3656,13 @@ They list such a command while the user has changed its shortcut (`overridden: t
 shortcut for that command runs what a click on the item runs: Object › Path › Clean Up…, Print Ink Fixes… and Edit ›
 Find and Replace… open their dialogs.
 
+Each installed filter plug-in's Object › Plug-ins item is its own row, with id `plugin:<id>` (the plug-in's id), its
+menu label and no default shortcut, so two filters with the same name have two rows. `shortcuts.set {id:
+"plugin:<id>", shortcut}`, `shortcuts.list` and Import Shortcut Set use that id, `shortcuts.exportText` writes one line
+for the row under its menu path and label, and the key runs what a click on the item runs, `plugin.dialog {id}`. A
+removed plug-in's row goes away and its key runs nothing; its shortcut stays saved and applies again when a plug-in
+with the same id is installed.
+
 `shortcuts.exportText {path?}` saves the current set's shortcut list as a UTF-8 text file, as Edit › Keyboard
 Shortcuts › Export Text… does with the dialog's set as edited so far. The file starts with a "Keyboard Shortcuts" line
 and a "Set:" line with the set's name, followed by a Tools section and a Menu Commands section. Each section lists the
@@ -4592,6 +4602,14 @@ its file was found. Only files on this computer, or on the network share the doc
 on, are looked at: a path to another computer, a device or a URL counts as missing. On Windows, a document opened from
 a mapped drive (`Z:\…`) is on the share the drive is mapped to, and links on that share (`\\server\share\…`) are
 looked at. A link on a drive mapped to another share (`Y:\…`) counts as missing, from a document on this computer too.
+The links of an open document keep their relative paths from the file it was opened from (for a `.ai` file another
+app wrote, that file), also after a save to another folder. When a link's file is not at its path, a save and Package
+write the path relative to the new file of the place the file is found, or for a missing file of the place that
+relative path names, and a document made with New Document from State keeps the same places, so a document moved while
+its linked files were missing finds them once they are back in that folder. In the open document, a link
+is looked for at its path, then at its relative path from the folder of the file the document was opened from and from
+the document's own folder, then by name in those two folders. A link found away from its path takes the relative path
+of the place it was found.
 The result lists `missingLinks`
 (their images show the preview), `modifiedLinks` (left as they were; read again only with the preference
 `updateLinks: "automatically"`, then they are in `updatedLinks`), each as `{name, path, ids}`, with `refused` (why the
@@ -4937,7 +4955,8 @@ The Slice tool (`slice`, Shift+K) and the Slice Selection tool (`sliceSelection`
 `object.slice.create {x, y, width, height}` (the Slice tool's drag; it snaps to ruler guides), `object.slice.select
 {slices?, toggle?}`, `object.slice.move {slices?, dx, dy}` (an object slice moves its object),
 `object.slice.setRect {id, x, y, width, height}` (user slices) and `object.slice.delete {slices?}`. Slice ids are user
-slice ids and the ids of objects with an object slice.
+slice ids and the ids of objects with an object slice. `object.slice.select` with `slices` left out or null deselects
+the slices.
 
 ```json
 {"name":"run_command","arguments":{"command":"object.slice.create","params":{"x":0,"y":0,"width":200,"height":80}}}
@@ -5821,6 +5840,53 @@ dialog open.
 {"name":"run_command","arguments":{"command":"text.setRangeStyle","params":{"id":12,"start":0,"end":4,"tateChuYoko":true,"tcyUpDown":2,"tcyLeftRight":-1}}}
 ```
 
+## Composite Fonts
+
+A composite font sets each class of character in a font of its own
+([Creating composite fonts](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347)).
+`type.compositeFonts.set {fonts: [{name, parts}]}` replaces the active document's composite fonts as one undo step,
+and adds no step when nothing changes. `parts` holds `kanji` (the base font), `kana`, `punctuation`, `symbols`, `roman`
+and `numerals`, each `{font, style?, size?, baseline?, hScale?, vScale?, scaleAtCenter?}`; a part left out copies the
+`kanji` part. Which characters fall in each class is VectorCraft's own rule: Kanji takes ideographs, full-width
+letters and digits and every character no other class takes; Kana takes hiragana and katakana of both widths;
+Punctuation takes East Asian and full-width punctuation, quotes and dashes; Symbols takes arrows, math, shapes and
+other symbols; Roman takes half-width letters, their punctuation and spaces; Numerals takes the digits 0 to 9.
+
+`size` (10 to 400, 100 by default) and `baseline` (-100 to 100, 0 by default; positive raises) are percentages of the
+type's size, VectorCraft's own ranges. `hScale` and `vScale` (10 to 400, 100 by default) scale Kana, Roman and
+Numerals only, and `scaleAtCenter` (Kana only) scales kana from the center of the em box instead of the baseline. A
+value out of range, a scale on another class, an unknown class or key, a name that is empty, longer than 255
+characters, shared by two fonts (in any case) or the name of an installed font, and a part set in a composite font are
+each refused with an error, and nothing changes. A document keeps at most 256.
+
+Type set in a composite font names it as its family (`text.setStyle {font: "My Composite"}`), and the font menus list
+composite fonts first. The layout sets each character in its class's font, a letter and its combining marks together.
+A composite font taken out of the document leaves its type naming it, and the type shows as missing. Composite fonts
+are saved with the document. SVG and legacy `.ai` write type in one of the document's composite fonts as outlines, and
+SVG, PDF, EPS and legacy `.ai` export draw it in the font's parts also when the document was read without an open app.
+`type.compositeFonts.list` returns the document's composite fonts.
+
+`text.replaceFont` and `addon.cleanup.replaceFonts` with a composite font as the new font set the type in it by its own
+name, and the type keeps its style. `text.fonts` lists a composite font by its name; its `status` is the worst among the
+parts its characters are drawn in, and `missingGlyphs` counts the characters that their part's font lacks.
+`text.missingFonts`, File › Package and the warnings about fonts that aren't available name the part fonts that the
+characters are drawn in. `text.glyphAlternates` lists the alternates of a character from its part's font.
+
+`type.compositeFonts.export {path?, names?, fonts?}` writes the document's composite fonts (all, or those `names`
+lists), or the `fonts` given, to a `.vccomposite` file; without `path` it returns the file's text as `data`.
+`type.compositeFonts.import {path | data | dataBase64, apply?}` reads a file of at most 4 MB. With `apply` (the
+default) its fonts join the document's, replacing a font of the same name, as one undo step; with `apply: false` it
+only returns them. Opening a `.vccomposite` file imports it.
+
+Type › Composite Fonts… (shown with Show East Asian Options) opens the Composite Fonts dialog on the document's fonts:
+Font picks one, and a table sets each class's font, style, size, baseline and scales. New adds a font based on the one
+picked, Delete Font takes it out, Import… adds the fonts of a file and Export… writes the one picked. OK runs
+`type.compositeFonts.set` with every font as one undo step; a refused font keeps the dialog open.
+
+```json
+{"name":"run_command","arguments":{"command":"type.compositeFonts.set","params":{"fonts":[{"name":"My Composite","parts":{"kanji":{"font":"Source Han Sans"},"roman":{"font":"Source Sans 3","size":95,"baseline":-2},"numerals":{"font":"Source Sans 3"}}}]}}}
+```
+
 ## Optical Margin Alignment
 
 `type.opticalMarginAlignment {on?: bool}` (Type › Optical Margin Alignment) turns Optical Margin Alignment on or off
@@ -6203,8 +6269,12 @@ Type on a path flows between a start and an end bracket, stored as fractions of
 Path Options: `end: null` puts the end bracket back at the end of the path (or once round a closed one); `flip`
 then turns the type to the other side of its path, the path running the other way and the brackets swapping ends so
 the type keeps its stretch of the path; `alignToPath` runs the `ascender`, `descender`, `center` or `baseline` (the
-default) along the path; `spacing` (points) closes glyphs up round the outside of curves and opens them up round the
-inside. With none of them it queries the first selected type on a path:
+default) along the path, each character by its own font, size and vertical scale: `ascender` runs the top of the
+font's em box along it (its ideographic em box, else an em box centered on the cap height), `descender` runs the
+bottom of the font's bounding box along it, and `center` runs a line at half the height of the top of the font's H
+above the baseline along it (in vertical type, `ascender` and `descender` move the characters half an em with their
+horizontal scale, and `center` leaves them on the path); `spacing` (points) closes glyphs up round the outside of
+curves and opens them up round the inside. With none of them it queries the first selected type on a path:
 `{start, end, flip: false, effect, alignToPath, spacing}`. The Options dialog shows Effect, Flip, Align to Path and
 Spacing and leaves the brackets where they are. As in the reference app, the Selection and Direct Selection tools
 show selected type on a path's brackets: dragging the start or end bracket (`pointer_gesture`) sets where the type
@@ -6371,8 +6441,18 @@ trusts the client that sends it. `plugin.remove` forgets the grant. A
 filter without `doc.write` or `state` that returns output needing them gets an error and the document is unchanged.
 A plug-in of API level 2 (`api: 2` in its entry) that lists `progress` may report its progress, see Cancel and write
 log lines: `notifications/cancelled` makes its `vc_cancelled` return 1, and its log lines go to the server's log
-under its id. A module that imports anything else, or imports these without `api` 2 and `progress`, is refused by
-`plugin.install` and `plugin.inspect` with an error naming the import.
+under its id. One that lists `settings` or `cache` keeps settings or a cache of its own in the `Plug-ins` folder
+(VectorCraft's own caps: 256 settings and 1 MiB, 512 MiB of cache): `plugin.list` and `plugin.info` give the cache's
+size as `cacheBytes`, `plugin.clearCache {id?}` empties the cache of one plug-in or of all of them and returns
+`{cleared: [id], bytesFreed}`, replacing a plug-in keeps both, and `plugin.remove` deletes both (also for an id that
+isn't installed but still has them). A module with other bytes than the plug-in installed with its id, or, with none
+installed, one whose id has settings or a cache in the
+`Plug-ins` folder (`needsReplace: true` in its `plugin.inspect` entry), installs only with `replace: true`: ask the
+user first, since it takes that plug-in's place and gets its settings and cache. Without it, `plugin.install` returns
+an error naming the plug-in. The same module installs again without `replace`, and `replace: false` refuses a module
+whose id is installed. A module that imports
+anything else, or imports one of these without `api` 2 and the import's permission, is refused by `plugin.install` and
+`plugin.inspect` with an error naming the import and the permission.
 `plugin.install` rejects a `replace` or `allowHeavy` value that is not a boolean, a `grant` that is not a list of
 permission names, and a `hash` that is not the module's SHA-256. `prefs.set` returns an error and
 changes nothing when a new `pluginsFolder` is missing, is not a folder or can't be listed. It does not check an empty
@@ -6413,6 +6493,8 @@ Disable and Continue can't save the plug-in it turns off, this launch skips it a
 {"name":"run_command","arguments":{"command":"plugin.install","params":{"path":"/plugins/desaturate.wasm"}}}
 {"name":"run_command","arguments":{"command":"plugin.run","params":{"id":"org.vectorcraft.example.desaturate","params":{"amount":60}}}}
 {"name":"run_command","arguments":{"command":"effect.apply","params":{"effect":"plugin.org.example.wobble","params":{"size":4}}}}
+{"name":"run_command","arguments":{"command":"plugin.install","params":{"path":"/plugins/tiles-2.wasm","replace":true}}}
+{"name":"run_command","arguments":{"command":"plugin.clearCache","params":{"id":"org.example.tiles"}}}
 ```
 
 ## Colour adjustments
diff --git a/docs/plugins.md b/docs/plugins.md
index 0dc8f88e4..31543bce0 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -23,12 +23,13 @@ This page is the contract for plug-in authors and the reference for the host (`c
 
 | Command | Params | What it does |
 |---|---|---|
-| `plugin.list` | `{}` | `{"plugins": [{id, name, version, kind, author, description, params, paramsSchema, effect?, format?, extensions?, budget?, size, source, api, permissions, hash}], "folder": report}` (`api` is the manifest's [plug-in API level](#permissions); `budget: "heavy"` for a [heavy filter](#heavy-filters); `permissions` lists what it [may do](#permissions), `hash` is the module's SHA-256) |
+| `plugin.list` | `{}` | `{"plugins": [{id, name, version, kind, author, description, params, paramsSchema, effect?, format?, extensions?, budget?, size, source, api, permissions, hash, cacheBytes}], "folder": report}` (`api` is the manifest's [plug-in API level](#permissions); `budget: "heavy"` for a [heavy filter](#heavy-filters); `permissions` lists what it [may do](#permissions), `hash` is the module's SHA-256; `cacheBytes` is the size of its [cache](#settings-and-cache)) |
 | `plugin.info` | `{"id"}` | One plug-in: the `plugin.list` entry plus `manifest`, `defaults` and `lastError` (a live effect's last failure). |
 | `plugin.run` | `{"id", "params"?: {…}, "ids"?: [...]}` (plug-in params may also be top-level keys) | Runs an object filter on the selection (or `ids`). One undo step; the result is selected, except the objects it locked or made guides. |
-| `plugin.install` | `{"path": "/x/y.wasm"}` (desktop) or `{"dataBase64": "…", "name"?}`, `"replace": bool = true`, `"allowHeavy": bool = false`, `"grant"?: [permission]`, `"hash"?: "sha256 hex"` | Validates and installs a module; returns its `plugin.list` entry. The desktop app and `vectorcraft-cli` keep it in the `Plug-ins` folder next to the preferences, so it is installed again after a restart (#2541). A [heavy filter](#heavy-filters) installs only with `allowHeavy: true`, once the user agreed. A plug-in whose manifest lists [permissions](#permissions) installs only when `grant` lists every one of them, once the user agreed, unless the user already granted a module with the same SHA-256. With `hash`, a module whose SHA-256 differs is refused. |
-| `plugin.inspect` | as `plugin.install`: `{"path"}` or `{"dataBase64", "name"?}` | Validates a module without installing it; returns the `plugin.list` entry it would have, plus `needsApproval` (true when `plugin.install` needs `grant`). |
-| `plugin.remove` | `{"id"}` | Uninstalls, and deletes it from the `Plug-ins` folder. |
+| `plugin.install` | `{"path": "/x/y.wasm"}` (desktop) or `{"dataBase64": "…", "name"?}`, `"replace"?: bool`, `"allowHeavy": bool = false`, `"grant"?: [permission]`, `"hash"?: "sha256 hex"` | Validates and installs a module; returns its `plugin.list` entry. The desktop app and `vectorcraft-cli` keep it in the `Plug-ins` folder next to the preferences, so it is installed again after a restart (#2541). A module with other bytes than the plug-in installed with its id, or, with none installed, one whose id has [settings and a cache](#settings-and-cache) in the `Plug-ins` folder, installs only with `replace: true`, once the user agreed; it takes that plug-in's place and gets its settings and cache. The same module installs again without `replace`, and `replace: false` refuses a module whose id is installed. A [heavy filter](#heavy-filters) installs only with `allowHeavy: true`, once the user agreed. A plug-in whose manifest lists [permissions](#permissions) installs only when `grant` lists every one of them, once the user agreed, unless the user already granted a module with the same SHA-256. With `hash`, a module whose SHA-256 differs is refused. |
+| `plugin.inspect` | as `plugin.install`: `{"path"}` or `{"dataBase64", "name"?}` | Validates a module without installing it; returns the `plugin.list` entry it would have, plus `needsApproval` (true when `plugin.install` needs `grant`) and `needsReplace` (true when `plugin.install` needs `replace: true`). |
+| `plugin.remove` | `{"id"}` | Uninstalls, and deletes it from the `Plug-ins` folder with its [settings and cache](#settings-and-cache). |
+| `plugin.clearCache` | `{"id"?}` | Deletes every entry in the [cache](#settings-and-cache) of plug-in `id`, or of every installed plug-in; settings stay. Returns `{"cleared": [id], "bytesFreed"}`. |
 | `plugin.reload` | `{"path"?: "folder"}` (default: the preference folder) | Installs every `*.wasm` in a folder; a bad module is reported and skipped, and so are a heavy filter and a plug-in whose permissions the user hasn't granted (nobody was asked). |
 
 Live effects are applied like any effect: `effect.apply {"effect": "plugin.<id>", "params": {…}}`, edited with
@@ -42,7 +43,9 @@ In the app, installed filters appear under **Object › Plug-ins**, next to **In
 Plug-ins**; live effects under **Effect › Plug-ins** and in the Appearance panel's effect menu. A plug-in with
 parameters gets a dialog generated from its schema (numbers, whole numbers, checkboxes, dropdowns, text, lists
 of numbers and colors, labelled, explained and sorted into sections as its manifest says) with a live preview; without
-parameters it runs at once. Parameters too many for the window's height scroll inside the dialog, which keeps its
+parameters it runs at once. Edit › Keyboard Shortcuts lists each installed filter under Object › Plug-ins, where
+it can be given a shortcut (`plugin:<id>`); the shortcut stays saved while the plug-in is removed and applies again
+when it is reinstalled. Parameters too many for the window's height scroll inside the dialog, which keeps its
 heading and buttons in view. Exporters are formats of **File › Export › Export As**, where Use
 Artboards is greyed out (the plug-in writes the whole document); one with parameters asks for them in a dialog of the
 same kind once the file is picked, and its Export button writes the file. **File › Open** of a `.wasm` file installs
@@ -67,7 +70,7 @@ The host is [`wasmi`](https://github.com/wasmi-labs/wasmi), a pure-Rust WebAssem
 
 | Limit | Default | On violation |
 |---|---|---|
-| Host imports | none at API level 1; at level 2 only the three [host imports](#host-imports-api-level-2): no WASI, file system, network, clock or randomness | module rejected at install, naming the import |
+| Host imports | none at API level 1; at level 2 only the [host imports](#host-imports-api-level-2): no WASI, file system, network, clock or randomness | module rejected at install, naming the import |
 | Module size | 32 MiB | rejected |
 | Linear memory | 512 MiB per instance (input and parameters: at most half) | `memory.grow` returns -1; oversized input or initial memory fails |
 | Output | 64 MiB of JSON | `Limit("output size")` |
@@ -116,14 +119,17 @@ capability model proposed for PhotoCraft plug-ins
 | `effect.render` | effect | Change how the objects its effect is applied to are drawn. |
 | `export.write` | exporter | Write the document as a file in its own format. |
 | `progress` | all | Show its progress, see Cancel and write log lines through the [host imports](#host-imports-api-level-2). Needs `api` 2. |
+| `settings` | all | Keep settings of its own between runs and sessions ([settings and cache](#settings-and-cache)). Needs `api` 2. |
+| `cache` | all | Keep a cache of its own, which the user can clear ([settings and cache](#settings-and-cache)). Needs `api` 2. |
 
 - A manifest without `permissions` gets the ones its kind implies, as plug-ins did before the key existed: a filter
   `doc.read`, `doc.write` and `state`; an effect `doc.read` and `effect.render`; an exporter `doc.read` and
   `export.write`. Such a plug-in installs without a prompt. This rule is VectorCraft's own. A filter whose list is
   empty may do none of these, and also installs without a prompt.
 - An effect or an exporter that lists permissions lists both of its implied ones. A filter may list any of its three.
-  Any kind may add `progress`, which no kind implies. An unknown name, a name listed twice, a name that doesn't apply
-  to the kind, more than 16 names, `progress` with an `api` below 2, or one of the names kept for a later plug-in API
+  Any kind may add `progress`, `settings` and `cache`, which no kind implies. An unknown name, a name listed twice, a
+  name that doesn't apply to the kind, more than 16 names, `progress`, `settings` or `cache` with an `api` below 2, or
+  one of the names kept for a later plug-in API
   (`ui.panel`, `ui.tool`) is refused when the module is installed, and the error names it.
 - **Installing asks first.** Install Plug-in… and File › Open show the plug-in's name, id, version, the SHA-256 of
   the file and each permission in plain words, and install it once the user clicks OK, if the file still has the
@@ -133,12 +139,20 @@ capability model proposed for PhotoCraft plug-ins
   passes once the user agreed (`plugin.inspect`'s `needsApproval` tells it beforehand), with `hash` set to the
   `plugin.inspect` entry's `hash` so that the module installed is the one the user saw. `plugin.install` does not
   check that a person approved `grant`: it trusts the client that sends it.
+- **Replacing asks first.** When the file is another module than the plug-in installed with its id, or, with none
+  installed, its id has settings and a cache in the `Plug-ins` folder, Install Plug-in… and File › Open show its id
+  and SHA-256 and ask whether to install it in place of that plug-in, which gives it the settings and cache kept for
+  the id. `plugin.install` refuses such a module, naming it, unless `replace` is `true`, which an agent passes once
+  the user agreed (`plugin.inspect`'s `needsReplace` tells it beforehand). The Additional Plug-ins Folder and
+  `plugin.reload` do not ask.
 - The grant is recorded with the plug-in's id, the module's hash and the permissions, in `grants.json` in the
   `Plug-ins` folder, and covers only that module. Installing the same bytes again needs no new approval. A module with
-  other bytes asks again, even when it lists the same permissions. Until it is approved, the installed module and its
-  grant stay as they are; once it is, the grant records the new hash. When the new module or its grant can't be
-  written to the `Plug-ins` folder, the folder keeps the old module and its grant, and the old module loads at the
-  next start. A grant whose hash is not 64 lower-case
+  other bytes asks again, even when it lists the same permissions, and does not get the id's settings and cache until
+  it is approved. Until then, the installed module and its grant stay as they are; once it is approved, the grant
+  records the new hash. When the new module or its grant can't be written to the `Plug-ins` folder, the folder keeps
+  the old module and its grant, and the old module loads at the next start. If the write that puts the old module back
+  fails as well, the folder holds the new module with the old grant, the grant does not cover that module, and the
+  plug-in is skipped at the next start until it is approved again. A grant whose hash is not 64 lower-case
   hexadecimal digits covers nothing. `plugin.remove` forgets the grant. An entry of `grants.json` that this version can't use (a
   permission it doesn't know, an invalid id) is skipped and stays in the file until its plug-in is granted again or
   removed. A `grants.json` that is not a JSON list is never overwritten, and the file is never written larger than
@@ -154,7 +168,8 @@ capability model proposed for PhotoCraft plug-ins
   imports](#host-imports-api-level-2). A higher one is refused. `plugin.list` and `plugin.info` give it as `api`.
 - Parameter declarations are unchanged by permissions (`params`, below).
 
-Every run gets a **fresh instance**, so no state survives between calls. Traps, exhausted budgets, malformed
+Every run gets a **fresh instance**, so no state survives between calls except what a plug-in writes to its
+[settings and cache](#settings-and-cache). Traps, exhausted budgets, malformed
 modules, bad manifests, out-of-range pointers, negative return codes and invalid output all become errors, and the
 document is left untouched: a filter's output is checked completely before one edit applies it. A live effect that
 fails draws the object's geometry unchanged; `plugin.info` reports why (`lastError`).
@@ -188,9 +203,10 @@ module's memory.
 
 ### Host imports (API level 2)
 
-A plug-in whose manifest gives `"api": 2` and lists the `progress` [permission](#permissions) may import these
+A plug-in whose manifest gives `"api": 2` and lists the [permission](#permissions) an import needs may import these
 functions from module `env` (the module a Rust or C toolchain gives `extern` functions by default). `vc_abi_version`
-still returns `1`.
+still returns `1`. `vc_progress`, `vc_cancelled` and `vc_log` need `progress`; the `vc_settings_*` imports need
+`settings` and the `vc_cache_*` imports need `cache` ([settings and cache](#settings-and-cache)).
 
 | Import | Signature | Meaning |
 |---|---|---|
@@ -199,8 +215,8 @@ still returns `1`.
 | `vc_log` | `(level, ptr, len) -> i32` | Writes the UTF-8 text at `ptr` as a log line of `level` (0 error, 1 warning, 2 information, 3 debug). Returns `0` when written, `1` when the run's log budget is spent and the line was dropped, `-1` when the text doesn't lie inside the module's memory, `-2` when it is not UTF-8, `-3` for another level. |
 
 - The host checks the imports when the module is installed: an import it doesn't offer, one with another signature,
-  and one the manifest doesn't allow (an `api` below 2, or no `progress` permission) refuse the module, and the error
-  names the import.
+  and one the manifest doesn't allow (an `api` below 2, or without the import's permission) refuse the module, and the
+  error names the import and the permission.
 - A filter's or an exporter's progress is shown as a share: a heavy filter's progress window and the export's progress
   window draw a bar with a percentage, and Cancel there makes `vc_cancelled` return `1`. A plug-in that checks it can
   stop early, and the host discards what it returns after the Cancel or after its time budget ran out; one that
@@ -214,6 +230,53 @@ still returns `1`.
   text, and the host reads at most 1 MiB of log text in a run; past any of these, one "log truncated" line is written
   and the rest are dropped.
 
+### Settings and cache
+
+A plug-in with the `settings` permission keeps named values between runs and sessions, and one with `cache` keeps
+named entries that the user can clear (#2191). It names each value by a key and never by a path. Each import takes
+the key as `(key, key_len)`, the UTF-8 bytes at `key` in its memory:
+
+| Import | Signature | Meaning |
+|---|---|---|
+| `vc_settings_get` | `(key, key_len, out, out_cap) -> i32` | The setting's length in bytes. When it fits in the `out_cap` bytes at `out`, its bytes are copied there; otherwise nothing is copied. |
+| `vc_settings_set` | `(key, key_len, value, value_len) -> i32` | Sets the setting to the `value_len` bytes at `value`. Returns `0`. |
+| `vc_settings_delete` | `(key, key_len) -> i32` | Removes the setting. Returns `0`. |
+| `vc_cache_read` | `(key, key_len, out, out_cap) -> i32` | As `vc_settings_get`, for the cache entry. |
+| `vc_cache_write` | `(key, key_len, value, value_len) -> i32` | As `vc_settings_set`, for the cache entry. |
+| `vc_cache_clear` | `(key, key_len) -> i32` | Removes the cache entry; with `key_len` 0, every entry. Returns `0`. |
+
+A call that fails returns `-1` when the key has no value, `-2` when a key, value or buffer doesn't lie inside the
+module's memory, `-3` when the key is not a valid key, `-4` when the write would pass a cap (nothing changes), `-5`
+when there is nowhere to keep anything, `-6` when reading or writing the file failed, and `-7` when the run has used
+its 10,000 storage calls or its 1 GiB of storage reads and writes. Each call counts the bytes it reads and writes: a
+settings call the whole settings file it reads, and a set or delete also the whole file it writes; a cache call the
+entry it reads or writes. A read counts them even when the value doesn't fit and nothing is copied. A call that would
+pass the 1 GiB returns `-7` before it reads or writes anything.
+
+- A key is 1 to 64 characters from `A-Z`, `a-z`, `0-9`, `_` and `-`, and is not a Windows device name (`CON`, `PRN`,
+  `AUX`, `NUL`, `COM0` to `COM9`, `LPT0` to `LPT9`, in any case). Keys differ in case: `tile` and `Tile` are two.
+- These caps are VectorCraft's own values: at most 256 settings of at most 64 KiB each, in a settings file of at most
+  1 MiB; cache entries of at most 64 MiB each, at most 4,096 entries and 512 MiB per plug-in. The cache has no
+  automatic eviction: a write past a cap fails with `-4`, and the plug-in or the user clears entries. A cache write
+  also fails with `-4` when the `cache` folder holds more than 8,192 items; clearing the cache removes every file in
+  it.
+- The desktop app and `vectorcraft-cli` keep them in a folder named from the id under `storage/` in the `Plug-ins`
+  folder (ids that differ only in case get two folders): `settings.json` and a
+  `cache` folder with one file per entry, named by the host. A settings file that is too large or doesn't parse is
+  moved to `settings.unreadable.json`, replacing an earlier one there, and the settings start empty. A link in that
+  folder is refused (`-5`). Writes go to a temporary file that then replaces the old one; a temporary file a failed
+  write leaves in the `cache` folder does not count toward the caps, and clearing the cache removes it.
+- A plug-in reaches only the storage of its own id. Replacing it with another module of the same id
+  (`plugin.install` with `replace: true`, after the user agreed) keeps the storage; `plugin.remove` deletes it, and a run of the plug-in still going gets `-5` from every storage call after that.
+  `plugin.remove` first renames the folder (adding `.removed` to its name). When that fails, `plugin.remove` fails
+  and the plug-in stays installed with its storage as it was. Files that can't be deleted after the rename stay in the
+  `.removed` folder, where no plug-in reaches them, and the next removal of a plug-in with that id deletes them.
+  `plugin.remove` with the id of a plug-in that isn't installed deletes the storage kept for that id, when there is
+  any.
+  `plugin.clearCache` empties the cache and leaves the settings, and `plugin.list` and
+  `plugin.info` give the cache's size as `cacheBytes`.
+- Without a `Plug-ins` folder (the web build, and embedders that attach none) the storage calls return `-5`.
+
 ### Manifest
 
 ```json
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index fc08aac09..bc2b81b90 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -209,7 +209,7 @@ dominate; 3D, graphs and automation are specialist). They sum to 105. Feature de
 | Image Trace, graphs, image tools | 3 | 75% | graph Column designs, Image Trace Create Strokes depth (Create Object Mosaic is done; junction-returning piece survival has source-generated regressions in `image-trace-quality.md`; large images trace with a warning; Auto Color keeps rare distinct colours) | 5–8 | estimated (raised from 72%); quick presets reveal adjustment controls, Properties reopens them |
 | Layers, artboards, document setup | 5 | 78% | Selected-artboard deletion is consistent across panel actions (all-selected retains artboard 1); history prunes removed indices while preserving valid multiselection; remaining:  30.0's artboard locking and colours and managing artboards from the canvas, Layers panel row context menus and Collect for Export (click-to-fit objects is done, #1227) | 5–8 | estimated (lowered from 82%: target moved); Artboard deletion keys keep artwork and the first of an all-selected set; Artboard Options' Show Center Mark and Show Cross Hairs draw on the canvas only (exports and print leave them out), regression-tested; Artboard Options' Show Video Safe Areas and Video Ruler Pixel Aspect Ratio (per artboard, native format) are done ([video display options](#evidence-what-ships-today-by-area)), score unchanged |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged); document-tab artwork hover/copy and lossless transfer tested (2026-10-22; score/hours unchanged); cached canvas reprojection preserves scale during resize, rotation and DPI changes (regression and contributor original-file evidence below; scores/hours unchanged); cached canvas dimensions match the renderer limit before cache-key creation, view construction and worker submission (regression evidence below) |
-| File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), no writing of Illustrator's editing data (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`; the distance from the path under Align to Path comes from VectorCraft's font metrics, and the fit under Gravity does not reproduce the file's layout), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
+| File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), no writing of Illustrator's editing data (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`; the distance from the path under Align to Path is measured from the top of each character's em box, half the height of the top of its H or the bottom of its font's bounding box (`tests_native::aligned_type_lies_as_far_from_its_path_as_the_file_lays_it_out`), and the fit under Gravity does not reproduce the file's layout), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
 | File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), a saved `.ai`'s editing copy without live effects on objects other than paths, compound paths and groups that qualify (at most a fill and a stroke, a non-zero fill rule when filled, no large canvas) and whose appearance and effects the art-style writer supports, and with live objects as their art (#868), FreeHand/CorelDRAW/DWG/HEIC import, textures, map art and shading in 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
 | File formats | 6 | 75% | `.ai` files open with a flattened or wrong layer structure in real cases (#951), a saved `.ai`'s editing copy without live effects on objects other than paths, compound paths and groups that qualify (at most a fill and a stroke, a non-zero fill rule when filled, no large canvas) and whose appearance and effects the art-style writer supports, and with live objects as their art (#868), FreeHand/CorelDRAW/DWG/HEIC import, 3D export; see [file-format-parity.md](file-format-parity.md); EPS legacy mesh/opacity-mask and raster comparison follow-up verified | 10–20 | estimated (lowered from 85%: open issues); DXF control-point SPLINE import closure regression-tested (#1299 follow-up after #1320); PDF writer metadata, reader streaming and immutable backend checks in `crates/pdf/src/tests.rs`, `crates/pdf/src/tests/reader_streaming.rs` and `xtask/src/pdf_deps.rs`; PDF Place and clipboard paste retain live text (synthetic regressions); SVG CSS classes survive export and repeated import in all four styling modes (#2480); current-main integration retains event attributes and scripts; EPS ordinary Save retains the page frame and editable document (2026-10-26); `.ai`/EPS editing data checked against a user's files (2026-10-30): case setting (`ate::tests`, `tests_native::type_from_the_text_document_keeps_its_case_setting`), placed-file placements (`tests_native::a_small_placed_file_goes_where_it_draws_closer_to_the_page`), pages cropped to the art (`tests_native::type_on_the_copies_of_a_page_cropped_to_the_art_is_read_once`), mesh corner weights and state (`ai::mesh::tests::corners_with_handle_weights_of_zero_are_read`, `ai::tests::a_gradient_mesh_takes_the_transparency_written_after_it`), type on a path spacing (`tests_native::type_round_a_circle_is_spaced_as_the_file_lays_it_out`), blend state (`ai::tests::a_blends_transparency_follows_its_record`); scores and estimates unchanged. |
 | View & navigation | 3 | 70% | multiple windows and the rest of Arrange (Cascade, Float in Window, Float All in Windows) | 9–14 | estimated; Window › Arrange › Tile and Consolidate All Windows done (score/hours unchanged); document-tab artwork hover/copy and lossless transfer tested (2026-10-22; score/hours unchanged); cached canvas reprojection preserves scale during resize, rotation and DPI changes (regression and contributor original-file evidence below; scores/hours unchanged) |
@@ -549,7 +549,7 @@ since 2026-10-01.
 - **Transform effect options (#885):** Effect › Distort & Transform › Transform… has visible Transform Objects, Transform Patterns and Scale Strokes & Effects checkboxes (`distort.transform` params `objects`, `patterns`, `strokes`; files without them draw as before). With Transform Objects off the geometry stays and makes no copies; Scale Strokes & Effects scales stroke weights, dashes and the fills' and strokes' effect distances by the mean scale, and Transform Patterns moves pattern tiles, each copy `k` by the transformation `k` times. Such objects draw, export and expand through the same per-copy art, so the canvas and Expand Appearance agree (engine `tests_transformfx`, effects `tests_transformfx`, the dialog test). A Transform effect in a fill's or stroke's own effects applies the same options to that fill or stroke: its weight and dashes, the distances of its later effects and its pattern follow the transformation, and with copies each copy is an object of its own; the canvas, export, Expand Appearance and Use Preview Bounds use the same art (effects `tests_transformfx`). Not yet: object effects after a Transform effect keep their distances. Public reference: [Scale objects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/scale-objects.html), [How to apply effects](https://helpx.adobe.com/illustrator/using/effects.html), [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html). Scores and hours unchanged.
 - **Warp Options (#1760):** Effect > Warp and existing Appearance effect links share the fifteen existing styles, original schematic previews, orientation choices and percent Bend/Distortion controls. Focused tests passed for real numeric entry and slider input, Preview/Cancel, immediate Enter/OK, mixed-style edits, target/slot/visibility preservation and Undo/Redo. Each applied style stays unchanged until an explicit Style choice. Original style-menu and live-preview captures were reviewed; their numeric values were supplied programmatically. Public references: [Reshaping with effects](https://helpx.adobe.com/illustrator/using/reshaping-objects-effects.html) and [Using effects](https://helpx.adobe.com/illustrator/using/effects.html). Warp geometry, optional Properties integration and remembered defaults are unchanged; no broader parity claim.
 - **Distort Appearance with Transform effect options:** with Envelope Options › Distort Appearance on, a path whose Transform effect has Scale Strokes & Effects or Transform Patterns on, or copies it with a gradient, is bent as the same per-copy art it draws and expands as outside the envelope: each copy's own stroke weight, dashes, pattern placement and gradient (effects `bake::tests`). Scores and hours unchanged.
-- **Placed gradients follow Transform and Free Distort effects:** a gradient placed with the Gradient tool moves, turns and scales with the object when the object's Transform effect moves its outline, and each copy of the Transform effect takes it as many times as it takes the transform. Under Free Distort it moves and scales from the path's bounds before the effect to its bounds after it. This holds on the canvas, in export, in Expand Appearance, in Pathfinder and compound shapes, and in Object › Expand of the fill, for an object's own effects, a group's (the own fills of the group, of the groups inside it, of a symbol's art, and of the images and symbol instances it moves, included) and a fill's or stroke's own. A gradient on a path inside a group with a Transform effect now moves with the path (#2214 moved only the gradients of type), and so does a gradient on an image's or symbol instance's own fill. When a path keeps its shape because the effect would pass the geometry budget, the group's own gradients stay in place. How gradients follow each effect is VectorCraft's own rule; what each effect does to the object is described in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (effects `bake::tests::a_baked_transform_moves_a_placed_gradient_with_the_path`, `bake::tests::a_strokes_own_transform_and_free_distort_move_its_placed_gradient`, `bake::tests::a_fills_gradient_follows_the_effects_around_its_transform_with_options`, `bake::tests::baked_free_distort_moves_placed_gradients_from_the_bounds_to_the_distorted_bounds`, `group::tests::a_groups_transform_and_free_distort_move_the_gradients_placed_on_its_paths`, `group::tests::a_groups_transform_moves_the_gradient_of_its_own_fill`, `group::tests::a_nested_groups_own_gradient_follows_the_outer_groups_transform_and_free_distort`, `group::tests::a_groups_transform_moves_the_gradients_placed_on_an_images_own_fills`, `group::tests::shape_art_moves_gradients_with_a_transform_effect`, `group::tests::shape_art_moves_the_gradient_of_a_symbol_instances_art_with_its_transform`, `tests::art_past_the_budget_keeps_its_own_gradients_in_place`; render `objectfx::a_paths_gradient_moves_with_its_transform_and_free_distort`; engine `objexpand::a_placed_gradient_moved_by_a_transform_or_free_distort_expands_as_the_canvas_draws_it`). Scores and hours unchanged.
+- **Placed gradients follow Transform and Free Distort effects:** a gradient placed with the Gradient tool moves, turns and scales with the object when the object's Transform effect moves its outline, and each copy of the Transform effect takes it as many times as it takes the transform. Under Free Distort it moves and scales from the path's bounds before the effect to its bounds after it. This holds on the canvas, in export, in Expand Appearance, in Pathfinder and compound shapes, and in Object › Expand of the fill, for an object's own effects, a group's (the own fills of the group, of the groups inside it, of a symbol's art, and of the images and symbol instances it moves, included) and a fill's or stroke's own. A gradient on a path inside a group with a Transform effect now moves with the path (#2214 moved only the gradients of type), and so does a gradient on an image's or symbol instance's own fill. When a path keeps its shape because the effect would pass the geometry budget, the group's own gradients stay in place; a hidden path in a layer, which the layer's bounds leave out, does not hold them. A freeform gradient whose points were edited moves its points in the same way. How gradients follow each effect is VectorCraft's own rule; what each effect does to the object is described in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (effects `bake::tests::a_baked_transform_moves_a_placed_gradient_with_the_path`, `bake::tests::a_strokes_own_transform_and_free_distort_move_its_placed_gradient`, `bake::tests::a_fills_gradient_follows_the_effects_around_its_transform_with_options`, `bake::tests::baked_free_distort_moves_placed_gradients_from_the_bounds_to_the_distorted_bounds`, `group::tests::a_groups_transform_and_free_distort_move_the_gradients_placed_on_its_paths`, `group::tests::a_groups_transform_moves_the_gradient_of_its_own_fill`, `group::tests::a_nested_groups_own_gradient_follows_the_outer_groups_transform_and_free_distort`, `group::tests::a_groups_transform_moves_the_gradients_placed_on_an_images_own_fills`, `group::tests::shape_art_moves_gradients_with_a_transform_effect`, `group::tests::shape_art_moves_the_gradient_of_a_symbol_instances_art_with_its_transform`, `tests::art_past_the_budget_keeps_its_own_gradients_in_place`, `tests::a_hidden_path_past_the_budget_leaves_a_layers_gradients_free_to_move`, `tests::edited_freeform_points_follow_a_transform_effect_and_free_distort`; render `objectfx::a_paths_gradient_moves_with_its_transform_and_free_distort`; engine `objexpand::a_placed_gradient_moved_by_a_transform_or_free_distort_expands_as_the_canvas_draws_it`). Scores and hours unchanged.
 - **Constrain Angle (#394):** General › Constrain Angle turns the arrow keys' axes (guides stay on the page's), holds Shift drags of the Selection, Direct Selection, Free Transform, Slice Selection, Reshape and Measure tools and the Pen's handles to the turned axes, and new rectangles, rounded rectangles, ellipses, grids, point and area type, Shift-drawn polygons and stars and the shape size dialogs are drawn along it with their bounding box turned; 0° and whole turns are exactly as before, quarter turns exact (<https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/rotate-objects-by-specific-angles.html>). Tests: `tests_constrain_tools`, `tests_constrain_new` (engine), `geom` `constrain_axes` / `rotate_deg`, the shape, grid and type tool tests.
 
 - **Clipping paths on their outline (G1):** the selection tools (Selection, Direct Selection, Group Selection), Object Highlighting and a right-click take a clipping path on its outline before the art it clips; Select Behind lists the same; the eyedropper, the tools that act on what is drawn and the selection tools' double-clicks, loaded text and guide release take the art. Doc and tool regression tests; score unchanged.
@@ -729,6 +729,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool. Native menus explicitly end tracking on command selection, outside window presses and Escape; menu updates wait until tracking ends, and a dismissing press never starts a canvas gesture (M14.8).
   - The errors of the blend spine commands (Move Spine Point, Reshape Spine Segment, Add Spine Point and Delete Spine Point) show in the status bar in the interface language: each has a row in every catalog that translates all status and error messages and in Bulgarian (`blend_spine_param_errors_are_translated`).
   - The errors of the parameter checks that many commands share show in the status bar in the interface language: a value that is not a number where a number goes (`object.move` with `"dx": "60 mm"`, and `object.rotate`, `object.setBounds` and the other commands that call `check_numbers`), a missing number or index, `ids` that are not a list of object ids, an object id that is not a non-negative integer or names no object, and a date that is not Unix seconds. Each has a row in every catalog that translates all status and error messages, and in Bulgarian, Danish, Indonesian and Dutch (`shared_param_check_errors_are_translated`).
+  - Commands that read their `ids` (or `slices`) list themselves refuse a list with an entry that is not a non-negative integer, and a value that is not a list, and change nothing; they no longer drop the entry and act on the rest (Copy Appearance From, the Edit Colors commands and Overprint Black, Find and Replace, `layer.highlight`, `layer.move`, `library.add`, the Links panel commands, `object.transform`, Make Pattern, the Repeat commands, the slice commands, Join, Average and Join, `plugin.run`, `symbol.edit`, Make Opacity Mask; `tests::ids_without_selection::an_ids_entry_that_is_not_an_id_is_refused_and_changes_nothing`). The error for an entry of an object id list names the key, the entry and its value ("`ids` entry 1 is true, not a non-negative integer object id"), with a row in every catalog that has the other object id errors.
   - The errors of Enter Isolation Mode (`object.isolate`) for a type object, for hidden or locked art and for a call with no `id` while nothing is selected ("missing id", which other commands that take an `id` also give), and the error of the Layers panel's target circle (`layer.target`) for an object outside the isolated group, show in the status bar in the interface language: each has a row in every catalog that translates all status and error messages, and in Bulgarian, Danish, Indonesian and Dutch.
   - An EPS or PostScript file that stops on a PostScript error gives the error's name as PostScript spells it (`typecheck`, `rangecheck` and the other names the reader raises, except `undefined`, whose message names the unknown name) followed by what it means, in the warning after opening and in the error when the file can't be opened. The status bar and the open-error dialog show the meaning in the interface language: each meaning has a row in every catalog (`postscript_error_meanings_are_translated`).
   - The macOS menu bar is built from the in-window menus (one model, `native_menu`) and laid out as a Mac app's: the VectorCraft menu holds About, Settings ▸ (each Preferences page, General… ⌘K), Language ▸, Appearance ▸ (UI brightness), Services, Hide VectorCraft ⌃⌘H (⌘H stays Hide Edges), Hide Others, Show All and Quit; Window gains Minimize ⌃⌘M, Zoom and Bring All to Front, and Help the system's search field. Its key equivalents go back to egui as key presses, so user shortcuts, focused text fields and the Type tool's input method behave as in the window, and nothing fires twice; enabled, check marks and labels update in place. `--in-window-menus` or `VECTORCRAFT_IN_WINDOW_MENUS=1` keeps the menus in the window; `ui.inspect` reports `nativeMenuBar`.
@@ -1059,6 +1060,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   Object › Flatten Transparency, the Flattener Preview, and EPS, PDF and print output that flatten transparency stop building a group's flat regions at the first region past the raster/vector balance's limit (10^(balance/20), rounded down) and rasterize the whole group without building the remaining regions. Building every region gives the same flattened art and the same files. With Clip Complex Regions on, a group builds every region and its image is clipped to them.
   New Symbol and Redefine Symbol on a frame of threaded text take it out of the thread with the text it shows, which the symbol's art holds, and the other frames keep the text they hold. When the last frame goes into the symbol, the text it has no room for goes after the text of the last frame that stays. When every frame of a thread goes into the symbol, the copy of the last frame keeps all its text.
   With Optical Margin Alignment on, or Roman Hanging Punctuation on in the first paragraph, the glyphs at the ends of left-to-right type on a path hang outside its brackets, measured along the path. The type hangs at the start bracket when its line is placed there, hangs at the end bracket when the line is placed there, and hangs at both when it is centered. Glyphs that hang past the end bracket do not make the type overflow, and a hang stops at an open path's end. SVG export writes such type as outlines.
+  Type on a Path Options › Align to Path (option names as in [Create type on a path](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/create-type-on-a-path.html)) moves each character by its own font, size and vertical scale: Ascender runs the top of the font's em box along the path (the ideographic em box that its `BASE` table, its typographic or `hhea` box or its ideographs give, else an em box centered on the cap height), Descender runs the bottom of the font's bounding box along it, and Center runs a line at half the height of the top of the font's H above the baseline along it. In vertical type, Ascender and Descender move the characters half an em, and Center leaves them on the path. These distances are VectorCraft's own values (`tests::on_path_align_runs_each_glyph_by_its_own_metrics`, `tests::on_path_align_finds_the_em_box_of_each_kind_of_face`, `tests::on_path_align_in_vertical_type_moves_half_an_em`).
   The frames of threaded text share one Optical Margin Alignment setting: turning it on or off in one frame sets it in every frame, threading frames gives the thread its first frame's setting, and frames taken out of a thread keep it.
   The frames of threaded text share one writing direction: Type › Type Orientation (`type.orientation.vertical`, `type.orientation.horizontal`) in one frame sets every frame, threading frames gives the thread its first frame's direction, frames taken out of a thread keep theirs, and the story flows through every frame in the thread's direction.
   Type › Optical Margin Alignment (`type.opticalMarginAlignment`) hangs the punctuation and letter edges at the ends of a type object's lines outside its margins: at the left of left-aligned lines, at the right of right-aligned lines, and at both ends of centered and justified lines, in point and area type of left-to-right paragraphs. Quotation marks, hyphens, full stops and commas hang wholly; asterisks, tildes, ellipses, en and em dashes, colons and semicolons hang by half; and A, V, W, Y, v, w and y hang by a tenth of their width. It is off by default and saved with the type object. Justification's Glyph Scaling leaves the glyphs that hang at their width, so they hang exactly their share, and Standard burasagari counts what hangs at a line's start as room before hanging a comma; `crates/text/src/tests/hang.rs` checks whole paragraphs with both composers, ragged, centred and justified, with Line-end Punctuation Half Width and bidirectional lines.
@@ -1157,7 +1159,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Colorized images (#1466):** a fill color applied to a selected grayscale or 1-bit image (`paint.setFill`) colorizes it with black, white, a process color or a spot color, and refuses a process color when the image has an alpha channel ([Convert color modes](https://web.archive.org/web/20251220223850/https://helpx.adobe.com/illustrator/desktop/manage-colors/select-and-adjust-colors/convert-color-modes.html), "Colorize Grayscale or 1-bit images"); black and white are accepted there too. The canvas draws each pixel in the color as far as the pixel is dark, with white pixels transparent; PDF export writes the image in the color (a spot color as its ink, Registration in every ink) with the image as its soft mask; Separations Preview and printed separations show it on its color's plates; native files keep the color. EPS and SVG write the image's own pixels.
   - **Missing library files:** a persistent swatch or graphic style library panel whose file is gone at startup reopens and stays in the preferences, showing the file's path with Locate Library… (`ui.libraryPanel.locate`), which reads the file from where it is now into the same panel.
   - **Swatch library and Recolor Artwork parameters:** the `swatch.library.*` commands, `swatch.resetDefaults`, the graphic style library save, load and add, the `recolor.*` commands and `color.harmony`'s `limitTo` refuse parameters of the wrong form, such as `names: "Grays"`, `limitTo: 5` or `includeImages: "false"`. Errors name the parameter, except that a `limitTo` that is not a string, such as `5`, gets an unknown-library error. A `null` counts as left out except for `recolor.apply`'s `model`, which must be a string when given.
-  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel shows a selected colour in its own model and, with nothing selected, the new-art defaults in the mode picked last, which it keeps between sessions; Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers (the Properties panel has the Control bar's Fill and Stroke chips, Stroke link and weight spinner, with nothing selected too), panels have Illustrator's Window menu keys (Align Shift+F7, Transform Shift+F8, Pathfinder Cmd+Shift+F9, Layers F7, Character Cmd+T…; every panel can be given one in Edit › Keyboard Shortcuts), and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). An ICC CMYK profile converts straight into the RGB working space (not through sRGB, so a wider space such as Wide Gamut RGB keeps colours sRGB can't hold) with the colour settings' black-point compensation, on the canvas and in RGB exports alike (the built-in Generic CMYK compensates both ways, so RGB black separated to a rich black displays as black again). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB greys separate into four-colour greys and a rich black as Illustrator does, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
+  - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel shows a selected colour in its own model and, with nothing selected, the new-art defaults in the mode picked last, which it keeps between sessions; Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers (the Properties panel has the Control bar's Fill and Stroke chips, Stroke link and weight spinner, with nothing selected too), panels have Illustrator's Window menu keys (Align Shift+F7, Transform Shift+F8, Pathfinder Cmd+Shift+F9, Layers F7, Character Cmd+T…; every panel can be given one in Edit › Keyboard Shortcuts), and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). An ICC CMYK profile converts straight into the RGB working space (not through sRGB, so a wider space such as Wide Gamut RGB keeps colours sRGB can't hold) with the colour settings' black-point compensation, on the canvas and in RGB exports alike (the built-in Generic CMYK compensates both ways, so RGB black separated to a rich black displays as black again). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening. Document Color Mode converts the art, symbols, pattern tiles and swatches through the colour settings: Gray stays Gray, RGB grays separate into light grays in cyan, magenta and yellow only, darker four-color grays and a rich black, or go on the black plate only with `grays: "black"` (also for `document.open {colorMode}`).
     Plain Comma and Period, and also Shift+Comma and Shift+Period, apply the last solid color and the last gradient to the active Fill or Stroke proxy in VectorCraft ([Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html), "Select color fill mode" and "Select gradient fill mode").
     Recent Colors keeps the last 30 solid colors applied, newest first and each once, and the list stays the same when another document is opened or made active; a 31st color drops the oldest ([Select colors using the Color panel](https://helpx.adobe.com/illustrator/desktop/manage-colors/select-and-adjust-colors/select-colors-using-the-color-panel.html)). The list lasts for the session. In the Color and Swatches panels the chips wrap onto further rows when the panel is too narrow for one row (`paint.recent`). Tests: `recent_colors_keep_thirty_colors_across_documents` in `crates/engine/src/tests/paintproxy.rs`, `all_thirty_recent_colors_wrap_into_a_narrow_panel` in `crates/ui-egui/src/panels/color/tests.rs`.
     A Cmd/Ctrl-click on the Color panel's spectrum applies Complement and a Cmd/Ctrl+Shift-click applies Invert to the active Fill or Stroke (`paint.complement`, `paint.invert`); with Alt also held, the click recolors the inactive one, as the reference app's [Default keyboard shortcuts](https://web.archive.org/web/20260726060015/https://helpx.adobe.com/illustrator/using/default-keyboard-shortcuts.html) list them.
@@ -1175,8 +1177,9 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - **Pasting into hex color fields:** in the hex fields of the Color Picker, Swatch Options, Recolor Artwork, the Color panel, Document Setup, Duotone, Color Themes and Perspective Grid, a click or keyboard focus selects the digits. A pasted code of six digits, with or without `#`, replaces them wherever the caret is. A pasted code of three digits also replaces them, unless the paste holds only those digits and exactly three digits stay; those digits then edit the text in place. A press on another field commits the text as Tab and Enter do. As VectorCraft's own rule, a paste that is not a color leaves the field as it was. Tests: `a_hex_code_pasted_into_the_hex_field_replaces_its_digits` in `crates/ui-egui/src/dialogs/tests.rs`, `define_grid_takes_a_three_digit_color` in `crates/ui-egui/src/dialogs/tests_perspective.rs` and `a_paste_into_a_hex_field_replaces_or_edits_its_digits` in `crates/ui-egui/src/tests/numfields.rs`.
   - **Color Picker layout (#2008):** a centered draggable header, equal-width actions above aligned HSB/RGB/Hex and Lab/CMYK fields, compact field and slider, and warnings below the preview. No horizontal scrolling; narrow windows stack the sections with vertical scrolling. Tests in `dialogs/color_picker.rs` cover actual pointer/key input, typed values before OK/Enter, Cancel/Escape rollback, one Undo step, mode-size stability, warnings and layout at two UI scales. The screen sampler sits above the field and the upstream two-grid Tab order is retained. AccessKit regressions check the action names and each channel slider's displayed value, units and range. German and enlarged English UI renders were reviewed locally; no reference images are shipped. This is a layout improvement, with no change to scores or remaining-hour estimates.
   - **Eyedropper sources (#1251):** ordinary and Shift clicks, Shift+Alt appearance append, raster pixels and gradient-stop sampling can read visible locked/template art and sources outside isolation. Sampling leaves the source and selection intact; Alt reverse still uses editable hits, and hidden art stays excluded. Engine/tool/hit regressions cover the editing boundary, color models and one-step Undo/Redo. The general object/image workflow is described in [public HelpX](https://helpx.adobe.com/illustrator/using/tool-techniques/eyedropper-tool.html); the lock/isolation expectations come from the user report and these regressions, without a new full-parity measurement.
-  - **Eyedropper colors in a CMYK document (#2276):** a CMYK image (a four-component JPEG, or an 8- or 16-bit chunky CMYK TIFF) gives its ink amounts as they are, and an RGB image's pixel or an RGB color given to `paint.setFill`, `paint.setStroke`, `paint.sampleColor` or `swatch.new {color}` (hex input and gradient stops included) is separated through the color settings' CMYK working space and intent, as Document Color Mode converts it. With the default Generic CMYK, RGB 83/170/223 separates to C59 M12 Y3 K0, where the profile-free formula gave C63 M24 Y0 K13.
-  - **RGB input to other commands in a CMYK document:** type colors (`text.create`, `text.setStyle`, `text.setRangeStyle`), a Shape Builder hex fill, `paint.editGradient` stops, freeform gradient points, gradient mesh points (the Mesh tool gives a new point the fill's color in its own model), the Symbol Stainer's color and the swatch commands (`swatch.new {colors}`, `swatch.newGroup`, `swatch.editGroup`, `swatch.edit`) separate RGB through the color settings as `paint.setFill` does: with Generic CMYK, `text.setStyle {fill: "#53aadf"}` gives C59 M12 Y3 K0. A color a swatch already has keeps its model, and a swatch color given with `mode` is converted into that mode only.
+  - **Eyedropper colors in a CMYK document (#2276):** a CMYK image (a four-component JPEG, or an 8- or 16-bit chunky CMYK TIFF) gives its ink amounts as they are, and an RGB image's pixel or an RGB color given to `paint.setFill`, `paint.setStroke`, `paint.sampleColor` or `swatch.new {color}` (hex input and gradient stops included) is separated through the color settings' CMYK working space and intent, as Document Color Mode converts it. With the default Generic CMYK, RGB 83/170/223 separates to C62 M19 Y0 K0, where the profile-free formula gave C63 M24 Y0 K13.
+  - **RGB input to other commands in a CMYK document:** type colors (`text.create`, `text.setStyle`, `text.setRangeStyle`), a Shape Builder hex fill, `paint.editGradient` stops, freeform gradient points, gradient mesh points (the Mesh tool gives a new point the fill's color in its own model), the Symbol Stainer's color and the swatch commands (`swatch.new {colors}`, `swatch.newGroup`, `swatch.editGroup`, `swatch.edit`) separate RGB through the color settings as `paint.setFill` does: with Generic CMYK, `text.setStyle {fill: "#53aadf"}` gives C62 M19 Y0 K0. A color a swatch already has keeps its model, and a swatch color given with `mode` is converted into that mode only.
+  - **Generic CMYK (SWOP-like):** each ink's 40% and 50% tints gain as [CGATS TR 001](https://registry.color.org/cmyk-registry/cgats_tr_001) gives for SWOP printing, and separations stay within SWOP's [300% total ink limit](https://en.wikipedia.org/wiki/Specifications_for_Web_Offset_Publications). The paper, solid and overprint colors, the black-generation curve and the black point are VectorCraft's own values: RGB black separates to 90% black under neutral cyan, magenta and yellow that fill the ink limit (C75 M68 Y67 K90).
   - **Swatches made from a shown color in a CMYK document:** the Color panel menu's Create New Swatch, an Alt-click on the Swatches panel's New Swatch button, the New Swatch dialog for a gradient, a Fill or Stroke proxy or the Gradient panel's thumbnail dropped on the Swatches panel (or Alt-dropped on a swatch of its kind), and the Gradient panel's Add to Swatches and Save to Swatches keep each color's model, as the Color Guide's and Color Themes' saved colors do: an RGB object's color gives an RGB swatch, and a gradient's RGB stops stay RGB.
   - **Sample Color from Screen:** an eyedropper button in the Color Picker and `ui.sampleScreenColor` (which can be given a key in Keyboard Shortcuts) pick a color anywhere on the screen with the system's sampler: `NSColorSampler` on macOS, the EyeDropper API in browsers that have it. The color becomes the fill or the stroke as one undo step, or the Color Picker's color, converted from display sRGB into the working RGB space. Windows, Linux and other browsers have no sampler yet; the button is gray there.
   - **Stroke visibility (#1253):** adding paint to a previously unpainted zero-width stroke restores the existing 1 pt default (`PaintDefaults::default`, `Appearance::set_stroke`), for the selected appearance item, the new-art defaults and Swap Fill/Stroke. Positive widths are kept; recoloring a painted zero-width stroke keeps its explicit zero. A real Eyedropper-to-new-shape sequence reproduces the zero-width inheritance. Five engine regressions cover creation, defaults, targeted items, preserved widths and one-step Undo/Redo (`crates/engine/tests/it/stroke_visibility.rs`).
@@ -1323,6 +1326,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
     `document.open`, `file.place` and `document.pdfInfo` reject a `cropTo`, `crop`, `password`, `colorMode` or `textAs` that is not a string, such as `"textAs": true`, and `document.pdfInfo` rejects a `thumbnailSize` that is not a number; the error names the param, and nothing opens or is placed. A param left out or given as null keeps its default (`crates/engine/src/cmd/fileio/tests_pdfimport.rs`).
     When the PDF content of a `.ai` has a page for each artboard, the layers are compared with every page on its artboard (until the pages compared take 8,388,608 pixels at the comparison's scale, about 67 letter-size pages, or number 128): art that only the layers or only a later page draws is handled as art that differs on the first page is, and a text object that a later page doesn't draw is left out unless its layer doesn't print (`crates/eps/src/import/tests_native.rs`).
     When the editing data of a `.ai` or EPS is for a page of another size than the file's, the warning that its layers weren't read gives both sizes in points, and the scale of the editing data's page to the file's page (1:10 for a tenth of its size) when their sides are in proportion (#2034; `crates/eps/src/import/tests_native.rs`).
+    A `.ai` or EPS opened from its editing data keeps its layers when it embeds an image of more than 2^25 pixels (part of #1479). The image comes in at full size up to a target size (2^26 to 2^28 pixels on the desktop, by installed memory; 2^27 on the web), a 1-bit gray image as a 1-bit PNG. A larger image is averaged down by the smallest whole step that fits, a 1-bit one into shades of gray, with a note giving both sizes. An image of more than 2^31 pixels or 512 MiB of samples is an object the reader can't read, so its box comes in as the page's art; without page art, it is left out with a note (`crates/eps/src/import/tests_native.rs`).
     A `.ai`, or a PDF saved with Illustrator's editing data, whose editing data can't be decompressed opens from its PDF part with a warning that its layers weren't read and why, and an export or Save As to its own path asks first (`acknowledgeLoss`), as for a file whose layers the reader can't read (`crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` or EPS opened from its editing data with one object on a shown layer that the reader can't read (an unknown operator inside a group, a pattern fill whose pattern it doesn't have, a symbol instance, a placed file without a usable preview) keeps its layers and groups: in that object's place, its layer gets a group of the page's objects inside the object's box, named after it, with a warning that lists what came in as the page's art and an export or Save As to its own path asking first (`acknowledgeLoss`). The file still opens from its page or PDF part when no box can be found, when live art or another unread object shares the page art inside it, when the object spans two artboards or lies on an artboard that has no page, when no page art lies inside its box, when that page art is inside a page group with a clip, mask, transparency or appearance, when the object holds a frame of threaded type, when the page art uses a pattern, image or swatch that the page lacks or that differs from the editing data's, or when the page art doesn't carry the object's transparency (#4806; `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
     A `.ai` or EPS opened from its editing data with one object on a shown layer that the reader can't read (an unknown operator inside a group, a pattern fill whose pattern it doesn't have, a symbol instance, a placed file without a usable preview) keeps its layers and groups: in that object's place, its layer gets a group of the page's objects inside the object's box, named after it, with a warning that lists what came in as the page's art and an export or Save As to its own path asking first (`acknowledgeLoss`). The file still opens from its page or PDF part when no box can be found, when live art or another unread object shares the page art inside it, when the object spans two artboards, or when the page art doesn't carry the object's transparency (#4806; `crates/eps/src/import/tests_native.rs`, `crates/engine/src/cmd/fileio/tests_aiimport.rs`).
@@ -1389,6 +1393,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
   - Missing linked files can be looked for in a folder and its subfolders: Find in Folder… in the Linked File Not Found dialog and in the Links panel menu lists the files with each one's name, those with the size and contents saved with the link first, and relinks the files chosen, copying an image's file into the document's folder when asked, without replacing a file there (`links.findFiles`, `links.relink {copy}`). In the Links panel it looks for the selected linked files when any are selected.
   - The Links panel's Relink… opens a Relink dialog whose Replace menu picks which links take the new file: Selected Instances (the selected images, as before), All Instances (every image linked to the same file), Missing Links from This Folder (then every other missing link whose file name is in the new file's folder) and Each Link Separately (a file for each selected link in turn). Each relinks as one undo step (`links.relink {scope}`, `ui.relinkDialog`). Relink to Folder… stays as it is.
   - Linked files inside symbols, graph designs, patterns and opacity masks are saved with their paths relative to the document, as linked files in the layers are, so they are found after the document and its files move to another folder together; on open each of those links takes the path where its file was found. Update Links, and opening with Update Links: Automatically, read a modified file again for that art too, and saving a document refreshes its placed copies inside symbols and patterns of the other open documents. Evidence: `links_outside_the_layers_find_their_files_after_the_folder_moves`, `update_links_reads_files_again_inside_symbols_patterns_and_masks`, `saving_a_document_refreshes_its_placed_copies_inside_symbols_and_patterns`.
+  - A linked file that is missing when a moved document is saved keeps the folder its relative path names, instead of a relative path worked out from the out-of-date absolute path, also for a `.ai` file another app wrote (such as `src/`), so the file is found once it is back in that folder. Evidence: `a_missing_link_keeps_its_relative_path_when_the_moved_document_is_saved`, `links_of_an_imported_file_are_found_by_their_relative_folder`, `a_missing_link_of_a_moved_document_keeps_its_relative_place`.
   - On Windows, a document opened from a mapped network drive finds its links stored with the share's own path (`\\server\share\…`), as the same document opened from the share does; links on other computers stay missing.
   - On Windows, a link on a drive mapped to a network share other than the document's (`Y:\…`) is missing, with the reason that the path is on another computer, as a link stored with that share's own path is; links on this computer's drives and on the document's share are followed.
   - In the Links panel, Shift-click selects a range of links and Ctrl/Cmd-click adds or removes one.
@@ -1535,6 +1540,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
 - **Plug-in permissions (G17):** a manifest may list `permissions` (`doc.read`, `doc.write`, `state`, `effect.render`, `export.write`; the first three follow storytold/photocraft#662) and an `api` level; without the list a plug-in gets what its kind implies and installs as before. Install Plug-in… and File › Open show the name, id, version, file SHA-256 and each permission in plain words, with control and bidirectional characters escaped, and install nothing on Cancel; `plugin.install` needs `grant`, and folders install only granted plug-ins. The grant is kept with the module's hash, a module asking for more asks again, and a filter run refuses output its permissions don't allow. Regressions: `crates/plugins/src/permissions.rs`, `crates/plugins/src/manifest.rs`, `crates/engine/src/tests/plugins.rs`, `crates/engine/tests/plugin_fuzz.rs`, `crates/ui-egui/src/tests/plugins.rs`. Scores and hours unchanged.
 - **Plug-in grants cover one module (G17):** a grant counts only for the module with the id and SHA-256 it records. A module with other bytes under the same id needs a new approval, even with the same permissions: `plugin.inspect` reports `needsApproval`, `plugin.install` refuses it without `grant`, Install Plug-in… and File › Open ask again, and the plug-in store and plug-in folders skip it. A grant with a malformed hash covers nothing. Regressions: `crates/plugins/src/permissions.rs`, `crates/engine/src/tests/plugins.rs`, `crates/ui-egui/src/tests/plugins.rs`. Scores and hours unchanged.
 - **Plug-in progress, Cancel and log lines (G17):** at plug-in API level 2 a plug-in with the `progress` permission imports `env.vc_progress`, `env.vc_cancelled` and `env.vc_log`. A heavy filter's and an export's progress windows show its progress as a percentage bar, their Cancel reaches it through `vc_cancelled`, and its log lines go to the app's log with its id, capped per line and per run. Installing checks every import and names the one it refuses. Regressions: `crates/plugins/src/host.rs`, `crates/plugins/tests/abi.rs`, `crates/engine/src/tests/plugins.rs`, `crates/engine/tests/plugin_fuzz.rs`, `crates/ui-egui/src/tests/plugin_runs.rs`. Scores and hours unchanged.
+- **Plug-in settings and cache (G17, #2191):** at plug-in API level 2 a plug-in with the `settings` permission keeps settings of its own (`env.vc_settings_get`, `_set`, `_delete`) and one with `cache` a cache the user can clear (`env.vc_cache_read`, `_write`, `_clear`), under its id in the `Plug-ins` folder. Keys are plain names, never paths; VectorCraft's own caps refuse a write past 256 settings, 1 MiB of settings or 512 MiB of cache; a damaged settings file is moved aside and the settings start empty. `plugin.clearCache` empties a cache, `plugin.list` and `plugin.info` give `cacheBytes`, replacing a plug-in keeps its storage and `plugin.remove` deletes it. Another module under an id that is installed or has storage installs only with `replace: true`, which the app asks the user for; each storage call counts the whole settings file or cache entry it reads and writes toward the run's 1 GiB. Regressions: `crates/plugins/src/storage.rs`, `crates/plugins/tests/abi.rs`, `crates/engine/src/tests/plugins.rs`, `crates/engine/tests/plugin_fuzz.rs`. Scores and hours unchanged.
 
 - **Plug-in effects after a plug-in changes:** when a plug-in is installed for the first time, installed again or removed (`plugin.install`, `plugin.reload`, `plugin.remove`, File › Open of a `.wasm` file, the Additional Plug-ins Folder preference), the next frame the canvas draws uses the plug-ins then installed for objects with a plug-in effect and their raster effects, for the blends, envelopes and repeats that show such objects, and for pattern tiles and symbol instances whose art holds one.
 
@@ -1808,6 +1814,10 @@ Cmd/Ctrl+Alt+. (`stroke.weightUp`) and Cmd/Ctrl+Alt+, (`stroke.weightDown`) rais
 
 Edit › Keyboard Shortcuts lists every item of the Effect menu under its menu path (Effect › Distort & Transform › Transform…) and gives each one a shortcut of its own (stored as `effect:<id>`; they all run `effect.dialog {effect}`, or `effect.apply` for an effect without options, so a shortcut on the command alone couldn't tell them apart). The menu shows the shortcut, and pressing it opens that effect's dialog for the selection (#3296). Test: `shortcuts::tests::an_effect_menu_item_takes_a_shortcut_of_its_own`.
 
+A live-effect plug-in installed while the app runs gets its Effect › Plug-ins row in Edit › Keyboard Shortcuts, in `shortcuts.list` and in a Keyboard Shortcuts dialog that is already open, and its key runs it. A removed plug-in's row goes away and its key runs nothing; the shortcut stays saved and applies again when a plug-in with the same id is installed, opening the effect's dialog if the new one has options and applying the effect if it has none. Tests: `shortcuts::tests::a_live_effect_plugin_installed_later_takes_a_shortcut_of_its_own`, `shortcut_editor::tests::an_open_dialog_follows_live_effect_plugins`.
+
+Each installed filter plug-in's Object › Plug-ins item has a row of its own (stored as `plugin:<id>`, since every filter runs `plugin.dialog {id}`), with no default shortcut, also when two filters share a name. The menu shows its shortcut, and pressing it does what a click on the item does: it opens the filter's dialog, or runs a filter without parameters at once as one undo step (a heavy filter starts in the background). A removed filter's row goes away and its key runs nothing; the shortcut stays saved and applies again when a plug-in with the same id is installed. With no document open the key does nothing, as the dimmed item does. The command palette has one result per filter, and Import Shortcut Set offers each filter as a target without matching a row to it by name. Plug-in names stay as the plug-in gives them; the menu path is translated. Tests: `shortcuts::tests::each_filter_plugin_takes_a_shortcut_of_its_own`, `shortcuts::tests::a_filter_plugin_keeps_its_shortcut_when_replaced_or_reloaded`, `shortcuts::tests::a_heavy_filter_plugin_runs_from_its_shortcut_as_from_its_menu_item`, `shortcuts::tests::a_filter_plugin_row_translates_its_path_and_not_its_name`, `palette::tests::each_filter_plugin_is_a_result_of_its_own`, `dialogs::tests_shortcut_import::an_imported_shortcut_reaches_a_filter_plugin_picked_as_its_target`.
+
 ## Live Corners: arrow keys change the corner kind while dragging (2026-11-01)
 
 While a corner widget is pressed or dragged with the Selection or Direct Selection tool, the Up and Down arrows step the kind of the corners being edited (Round, Inverted Round, Chamfer, in turn, from the pressed corner's), shown live with the radius and kept, with it, as one undo step when the drag ends; a press with an arrow and no drag changes just the kind (#2898). Alt-clicking a widget still cycles it as before. Test: `tests::livecorners::arrows_while_dragging_a_corner_widget_change_the_corner_kind`.
diff --git a/docs/type-parity.md b/docs/type-parity.md
index dcf0eeaed..b7e7fffab 100644
--- a/docs/type-parity.md
+++ b/docs/type-parity.md
@@ -68,6 +68,7 @@ against Illustrator's public documentation; **estimated** unless noted.
 | CJK: East Asian Type units (Q, Ha) | done | Preferences › Units › East Asian Type (`unitsAsianType`, Points by default) offers every unit and Q and Ha, a quarter of a millimetre each ([Scripting Guide](https://ai-scripting.docsforadobe.dev/scripting/measurementUnits/): 0.709 pt per Q; [InDesign's unit notation](https://helpx.adobe.com/in/indesign/desktop/layout-and-grid-tools/rulers-and-measure-tools/change-ruler-measurement-units.html): `q`, `h`). The public pages do not say which fields follow it, so no field uses it yet and that waits for a source. Evidence: `q_and_ha_are_a_quarter_millimetre`, `east_asian_type_unit_*` |
 | CJK: manual tate-chu-yoko | done | Character panel menu › Tate-chu-yoko (`text.setFormat` / `text.setRangeStyle {tateChuYoko}`), with Show East Asian Options: marked characters stand side by side across one em of a vertical column, squeezed to the em when wider; two or three half-width digits still do so without the mark; horizontal type keeps the mark and does not move them. Tate-chu-yoko Settings… (`ui.tateChuYokoSettings`, `{tcyUpDown, tcyLeftRight}` in points) moves a marked block up or down and right or left as one piece. Evidence: `tests_vertical::manual_tate_chu_yoko_sets_marked_characters_across_one_em`, `tests_vertical::tate_chu_yoko_settings_move_a_marked_block_up_down_left_and_right`, `typecmd::tate_chu_yoko_is_a_character_attribute_saved_only_when_on`, `typecmd::tate_chu_yoko_settings_are_character_attributes_saved_only_when_set`, `dialogs::tate_chu_yoko::tests` |
 | CJK: Standard Vertical Roman Alignment | done | Character panel menu › Standard Vertical Roman Alignment (`text.setFormat` / `text.setRangeStyle {standardVerticalRoman}`), with Show East Asian Options, off by default: in vertical type the marked half-width characters (Latin letters, digits and other characters that would lie on their side) stand upright one below the other, each in its upright cell; spaces keep their width and tate-chu-yoko blocks stay across the column; horizontal type keeps the mark and does not change. Character Style Options has its own checkbox for it. Evidence: `tests_vertical::standard_vertical_roman_alignment_stands_half_width_characters_upright`, `typecmd::standard_vertical_roman_is_a_character_attribute_saved_only_when_on` |
+| CJK: composite fonts | partial | Type › Composite Fonts… (`type.compositeFonts.set`), with Show East Asian Options: a font made of a font per class of character (Kanji, Kana, Punctuation, Symbols, Roman, Numerals), each with its own style, size and baseline in percent of the type's size, Kana, Roman and Numerals with horizontal and vertical scale, and Kana with Scale at Center; New, Delete Font, Import… and Export… (`.vccomposite`, `type.compositeFonts.import` and `.export`) ([Creating composite fonts](https://help.adobe.com/archive/en_US/illustrator/cs3/illustrator_cs3_help.pdf#page=347)). Composite fonts are listed first in the font menus, saved with the document, and their type is laid out per class; SVG and legacy `.ai` write it as outlines. Not yet: custom character sets, the Units menu, Show Sample. Evidence: `text::composite::tests::characters_fall_in_their_classes`, `tests::composite::composite_type_draws_each_class_in_its_font`, `compositefonts::tests`, `dialogs::composite_fonts::tests` |
 | CJK: ruby | partial | ruby (ふりがな) for live text (`type.ruby`): a reading over a byte range, above (right of the column in vertical type) or below, start/centre/end alignment, size, overhang or squeeze; saved natively, laid out with its line growing, drawn on the canvas, in SVG and PDF (as outlines where ruby is present), in EPS, EMF/WMF and legacy `.ai` (legacy `.ai` writes type with ruby as outlines), and kept by Create Outlines, Expand Appearance and flattening, each glyph where the layout puts it (`typecmd::ruby_tests::create_outlines_keeps_the_ruby_where_it_is_laid_out`) | #633 |
 | Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Assamese and Sanskrit added, #4947; Serbian: Cyrillic, Serbian: Latin and Croatian); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). English and eleven Indian languages hyphenate by run language; Sanskrit automatic hyphenation awaits allowlisted patterns (#4947). Not yet: spelling by it, `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set`, `tests::typo::indic_language_runs_hyphenate_with_both_composers`, `hyphen::tests::sanskrit_without_allowlisted_patterns_uses_only_exceptions` |
 | Language per character (Character panel › Language, character styles), text shaped in it | done | `text.setFormat` / `text.setRangeStyle {language}` by name or BCP 47 tag, one of Document Setup's languages (Hindi, Marathi, Gujarati, Bengali, Punjabi, Tamil, Telugu, Kannada, Malayalam, Odia and Urdu added, #4943; Serbian: Cyrillic, Serbian: Latin and Croatian; Bulgarian, #5945); the shaper gets the tag, so the font's language forms apply (OpenType `locl`: Turkish keeps `fi` apart and the dot on its i, #4940); new type takes the document's language; saved as the tag only when set, carried by character styles (#4946). Not yet: hyphenation and spelling by it, `.ai`/PDF import of a text's language, paragraph styles. Evidence: `features::tests::language_picks_the_fonts_forms`, `features::tests::serbian_gets_the_fonts_serbian_forms`, `typecmd::area_tests::language_is_a_character_attribute_saved_only_when_set` |